autocommit 2022-02-07 16:43:47 CET

src/ifs/ipc/mod.rs

@@ -0,0 +1,206 @@
+use std::cell::{Cell, RefCell};
+use std::ops::{Deref, DerefMut};
+use std::rc::Rc;
+use ahash::AHashSet;
+use thiserror::Error;
+use uapi::OwnedFd;
+use crate::client::{Client, ClientId, WaylandObject};
+use crate::ifs::wl_seat::WlSeatGlobal;
+use crate::object::ObjectId;
+use crate::utils::clonecell::CloneCell;
+use crate::utils::smallmap::SmallMap;
+
+pub mod wl_data_device;
+pub mod wl_data_device_manager;
+pub mod wl_data_offer;
+pub mod wl_data_source;
+pub mod zwp_primary_selection_device_manager_v1;
+pub mod zwp_primary_selection_device_v1;
+pub mod zwp_primary_selection_offer_v1;
+pub mod zwp_primary_selection_source_v1;
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum Role {
+    Selection,
+    Dnd,
+}
+
+pub trait Vtable: Sized {
+    type DeviceId: Eq + Copy;
+    type OfferId: Copy + From<ObjectId>;
+
+    type Device;
+    type Source;
+    type Offer: WaylandObject;
+
+    fn device_id(dd: &Self::Device) -> Self::DeviceId;
+    fn get_offer_data(offer: &Self::Offer) -> &OfferData<Self>;
+    fn get_source_data(src: &Self::Source) -> &SourceData<Self>;
+    fn for_each_device<C>(seat: &WlSeatGlobal, client: ClientId, f: C)
+        where C: FnMut(&Rc<Self::Device>);
+    fn create_offer(client: &Rc<Client>, data: OfferData<Self>, id: ObjectId) -> Self::Offer;
+    fn send_selection(dd: &Self::Device, offer: Self::OfferId);
+    fn send_cancelled(source: &Self::Source);
+    fn get_offer_id(offer: &Self::Offer) -> Self::OfferId;
+    fn send_offer(dd: &Self::Device, offer: &Self::Offer);
+    fn send_mime_type(offer: &Self::Offer, mime_type: &str);
+    fn unset(seat: &Rc<WlSeatGlobal>);
+    fn send_send(src: &Self::Source, mime_type: &str, fd: Rc<OwnedFd>);
+}
+
+pub struct OfferData<T: Vtable> {
+    device_id: T::DeviceId,
+    source: CloneCell<Option<Rc<T::Source>>>,
+    client: Rc<Client>,
+}
+
+struct Attachment<T: Vtable> {
+    seat: Rc<WlSeatGlobal>,
+    role: Role,
+    offers: SmallMap<T::DeviceId, Rc<T::Offer>, 1>,
+}
+
+impl<T: Vtable> Attachment<T> {
+    fn detach_offers(&self) {
+        while let Some((_, offer)) = self.offers.pop() {
+            T::get_offer_data(&offer).source.set(None);
+        }
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum IpcError {
+    #[error("The data source is already attached")]
+    AlreadyAttached,
+}
+
+pub struct SourceData<T: Vtable> {
+    attachment: RefCell<Option<Attachment<T>>>,
+    disconnecting: Cell<bool>,
+    mime_types: RefCell<AHashSet<String>>,
+    client: Rc<Client>
+}
+
+impl<T: Vtable> SourceData<T> {
+    fn new(client: &Rc<Client>) -> Self {
+        Self {
+            attachment: Default::default(),
+            disconnecting: Cell::new(false),
+            mime_types: Default::default(),
+            client: client.clone(),
+        }
+    }
+}
+
+pub fn attach_source<T: Vtable>(
+    src: &T::Source,
+    seat: &Rc<WlSeatGlobal>,
+    role: Role,
+) -> Result<(), IpcError> {
+    let src = T::get_source_data(src);
+    let mut attachment = src.attachment.borrow_mut();
+    if attachment.is_some() {
+        return Err(IpcError::AlreadyAttached);
+    }
+    *attachment = Some(Attachment {
+        seat: seat.clone(),
+        role,
+        offers: Default::default(),
+    });
+    Ok(())
+}
+
+pub fn detach_source<T: Vtable>(src: &T::Source) {
+    let data = T::get_source_data(src);
+    if data.disconnecting.get() {
+        return;
+    }
+    if let Some(attachment) = data.attachment.borrow_mut().take() {
+        attachment.detach_offers();
+    }
+    T::send_cancelled(src);
+}
+
+pub fn offer_source_to<T: Vtable>(src: &Rc<T::Source>, client: &Rc<Client>) {
+    let data = T::get_source_data(src);
+    let mut attachment = data.attachment.borrow_mut();
+    let attachment = match attachment.deref_mut() {
+        Some(a) => a,
+        _ => {
+            log::error!("Trying to create an offer from a unattached data source");
+            return;
+        }
+    };
+    attachment.detach_offers();
+    T::for_each_device(&attachment.seat, client.id, |dd| {
+        let id = match client.new_id() {
+            Ok(id) => id,
+            Err(e) => {
+                client.error(e);
+                return;
+            }
+        };
+        let offer_data = OfferData {
+            device_id: T::device_id(dd),
+            source: CloneCell::new(Some(src.clone())),
+            client: client.clone(),
+        };
+        let offer = Rc::new(T::create_offer(client, offer_data, id));
+        attachment.offers.insert(T::device_id(dd), offer.clone());
+        let mt = data.mime_types.borrow_mut();
+        T::send_offer(dd, &offer);
+        for mt in mt.deref() {
+            T::send_mime_type(&offer, mt);
+        }
+        if attachment.role == Role::Selection {
+            T::send_selection(dd, T::get_offer_id(&offer));
+        }
+        client.add_server_obj(&offer);
+    });
+}
+
+
+fn add_mime_type<T: Vtable>(src: &T::Source, mime_type: &str) {
+    let data = T::get_source_data(src);
+    if data
+        .mime_types
+        .borrow_mut()
+        .insert(mime_type.to_string())
+    {
+        if let Some(attachment) = data.attachment.borrow_mut().deref_mut() {
+            for (_, offer) in &attachment.offers {
+                T::send_mime_type(&offer, mime_type);
+                let data = T::get_offer_data(&offer);
+                data.client.flush();
+            }
+        }
+    }
+}
+
+fn disconnect_source<T: Vtable>(src: &T::Source) {
+    let data = T::get_source_data(src);
+    data.disconnecting.set(true);
+    if let Some(attachment) = data.attachment.borrow_mut().take() {
+        attachment.detach_offers();
+        T::unset(&attachment.seat);
+    }
+}
+
+fn disconnect_offer<T: Vtable>(offer: &T::Offer) {
+    let data = T::get_offer_data(offer);
+    if let Some(src) = data.source.set(None) {
+        let src_data = T::get_source_data(&src);
+        if let Some(attachment) = src_data.attachment.borrow_mut().deref_mut() {
+            attachment.offers.remove(&data.device_id);
+        }
+    }
+}
+
+fn receive<T: Vtable>(offer: &T::Offer, mime_type: &str, fd: Rc<OwnedFd>) {
+    let data = T::get_offer_data(offer);
+    if let Some(src) = data.source.get() {
+        T::send_send(&src, mime_type, fd);
+        let data = T::get_source_data(&src);
+        data.client.flush();
+    }
+}

src/ifs/ipc/wl_data_device.rs

@@ -0,0 +1,196 @@
+use crate::client::{Client, ClientError, ClientId};
+use crate::ifs::ipc::wl_data_device_manager::WlDataDeviceManager;
+use crate::ifs::ipc::wl_data_source::{WlDataSource};
+use crate::ifs::wl_seat::{WlSeat, WlSeatError, WlSeatGlobal};
+use crate::object::{Object, ObjectId};
+use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::wl_data_device::*;
+use crate::wire::{WlDataDeviceId, WlDataOfferId};
+use std::rc::Rc;
+use thiserror::Error;
+use uapi::OwnedFd;
+use crate::ifs::ipc::{OfferData, SourceData, Vtable};
+use crate::ifs::ipc::wl_data_offer::WlDataOffer;
+
+#[allow(dead_code)]
+const ROLE: u32 = 0;
+
+pub struct WlDataDevice {
+    pub id: WlDataDeviceId,
+    pub manager: Rc<WlDataDeviceManager>,
+    pub seat: Rc<WlSeat>,
+}
+
+impl WlDataDevice {
+    pub fn new(id: WlDataDeviceId, manager: &Rc<WlDataDeviceManager>, seat: &Rc<WlSeat>) -> Self {
+        Self {
+            id,
+            manager: manager.clone(),
+            seat: seat.clone(),
+        }
+    }
+
+    pub fn send_data_offer(&self, id: WlDataOfferId) {
+        self.manager.client.event(DataOffer {
+            self_id: self.id,
+            id,
+        })
+    }
+
+    pub fn send_selection(&self, id: WlDataOfferId) {
+        self.manager.client.event(Selection {
+            self_id: self.id,
+            id,
+        })
+    }
+
+    fn start_drag(&self, parser: MsgParser<'_, '_>) -> Result<(), StartDragError> {
+        let _req: StartDrag = self.manager.client.parse(self, parser)?;
+        Ok(())
+    }
+
+    fn set_selection(&self, parser: MsgParser<'_, '_>) -> Result<(), SetSelectionError> {
+        let req: SetSelection = self.manager.client.parse(self, parser)?;
+        let src = if req.source.is_none() {
+            None
+        } else {
+            Some(self.manager.client.lookup(req.source)?)
+        };
+        self.seat.global.set_selection(src)?;
+        Ok(())
+    }
+
+    fn release(&self, parser: MsgParser<'_, '_>) -> Result<(), ReleaseError> {
+        let _req: Release = self.manager.client.parse(self, parser)?;
+        self.seat.remove_data_device(self);
+        self.manager.client.remove_obj(self)?;
+        Ok(())
+    }
+}
+
+impl Vtable for WlDataDevice {
+    type DeviceId = WlDataDeviceId;
+    type OfferId = WlDataOfferId;
+    type Device = WlDataDevice;
+    type Source = WlDataSource;
+    type Offer = WlDataOffer;
+
+    fn device_id(dd: &Self::Device) -> Self::DeviceId {
+        dd.id
+    }
+
+    fn get_offer_data(offer: &Self::Offer) -> &OfferData<Self> {
+        &offer.offer_data
+    }
+
+    fn get_source_data(src: &Self::Source) -> &SourceData<Self> {
+        &src.data
+    }
+
+    fn for_each_device<C>(seat: &WlSeatGlobal, client: ClientId, f: C) where C: FnMut(&Rc<Self::Device>) {
+        seat.for_each_data_device(0, client, f);
+    }
+
+    fn create_offer(client: &Rc<Client>, offer_data: OfferData<Self>, id: ObjectId) -> Self::Offer {
+        WlDataOffer {
+            id: id.into(),
+            client: client.clone(),
+            offer_data,
+        }
+    }
+
+    fn send_selection(dd: &Self::Device, offer: Self::OfferId) {
+        dd.send_selection(offer);
+    }
+
+    fn send_cancelled(source: &Self::Source) {
+        source.send_cancelled();
+    }
+
+    fn get_offer_id(offer: &Self::Offer) -> Self::OfferId {
+        offer.id
+    }
+
+    fn send_offer(dd: &Self::Device, offer: &Self::Offer) {
+        dd.send_data_offer(offer.id);
+    }
+
+    fn send_mime_type(offer: &Self::Offer, mime_type: &str) {
+        offer.send_offer(mime_type);
+    }
+
+    fn unset(seat: &Rc<WlSeatGlobal>) {
+        seat.unset_selection();
+    }
+
+    fn send_send(src: &Self::Source, mime_type: &str, fd: Rc<OwnedFd>) {
+        src.send_send(mime_type, fd);
+    }
+}
+
+object_base! {
+    WlDataDevice, WlDataDeviceError;
+
+    START_DRAG => start_drag,
+    SET_SELECTION => set_selection,
+    RELEASE => release,
+}
+
+impl Object for WlDataDevice {
+    fn num_requests(&self) -> u32 {
+        RELEASE + 1
+    }
+
+    fn break_loops(&self) {
+        self.seat.remove_data_device(self);
+    }
+}
+
+simple_add_obj!(WlDataDevice);
+
+#[derive(Debug, Error)]
+pub enum WlDataDeviceError {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+    #[error("Could not process `start_drag` request")]
+    StartDragError(#[from] StartDragError),
+    #[error("Could not process `set_selection` request")]
+    SetSelectionError(#[from] SetSelectionError),
+    #[error("Could not process `release` request")]
+    ReleaseError(#[from] ReleaseError),
+}
+efrom!(WlDataDeviceError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum StartDragError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(StartDragError, ParseFailed, MsgParserError);
+efrom!(StartDragError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum SetSelectionError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+    #[error(transparent)]
+    WlSeatError(Box<WlSeatError>),
+}
+efrom!(SetSelectionError, ParseFailed, MsgParserError);
+efrom!(SetSelectionError, ClientError);
+efrom!(SetSelectionError, WlSeatError);
+
+#[derive(Debug, Error)]
+pub enum ReleaseError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(ReleaseError, ParseFailed, MsgParserError);
+efrom!(ReleaseError, ClientError);

src/ifs/ipc/wl_data_device_manager.rs

@@ -0,0 +1,136 @@
+use crate::client::{Client, ClientError};
+use crate::globals::{Global, GlobalName};
+use crate::ifs::ipc::wl_data_device::WlDataDevice;
+use crate::ifs::ipc::wl_data_source::WlDataSource;
+use crate::object::Object;
+use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::wl_data_device_manager::*;
+use crate::wire::WlDataDeviceManagerId;
+use std::rc::Rc;
+use thiserror::Error;
+
+#[allow(dead_code)]
+const DND_NONE: u32 = 0;
+#[allow(dead_code)]
+const DND_COPY: u32 = 1;
+#[allow(dead_code)]
+const DND_MOVE: u32 = 2;
+#[allow(dead_code)]
+const DND_ASK: u32 = 4;
+
+pub struct WlDataDeviceManagerGlobal {
+    name: GlobalName,
+}
+
+pub struct WlDataDeviceManager {
+    pub id: WlDataDeviceManagerId,
+    pub client: Rc<Client>,
+    pub version: u32,
+}
+
+impl WlDataDeviceManagerGlobal {
+    pub fn new(name: GlobalName) -> Self {
+        Self { name }
+    }
+
+    fn bind_(
+        self: Rc<Self>,
+        id: WlDataDeviceManagerId,
+        client: &Rc<Client>,
+        version: u32,
+    ) -> Result<(), WlDataDeviceManagerError> {
+        let obj = Rc::new(WlDataDeviceManager {
+            id,
+            client: client.clone(),
+            version,
+        });
+        client.add_client_obj(&obj)?;
+        Ok(())
+    }
+}
+
+impl WlDataDeviceManager {
+    fn create_data_source(&self, parser: MsgParser<'_, '_>) -> Result<(), CreateDataSourceError> {
+        let req: CreateDataSource = self.client.parse(self, parser)?;
+        let res = Rc::new(WlDataSource::new(req.id, &self.client));
+        self.client.add_client_obj(&res)?;
+        Ok(())
+    }
+
+    fn get_data_device(
+        self: &Rc<Self>,
+        parser: MsgParser<'_, '_>,
+    ) -> Result<(), GetDataDeviceError> {
+        let req: GetDataDevice = self.client.parse(&**self, parser)?;
+        let seat = self.client.lookup(req.seat)?;
+        let dev = Rc::new(WlDataDevice::new(req.id, self, &seat));
+        seat.add_data_device(&dev);
+        self.client.add_client_obj(&dev)?;
+        Ok(())
+    }
+}
+
+global_base!(
+    WlDataDeviceManagerGlobal,
+    WlDataDeviceManager,
+    WlDataDeviceManagerError
+);
+
+impl Global for WlDataDeviceManagerGlobal {
+    fn singleton(&self) -> bool {
+        true
+    }
+
+    fn version(&self) -> u32 {
+        3
+    }
+}
+
+simple_add_global!(WlDataDeviceManagerGlobal);
+
+object_base! {
+    WlDataDeviceManager, WlDataDeviceManagerError;
+
+    CREATE_DATA_SOURCE => create_data_source,
+    GET_DATA_DEVICE => get_data_device,
+}
+
+impl Object for WlDataDeviceManager {
+    fn num_requests(&self) -> u32 {
+        GET_DATA_DEVICE + 1
+    }
+}
+
+simple_add_obj!(WlDataDeviceManager);
+
+#[derive(Debug, Error)]
+pub enum WlDataDeviceManagerError {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+    #[error("Could not process `create_data_source` request")]
+    CreateDataSourceError(#[from] CreateDataSourceError),
+    #[error("Could not process `get_data_device` request")]
+    GetDataDeviceError(#[from] GetDataDeviceError),
+}
+efrom!(WlDataDeviceManagerError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum CreateDataSourceError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(CreateDataSourceError, ParseFailed, MsgParserError);
+efrom!(CreateDataSourceError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum GetDataDeviceError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(GetDataDeviceError, ParseFailed, MsgParserError);
+efrom!(GetDataDeviceError, ClientError);

src/ifs/ipc/wl_data_offer.rs

@@ -0,0 +1,152 @@
+use crate::client::{Client, ClientError};
+use crate::object::Object;
+use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::wl_data_offer::*;
+use crate::wire::{WlDataOfferId};
+use std::rc::Rc;
+use thiserror::Error;
+use crate::ifs::ipc::{disconnect_offer, OfferData, receive};
+use crate::ifs::ipc::wl_data_device::WlDataDevice;
+
+#[allow(dead_code)]
+const INVALID_FINISH: u32 = 0;
+#[allow(dead_code)]
+const INVALID_ACTION_MASK: u32 = 1;
+#[allow(dead_code)]
+const INVALID_ACTION: u32 = 2;
+#[allow(dead_code)]
+const INVALID_OFFER: u32 = 3;
+
+
+pub struct WlDataOffer {
+    pub id: WlDataOfferId,
+    pub client: Rc<Client>,
+    pub offer_data: OfferData<WlDataDevice>,
+}
+
+impl WlDataOffer {
+    pub fn send_offer(&self, mime_type: &str) {
+        self.client.event(Offer {
+            self_id: self.id,
+            mime_type,
+        })
+    }
+
+    fn accept(&self, parser: MsgParser<'_, '_>) -> Result<(), AcceptError> {
+        let _req: Accept = self.client.parse(self, parser)?;
+        Ok(())
+    }
+
+    fn receive(&self, parser: MsgParser<'_, '_>) -> Result<(), ReceiveError> {
+        let req: Receive = self.client.parse(self, parser)?;
+        receive::<WlDataDevice>(self, req.mime_type, req.fd);
+        Ok(())
+    }
+
+    fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), DestroyError> {
+        let _req: Destroy = self.client.parse(self, parser)?;
+        disconnect_offer::<WlDataDevice>(self);
+        self.client.remove_obj(self)?;
+        Ok(())
+    }
+
+    fn finish(&self, parser: MsgParser<'_, '_>) -> Result<(), FinishError> {
+        let _req: Finish = self.client.parse(self, parser)?;
+        Ok(())
+    }
+
+    fn set_actions(&self, parser: MsgParser<'_, '_>) -> Result<(), SetActionsError> {
+        let _req: SetActions = self.client.parse(self, parser)?;
+        Ok(())
+    }
+}
+
+object_base! {
+    WlDataOffer, WlDataOfferError;
+
+    ACCEPT => accept,
+    RECEIVE => receive,
+    DESTROY => destroy,
+    FINISH => finish,
+    SET_ACTIONS => set_actions,
+}
+
+impl Object for WlDataOffer {
+    fn num_requests(&self) -> u32 {
+        SET_ACTIONS + 1
+    }
+
+    fn break_loops(&self) {
+        disconnect_offer::<WlDataDevice>(self);
+    }
+}
+
+simple_add_obj!(WlDataOffer);
+
+#[derive(Debug, Error)]
+pub enum WlDataOfferError {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+    #[error("Could not process `accept` request")]
+    AcceptError(#[from] AcceptError),
+    #[error("Could not process `receive` request")]
+    ReceiveError(#[from] ReceiveError),
+    #[error("Could not process `destroy` request")]
+    DestroyError(#[from] DestroyError),
+    #[error("Could not process `finish` request")]
+    FinishError(#[from] FinishError),
+    #[error("Could not process `set_actions` request")]
+    SetActionsError(#[from] SetActionsError),
+}
+efrom!(WlDataOfferError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum AcceptError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(AcceptError, ParseFailed, MsgParserError);
+efrom!(AcceptError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum ReceiveError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(ReceiveError, ParseFailed, MsgParserError);
+efrom!(ReceiveError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum DestroyError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(DestroyError, ParseFailed, MsgParserError);
+efrom!(DestroyError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum FinishError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(FinishError, ParseFailed, MsgParserError);
+efrom!(FinishError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum SetActionsError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(SetActionsError, ParseFailed, MsgParserError);
+efrom!(SetActionsError, ClientError);

src/ifs/ipc/wl_data_source.rs

@@ -0,0 +1,123 @@
+use crate::client::{Client, ClientError};
+use crate::object::Object;
+use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::wl_data_source::*;
+use crate::wire::{WlDataSourceId};
+use std::rc::Rc;
+use thiserror::Error;
+use uapi::OwnedFd;
+use crate::ifs::ipc::{add_mime_type, disconnect_source, SourceData};
+use crate::ifs::ipc::wl_data_device::WlDataDevice;
+
+#[allow(dead_code)]
+const INVALID_ACTION_MASK: u32 = 0;
+#[allow(dead_code)]
+const INVALID_SOURCE: u32 = 1;
+
+pub struct WlDataSource {
+    pub id: WlDataSourceId,
+    pub data: SourceData<WlDataDevice>,
+}
+
+impl WlDataSource {
+    pub fn new(id: WlDataSourceId, client: &Rc<Client>) -> Self {
+        Self {
+            id,
+            data: SourceData::new(client),
+        }
+    }
+
+    pub fn send_cancelled(&self) {
+        self.data.client.event(Cancelled { self_id: self.id })
+    }
+
+    pub fn send_send(&self, mime_type: &str, fd: Rc<OwnedFd>) {
+        self.data.client.event(Send {
+            self_id: self.id,
+            mime_type,
+            fd,
+        })
+    }
+
+    fn offer(&self, parser: MsgParser<'_, '_>) -> Result<(), OfferError> {
+        let req: Offer = self.data.client.parse(self, parser)?;
+        add_mime_type::<WlDataDevice>(self, req.mime_type);
+        Ok(())
+    }
+
+    fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), DestroyError> {
+        let _req: Destroy = self.data.client.parse(self, parser)?;
+        disconnect_source::<WlDataDevice>(self);
+        self.data.client.remove_obj(self)?;
+        Ok(())
+    }
+
+    fn set_actions(&self, parser: MsgParser<'_, '_>) -> Result<(), SetActionsError> {
+        let _req: SetActions = self.data.client.parse(self, parser)?;
+        Ok(())
+    }
+}
+
+object_base! {
+    WlDataSource, WlDataSourceError;
+
+    OFFER => offer,
+    DESTROY => destroy,
+    SET_ACTIONS => set_actions,
+}
+
+impl Object for WlDataSource {
+    fn num_requests(&self) -> u32 {
+        SET_ACTIONS + 1
+    }
+
+    fn break_loops(&self) {
+        disconnect_source::<WlDataDevice>(self);
+    }
+}
+
+dedicated_add_obj!(WlDataSource, WlDataSourceId, wl_data_source);
+
+#[derive(Debug, Error)]
+pub enum WlDataSourceError {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+    #[error("Could not process `offer` request")]
+    OfferError(#[from] OfferError),
+    #[error("Could not process `destroy` request")]
+    DestroyError(#[from] DestroyError),
+    #[error("Could not process `set_actions` request")]
+    SetActionsError(#[from] SetActionsError),
+}
+efrom!(WlDataSourceError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum OfferError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(OfferError, ParseFailed, MsgParserError);
+efrom!(OfferError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum DestroyError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(DestroyError, ParseFailed, MsgParserError);
+efrom!(DestroyError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum SetActionsError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(SetActionsError, ParseFailed, MsgParserError);
+efrom!(SetActionsError, ClientError);

src/ifs/ipc/zwp_primary_selection_device_manager_v1.rs

@@ -0,0 +1,143 @@
+use crate::client::{Client, ClientError};
+use crate::globals::{Global, GlobalName};
+use crate::object::Object;
+use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::zwp_primary_selection_device_manager_v1::*;
+use crate::wire::ZwpPrimarySelectionDeviceManagerV1Id;
+use std::rc::Rc;
+use thiserror::Error;
+use crate::ifs::ipc::zwp_primary_selection_device_v1::ZwpPrimarySelectionDeviceV1;
+use crate::ifs::ipc::zwp_primary_selection_source_v1::ZwpPrimarySelectionSourceV1;
+
+pub struct ZwpPrimarySelectionDeviceManagerV1Global {
+    name: GlobalName,
+}
+
+pub struct ZwpPrimarySelectionDeviceManagerV1 {
+    pub id: ZwpPrimarySelectionDeviceManagerV1Id,
+    pub client: Rc<Client>,
+    pub version: u32,
+}
+
+impl ZwpPrimarySelectionDeviceManagerV1Global {
+    pub fn new(name: GlobalName) -> Self {
+        Self { name }
+    }
+
+    fn bind_(
+        self: Rc<Self>,
+        id: ZwpPrimarySelectionDeviceManagerV1Id,
+        client: &Rc<Client>,
+        version: u32,
+    ) -> Result<(), ZwpPrimarySelectionDeviceManagerV1Error> {
+        let obj = Rc::new(ZwpPrimarySelectionDeviceManagerV1 {
+            id,
+            client: client.clone(),
+            version,
+        });
+        client.add_client_obj(&obj)?;
+        Ok(())
+    }
+}
+
+impl ZwpPrimarySelectionDeviceManagerV1 {
+    fn create_source(&self, parser: MsgParser<'_, '_>) -> Result<(), CreateSourceError> {
+        let req: CreateSource = self.client.parse(self, parser)?;
+        let res = Rc::new(ZwpPrimarySelectionSourceV1::new(req.id, &self.client));
+        self.client.add_client_obj(&res)?;
+        Ok(())
+    }
+
+    fn get_data_device(self: &Rc<Self>, parser: MsgParser<'_, '_>) -> Result<(), GetDeviceError> {
+        let req: GetDevice = self.client.parse(&**self, parser)?;
+        let seat = self.client.lookup(req.seat)?;
+        let dev = Rc::new(ZwpPrimarySelectionDeviceV1::new(req.id, self, &seat));
+        seat.add_primary_selection_device(&dev);
+        self.client.add_client_obj(&dev)?;
+        Ok(())
+    }
+
+    fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), DestroyError> {
+        let _req: Destroy = self.client.parse(self, parser)?;
+        self.client.remove_obj(self)?;
+        Ok(())
+    }
+}
+
+global_base!(
+    ZwpPrimarySelectionDeviceManagerV1Global,
+    ZwpPrimarySelectionDeviceManagerV1,
+    ZwpPrimarySelectionDeviceManagerV1Error
+);
+
+impl Global for ZwpPrimarySelectionDeviceManagerV1Global {
+    fn singleton(&self) -> bool {
+        true
+    }
+
+    fn version(&self) -> u32 {
+        1
+    }
+}
+
+simple_add_global!(ZwpPrimarySelectionDeviceManagerV1Global);
+
+object_base! {
+    ZwpPrimarySelectionDeviceManagerV1, ZwpPrimarySelectionDeviceManagerV1Error;
+
+    CREATE_SOURCE => create_source,
+    GET_DEVICE => get_data_device,
+    DESTROY => destroy,
+}
+
+impl Object for ZwpPrimarySelectionDeviceManagerV1 {
+    fn num_requests(&self) -> u32 {
+        DESTROY + 1
+    }
+}
+
+simple_add_obj!(ZwpPrimarySelectionDeviceManagerV1);
+
+#[derive(Debug, Error)]
+pub enum ZwpPrimarySelectionDeviceManagerV1Error {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+    #[error("Could not process `destroy` request")]
+    DestroyError(#[from] DestroyError),
+    #[error("Could not process `create_source` request")]
+    CreateSourceError(#[from] CreateSourceError),
+    #[error("Could not process `get_device` request")]
+    GetDeviceError(#[from] GetDeviceError),
+}
+efrom!(ZwpPrimarySelectionDeviceManagerV1Error, ClientError);
+
+#[derive(Debug, Error)]
+pub enum DestroyError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(DestroyError, ParseFailed, MsgParserError);
+efrom!(DestroyError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum CreateSourceError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(CreateSourceError, ParseFailed, MsgParserError);
+efrom!(CreateSourceError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum GetDeviceError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(GetDeviceError, ParseFailed, MsgParserError);
+efrom!(GetDeviceError, ClientError);

src/ifs/ipc/zwp_primary_selection_device_v1.rs

@@ -0,0 +1,178 @@
+use crate::client::{Client, ClientError, ClientId};
+use crate::ifs::wl_seat::{WlSeat, WlSeatError, WlSeatGlobal};
+use crate::object::{Object, ObjectId};
+use crate::utils::buffd::{MsgParser, MsgParserError};
+use crate::wire::zwp_primary_selection_device_v1::*;
+use crate::wire::{ZwpPrimarySelectionDeviceV1Id, ZwpPrimarySelectionOfferV1Id};
+use std::rc::Rc;
+use thiserror::Error;
+use uapi::OwnedFd;
+use crate::ifs::ipc::{OfferData, SourceData, Vtable};
+use crate::ifs::ipc::zwp_primary_selection_device_manager_v1::ZwpPrimarySelectionDeviceManagerV1;
+use crate::ifs::ipc::zwp_primary_selection_offer_v1::ZwpPrimarySelectionOfferV1;
+use crate::ifs::ipc::zwp_primary_selection_source_v1::{ZwpPrimarySelectionSourceV1};
+
+pub struct ZwpPrimarySelectionDeviceV1 {
+    pub id: ZwpPrimarySelectionDeviceV1Id,
+    pub manager: Rc<ZwpPrimarySelectionDeviceManagerV1>,
+    seat: Rc<WlSeat>,
+}
+
+impl ZwpPrimarySelectionDeviceV1 {
+    pub fn new(
+        id: ZwpPrimarySelectionDeviceV1Id,
+        manager: &Rc<ZwpPrimarySelectionDeviceManagerV1>,
+        seat: &Rc<WlSeat>,
+    ) -> Self {
+        Self {
+            id,
+            manager: manager.clone(),
+            seat: seat.clone(),
+        }
+    }
+
+    pub fn send_data_offer(&self, offer: ZwpPrimarySelectionOfferV1Id) {
+        self.manager.client.event(DataOffer {
+            self_id: self.id,
+            offer,
+        })
+    }
+
+    pub fn send_selection(&self, id: ZwpPrimarySelectionOfferV1Id) {
+        self.manager.client.event(Selection {
+            self_id: self.id,
+            id,
+        })
+    }
+
+    fn set_selection(&self, parser: MsgParser<'_, '_>) -> Result<(), SetSelectionError> {
+        let req: SetSelection = self.manager.client.parse(self, parser)?;
+        let src = if req.source.is_none() {
+            None
+        } else {
+            Some(self.manager.client.lookup(req.source)?)
+        };
+        self.seat.global.set_primary_selection(src)?;
+        Ok(())
+    }
+
+    fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), DestroyError> {
+        let _req: Destroy = self.manager.client.parse(self, parser)?;
+        self.seat.remove_primary_selection_device(self);
+        self.manager.client.remove_obj(self)?;
+        Ok(())
+    }
+}
+
+impl Vtable for ZwpPrimarySelectionDeviceV1 {
+    type DeviceId = ZwpPrimarySelectionDeviceV1Id;
+    type OfferId = ZwpPrimarySelectionOfferV1Id;
+    type Device = ZwpPrimarySelectionDeviceV1;
+    type Source = ZwpPrimarySelectionSourceV1;
+    type Offer = ZwpPrimarySelectionOfferV1;
+
+    fn device_id(dd: &Self::Device) -> Self::DeviceId {
+        dd.id
+    }
+
+    fn get_offer_data(offer: &Self::Offer) -> &OfferData<Self> {
+        &offer.offer_data
+    }
+
+    fn get_source_data(src: &Self::Source) -> &SourceData<Self> {
+        &src.data
+    }
+
+    fn for_each_device<C>(seat: &WlSeatGlobal, client: ClientId, f: C) where C: FnMut(&Rc<Self::Device>) {
+        seat.for_each_primary_selection_device(0, client, f)
+    }
+
+    fn create_offer(client: &Rc<Client>, offer_data: OfferData<Self>, id: ObjectId) -> Self::Offer {
+        ZwpPrimarySelectionOfferV1 {
+            id: id.into(),
+            client: client.clone(),
+            offer_data,
+        }
+    }
+
+    fn send_selection(dd: &Self::Device, offer: Self::OfferId) {
+        dd.send_selection(offer);
+    }
+
+    fn send_cancelled(source: &Self::Source) {
+        source.send_cancelled();
+    }
+
+    fn get_offer_id(offer: &Self::Offer) -> Self::OfferId {
+        offer.id
+    }
+
+    fn send_offer(dd: &Self::Device, offer: &Self::Offer) {
+        dd.send_data_offer(offer.id);
+    }
+
+    fn send_mime_type(offer: &Self::Offer, mime_type: &str) {
+        offer.send_offer(mime_type);
+    }
+
+    fn unset(seat: &Rc<WlSeatGlobal>) {
+        seat.unset_primary_selection();
+    }
+
+    fn send_send(src: &Self::Source, mime_type: &str, fd: Rc<OwnedFd>) {
+        src.send_send(mime_type, fd);
+    }
+}
+
+object_base! {
+    ZwpPrimarySelectionDeviceV1, ZwpPrimarySelectionDeviceV1Error;
+
+    SET_SELECTION => set_selection,
+    DESTROY => destroy,
+}
+
+impl Object for ZwpPrimarySelectionDeviceV1 {
+    fn num_requests(&self) -> u32 {
+        DESTROY + 1
+    }
+
+    fn break_loops(&self) {
+        self.seat.remove_primary_selection_device(self);
+    }
+}
+
+simple_add_obj!(ZwpPrimarySelectionDeviceV1);
+
+#[derive(Debug, Error)]
+pub enum ZwpPrimarySelectionDeviceV1Error {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+    #[error("Could not process `set_selection` request")]
+    SetSelectionError(#[from] SetSelectionError),
+    #[error("Could not process `destroy` request")]
+    DestroyError(#[from] DestroyError),
+}
+efrom!(ZwpPrimarySelectionDeviceV1Error, ClientError);
+
+#[derive(Debug, Error)]
+pub enum SetSelectionError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+    #[error(transparent)]
+    WlSeatError(Box<WlSeatError>),
+}
+efrom!(SetSelectionError, ParseFailed, MsgParserError);
+efrom!(SetSelectionError, ClientError);
+efrom!(SetSelectionError, WlSeatError);
+
+#[derive(Debug, Error)]
+pub enum DestroyError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(DestroyError, ParseFailed, MsgParserError);
+efrom!(DestroyError, ClientError);

src/ifs/ipc/zwp_primary_selection_offer_v1.rs

@@ -0,0 +1,87 @@
+use crate::client::{Client, ClientError};
+use crate::object::Object;
+use crate::utils::buffd::{MsgParser, MsgParserError};
+use crate::wire::zwp_primary_selection_offer_v1::*;
+use crate::wire::ZwpPrimarySelectionOfferV1Id;
+use std::rc::Rc;
+use thiserror::Error;
+use crate::ifs::ipc::{disconnect_offer, OfferData, receive};
+use crate::ifs::ipc::zwp_primary_selection_device_v1::ZwpPrimarySelectionDeviceV1;
+
+pub struct ZwpPrimarySelectionOfferV1 {
+    pub id: ZwpPrimarySelectionOfferV1Id,
+    pub client: Rc<Client>,
+    pub offer_data: OfferData<ZwpPrimarySelectionDeviceV1>,
+}
+
+impl ZwpPrimarySelectionOfferV1 {
+    pub fn send_offer(&self, mime_type: &str) {
+        self.client.event(Offer {
+            self_id: self.id,
+            mime_type,
+        })
+    }
+
+    fn receive(&self, parser: MsgParser<'_, '_>) -> Result<(), ReceiveError> {
+        let req: Receive = self.client.parse(self, parser)?;
+        receive::<ZwpPrimarySelectionDeviceV1>(self, req.mime_type, req.fd);
+        Ok(())
+    }
+
+    fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), DestroyError> {
+        let _req: Destroy = self.client.parse(self, parser)?;
+        disconnect_offer::<ZwpPrimarySelectionDeviceV1>(self);
+        self.client.remove_obj(self)?;
+        Ok(())
+    }
+}
+
+object_base! {
+    ZwpPrimarySelectionOfferV1, ZwpPrimarySelectionOfferV1Error;
+
+    RECEIVE => receive,
+    DESTROY => destroy,
+}
+
+impl Object for ZwpPrimarySelectionOfferV1 {
+    fn num_requests(&self) -> u32 {
+        DESTROY + 1
+    }
+
+    fn break_loops(&self) {
+        disconnect_offer::<ZwpPrimarySelectionDeviceV1>(self);
+    }
+}
+
+simple_add_obj!(ZwpPrimarySelectionOfferV1);
+
+#[derive(Debug, Error)]
+pub enum ZwpPrimarySelectionOfferV1Error {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+    #[error("Could not process `receive` request")]
+    ReceiveError(#[from] ReceiveError),
+    #[error("Could not process `destroy` request")]
+    DestroyError(#[from] DestroyError),
+}
+efrom!(ZwpPrimarySelectionOfferV1Error, ClientError);
+
+#[derive(Debug, Error)]
+pub enum ReceiveError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(ReceiveError, ParseFailed, MsgParserError);
+efrom!(ReceiveError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum DestroyError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(DestroyError, ParseFailed, MsgParserError);
+efrom!(DestroyError, ClientError);

src/ifs/ipc/zwp_primary_selection_source_v1.rs

@@ -0,0 +1,103 @@
+use crate::client::{Client, ClientError};
+use crate::object::Object;
+use crate::utils::buffd::{MsgParser, MsgParserError};
+use crate::wire::zwp_primary_selection_source_v1::*;
+use crate::wire::ZwpPrimarySelectionSourceV1Id;
+use std::rc::Rc;
+use thiserror::Error;
+use uapi::OwnedFd;
+use crate::ifs::ipc::{add_mime_type, disconnect_source, SourceData};
+use crate::ifs::ipc::zwp_primary_selection_device_v1::ZwpPrimarySelectionDeviceV1;
+
+pub struct ZwpPrimarySelectionSourceV1 {
+    pub id: ZwpPrimarySelectionSourceV1Id,
+    pub data: SourceData<ZwpPrimarySelectionDeviceV1>,
+}
+
+impl ZwpPrimarySelectionSourceV1 {
+    pub fn new(id: ZwpPrimarySelectionSourceV1Id, client: &Rc<Client>) -> Self {
+        Self {
+            id,
+            data: SourceData::new(client),
+        }
+    }
+
+    pub fn send_cancelled(&self) {
+        self.data.client.event(Cancelled { self_id: self.id })
+    }
+
+    pub fn send_send(&self, mime_type: &str, fd: Rc<OwnedFd>) {
+        self.data.client.event(Send {
+            self_id: self.id,
+            mime_type,
+            fd,
+        })
+    }
+
+    fn offer(&self, parser: MsgParser<'_, '_>) -> Result<(), OfferError> {
+        let req: Offer = self.data.client.parse(self, parser)?;
+        add_mime_type::<ZwpPrimarySelectionDeviceV1>(self, req.mime_type);
+        Ok(())
+    }
+
+    fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), DestroyError> {
+        let _req: Destroy = self.data.client.parse(self, parser)?;
+        disconnect_source::<ZwpPrimarySelectionDeviceV1>(self);
+        self.data.client.remove_obj(self)?;
+        Ok(())
+    }
+}
+
+object_base! {
+    ZwpPrimarySelectionSourceV1, ZwpPrimarySelectionSourceV1Error;
+
+    OFFER => offer,
+    DESTROY => destroy,
+}
+
+impl Object for ZwpPrimarySelectionSourceV1 {
+    fn num_requests(&self) -> u32 {
+        DESTROY + 1
+    }
+
+    fn break_loops(&self) {
+        disconnect_source::<ZwpPrimarySelectionDeviceV1>(self);
+    }
+}
+
+dedicated_add_obj!(
+    ZwpPrimarySelectionSourceV1,
+    ZwpPrimarySelectionSourceV1Id,
+    zwp_primary_selection_source
+);
+
+#[derive(Debug, Error)]
+pub enum ZwpPrimarySelectionSourceV1Error {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+    #[error("Could not process `offer` request")]
+    OfferError(#[from] OfferError),
+    #[error("Could not process `destroy` request")]
+    DestroyError(#[from] DestroyError),
+}
+efrom!(ZwpPrimarySelectionSourceV1Error, ClientError);
+
+#[derive(Debug, Error)]
+pub enum OfferError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(OfferError, ParseFailed, MsgParserError);
+efrom!(OfferError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum DestroyError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(DestroyError, ParseFailed, MsgParserError);
+efrom!(DestroyError, ClientError);