xwayland: implement copy/paste

src/ifs/ipc/wl_data_device.rs

@@ -4,17 +4,17 @@ use {
         fixed::Fixed,
         ifs::{
             ipc::{
-                break_device_loops, destroy_device, wl_data_device_manager::WlDataDeviceManager,
-                wl_data_offer::WlDataOffer, wl_data_source::WlDataSource, DeviceData, OfferData,
-                Role, SourceData, Vtable,
+                break_device_loops, destroy_data_device, wl_data_offer::WlDataOffer,
+                wl_data_source::WlDataSource, DeviceData, IpcVtable, OfferData, Role, SourceData,
             },
-            wl_seat::{WlSeat, WlSeatError, WlSeatGlobal},
+            wl_seat::{WlSeatError, WlSeatGlobal},
             wl_surface::{SurfaceRole, WlSurfaceError},
         },
         leaks::Tracker,
-        object::{Object, ObjectId},
+        object::Object,
         utils::buffd::{MsgParser, MsgParserError},
-        wire::{wl_data_device::*, WlDataDeviceId, WlDataOfferId, WlSurfaceId},
+        wire::{wl_data_device::*, WlDataDeviceId, WlDataOfferId, WlDataSourceId, WlSurfaceId},
+        xwayland::XWaylandEvent,
     },
     std::rc::Rc,
     thiserror::Error,
@@ -26,39 +26,73 @@ const ROLE: u32 = 0;
 
 pub struct WlDataDevice {
     pub id: WlDataDeviceId,
-    pub manager: Rc<WlDataDeviceManager>,
-    pub seat: Rc<WlSeat>,
-    pub data: DeviceData<WlDataDevice>,
+    pub client: Rc<Client>,
+    pub version: u32,
+    pub seat: Rc<WlSeatGlobal>,
+    pub data: DeviceData<ClipboardIpc>,
     pub tracker: Tracker<Self>,
 }
 
 impl WlDataDevice {
-    pub fn new(id: WlDataDeviceId, manager: &Rc<WlDataDeviceManager>, seat: &Rc<WlSeat>) -> Self {
+    pub fn new(
+        id: WlDataDeviceId,
+        client: &Rc<Client>,
+        version: u32,
+        seat: &Rc<WlSeatGlobal>,
+        is_xwm: bool,
+    ) -> Self {
         Self {
             id,
-            manager: manager.clone(),
+            client: client.clone(),
+            version,
             seat: seat.clone(),
-            data: Default::default(),
+            data: DeviceData {
+                selection: Default::default(),
+                dnd: Default::default(),
+                is_xwm,
+            },
             tracker: Default::default(),
         }
     }
 
-    pub fn send_data_offer(&self, id: WlDataOfferId) {
-        self.manager.client.event(DataOffer {
-            self_id: self.id,
-            id,
-        })
+    pub fn send_data_offer(&self, offer: &Rc<WlDataOffer>) {
+        if self.data.is_xwm {
+            self.client
+                .state
+                .xwayland
+                .queue
+                .push(XWaylandEvent::ClipboardSetOffer(offer.clone()));
+        } else {
+            self.client.event(DataOffer {
+                self_id: self.id,
+                id: offer.id,
+            })
+        }
     }
 
-    pub fn send_selection(&self, id: WlDataOfferId) {
-        self.manager.client.event(Selection {
-            self_id: self.id,
-            id,
-        })
+    pub fn send_selection(&self, offer: Option<&Rc<WlDataOffer>>) {
+        if self.data.is_xwm {
+            self.client
+                .state
+                .xwayland
+                .queue
+                .push(XWaylandEvent::ClipboardSetSelection(
+                    self.seat.id(),
+                    offer.cloned(),
+                ));
+        } else {
+            let id = offer.map(|o| o.id).unwrap_or(WlDataOfferId::NONE);
+            self.client.event(Selection {
+                self_id: self.id,
+                id,
+            })
+        }
     }
 
     pub fn send_leave(&self) {
-        self.manager.client.event(Leave { self_id: self.id })
+        if !self.data.is_xwm {
+            self.client.event(Leave { self_id: self.id })
+        }
     }
 
     pub fn send_enter(
@@ -69,101 +103,113 @@ impl WlDataDevice {
         offer: WlDataOfferId,
         serial: u32,
     ) {
-        self.manager.client.event(Enter {
-            self_id: self.id,
-            serial,
-            surface,
-            x,
-            y,
-            id: offer,
-        })
+        if !self.data.is_xwm {
+            self.client.event(Enter {
+                self_id: self.id,
+                serial,
+                surface,
+                x,
+                y,
+                id: offer,
+            })
+        }
     }
 
     pub fn send_motion(&self, x: Fixed, y: Fixed) {
-        self.manager.client.event(Motion {
-            self_id: self.id,
-            time: 0,
-            x,
-            y,
-        })
+        if !self.data.is_xwm {
+            self.client.event(Motion {
+                self_id: self.id,
+                time: 0,
+                x,
+                y,
+            })
+        }
     }
 
     pub fn send_drop(&self) {
-        self.manager.client.event(Drop { self_id: self.id })
+        if !self.data.is_xwm {
+            self.client.event(Drop { self_id: self.id })
+        }
     }
 
     fn start_drag(&self, parser: MsgParser<'_, '_>) -> Result<(), WlDataDeviceError> {
-        let req: StartDrag = self.manager.client.parse(self, parser)?;
-        if !self.manager.client.valid_serial(req.serial) {
+        let req: StartDrag = self.client.parse(self, parser)?;
+        if !self.client.valid_serial(req.serial) {
             log::warn!("Client tried to start_drag with an invalid serial");
             return Ok(());
         }
-        let origin = self.manager.client.lookup(req.origin)?;
+        let origin = self.client.lookup(req.origin)?;
         let source = if req.source.is_some() {
-            Some(self.manager.client.lookup(req.source)?)
+            Some(self.client.lookup(req.source)?)
         } else {
             None
         };
         let icon = if req.icon.is_some() {
-            let icon = self.manager.client.lookup(req.icon)?;
+            let icon = self.client.lookup(req.icon)?;
             icon.set_role(SurfaceRole::DndIcon)?;
             Some(icon)
         } else {
             None
         };
-        self.seat
-            .global
-            .start_drag(&origin, source, icon, req.serial)?;
+        self.seat.start_drag(&origin, source, icon, req.serial)?;
         Ok(())
     }
 
     fn set_selection(&self, parser: MsgParser<'_, '_>) -> Result<(), WlDataDeviceError> {
-        let req: SetSelection = self.manager.client.parse(self, parser)?;
-        if !self.manager.client.valid_serial(req.serial) {
+        let req: SetSelection = self.client.parse(self, parser)?;
+        if !self.client.valid_serial(req.serial) {
             log::warn!("Client tried to set_selection with an invalid serial");
             return Ok(());
         }
-        if !self
-            .seat
-            .global
-            .may_modify_selection(&self.seat.client, req.serial)
-        {
+        if !self.seat.may_modify_selection(&self.client, req.serial) {
             log::warn!("Ignoring disallowed set_selection request");
             return Ok(());
         }
         let src = if req.source.is_none() {
             None
         } else {
-            Some(self.manager.client.lookup(req.source)?)
+            Some(self.client.lookup(req.source)?)
         };
-        self.seat.global.set_selection(src, Some(req.serial))?;
+        self.seat.set_selection(src, Some(req.serial))?;
         Ok(())
     }
 
     fn release(&self, parser: MsgParser<'_, '_>) -> Result<(), WlDataDeviceError> {
-        let _req: Release = self.manager.client.parse(self, parser)?;
-        destroy_device::<Self>(self);
+        let _req: Release = self.client.parse(self, parser)?;
+        destroy_data_device::<ClipboardIpc>(self);
         self.seat.remove_data_device(self);
-        self.manager.client.remove_obj(self)?;
+        self.client.remove_obj(self)?;
         Ok(())
     }
 }
 
-impl Vtable for WlDataDevice {
-    type DeviceId = WlDataDeviceId;
-    type OfferId = WlDataOfferId;
+pub struct ClipboardIpc;
+
+impl IpcVtable for ClipboardIpc {
     type Device = WlDataDevice;
     type Source = WlDataSource;
     type Offer = WlDataOffer;
 
-    fn device_id(dd: &Self::Device) -> Self::DeviceId {
-        dd.id
-    }
-
     fn get_device_data(dd: &Self::Device) -> &DeviceData<Self> {
         &dd.data
     }
 
+    fn get_device_seat(dd: &Self::Device) -> Rc<WlSeatGlobal> {
+        dd.seat.clone()
+    }
+
+    fn create_xwm_source(client: &Rc<Client>) -> Self::Source {
+        WlDataSource::new(WlDataSourceId::NONE, client, true)
+    }
+
+    fn set_seat_selection(
+        seat: &Rc<WlSeatGlobal>,
+        source: &Rc<Self::Source>,
+        serial: Option<u32>,
+    ) -> Result<(), WlSeatError> {
+        seat.set_selection(Some(source.clone()), serial)
+    }
+
     fn get_offer_data(offer: &Self::Offer) -> &OfferData<Self> {
         &offer.data
     }
@@ -183,36 +229,36 @@ impl Vtable for WlDataDevice {
         client: &Rc<Client>,
         device: &Rc<WlDataDevice>,
         offer_data: OfferData<Self>,
-        id: ObjectId,
-    ) -> Rc<Self::Offer> {
+    ) -> Result<Rc<Self::Offer>, ClientError> {
         let rc = Rc::new(WlDataOffer {
-            id: id.into(),
+            id: client.new_id()?,
+            u64_id: client.state.data_offer_ids.fetch_add(1),
             client: client.clone(),
             device: device.clone(),
             data: offer_data,
             tracker: Default::default(),
         });
         track!(client, rc);
-        rc
+        Ok(rc)
     }
 
-    fn send_selection(dd: &Self::Device, offer: Self::OfferId) {
+    fn send_selection(dd: &Self::Device, offer: Option<&Rc<Self::Offer>>) {
         dd.send_selection(offer);
     }
 
-    fn send_cancelled(source: &Self::Source) {
+    fn send_cancelled(source: &Rc<Self::Source>) {
         source.send_cancelled();
     }
 
-    fn get_offer_id(offer: &Self::Offer) -> Self::OfferId {
-        offer.id
+    fn get_offer_id(offer: &Self::Offer) -> u64 {
+        offer.u64_id
     }
 
-    fn send_offer(dd: &Self::Device, offer: &Self::Offer) {
-        dd.send_data_offer(offer.id);
+    fn send_offer(dd: &Self::Device, offer: &Rc<Self::Offer>) {
+        dd.send_data_offer(offer);
     }
 
-    fn send_mime_type(offer: &Self::Offer, mime_type: &str) {
+    fn send_mime_type(offer: &Rc<Self::Offer>, mime_type: &str) {
         offer.send_offer(mime_type);
     }
 
@@ -223,9 +269,17 @@ impl Vtable for WlDataDevice {
         }
     }
 
-    fn send_send(src: &Self::Source, mime_type: &str, fd: Rc<OwnedFd>) {
+    fn send_send(src: &Rc<Self::Source>, mime_type: &str, fd: Rc<OwnedFd>) {
         src.send_send(mime_type, fd);
     }
+
+    fn remove_from_seat(device: &Self::Device) {
+        device.seat.remove_data_device(device);
+    }
+
+    fn get_offer_seat(offer: &Self::Offer) -> Rc<WlSeatGlobal> {
+        offer.device.seat.clone()
+    }
 }
 
 object_base! {
@@ -242,7 +296,7 @@ impl Object for WlDataDevice {
     }
 
     fn break_loops(&self) {
-        break_device_loops::<Self>(self);
+        break_device_loops::<ClipboardIpc>(self);
         self.seat.remove_data_device(self);
     }
 }

src/ifs/ipc/wl_data_device_manager.rs

@@ -61,7 +61,7 @@ impl WlDataDeviceManager {
         parser: MsgParser<'_, '_>,
     ) -> Result<(), WlDataDeviceManagerError> {
         let req: CreateDataSource = self.client.parse(self, parser)?;
-        let res = Rc::new(WlDataSource::new(req.id, &self.client));
+        let res = Rc::new(WlDataSource::new(req.id, &self.client, false));
         track!(self.client, res);
         self.client.add_client_obj(&res)?;
         Ok(())
@@ -73,9 +73,15 @@ impl WlDataDeviceManager {
     ) -> Result<(), WlDataDeviceManagerError> {
         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));
+        let dev = Rc::new(WlDataDevice::new(
+            req.id,
+            &self.client,
+            self.version,
+            &seat.global,
+            false,
+        ));
         track!(self.client, dev);
-        seat.add_data_device(&dev);
+        seat.global.add_data_device(&dev);
         self.client.add_client_obj(&dev)?;
         Ok(())
     }

src/ifs/ipc/wl_data_offer.rs

@@ -2,9 +2,11 @@ use {
     crate::{
         client::{Client, ClientError},
         ifs::ipc::{
-            break_offer_loops, destroy_offer, receive, wl_data_device::WlDataDevice,
-            wl_data_device_manager::DND_ALL, OfferData, Role, OFFER_STATE_ACCEPTED,
-            OFFER_STATE_DROPPED, OFFER_STATE_FINISHED, SOURCE_STATE_FINISHED,
+            break_offer_loops, destroy_data_offer, receive_data_offer,
+            wl_data_device::{ClipboardIpc, WlDataDevice},
+            wl_data_device_manager::DND_ALL,
+            OfferData, Role, OFFER_STATE_ACCEPTED, OFFER_STATE_DROPPED, OFFER_STATE_FINISHED,
+            SOURCE_STATE_FINISHED,
         },
         leaks::Tracker,
         object::Object,
@@ -13,6 +15,7 @@ use {
             buffd::{MsgParser, MsgParserError},
         },
         wire::{wl_data_offer::*, WlDataOfferId},
+        xwayland::XWaylandEvent,
     },
     std::rc::Rc,
     thiserror::Error,
@@ -29,36 +32,54 @@ const INVALID_OFFER: u32 = 3;
 
 pub struct WlDataOffer {
     pub id: WlDataOfferId,
+    pub u64_id: u64,
     pub client: Rc<Client>,
     pub device: Rc<WlDataDevice>,
-    pub data: OfferData<WlDataDevice>,
+    pub data: OfferData<ClipboardIpc>,
     pub tracker: Tracker<Self>,
 }
 
 impl WlDataOffer {
-    pub fn send_offer(&self, mime_type: &str) {
-        self.client.event(Offer {
-            self_id: self.id,
-            mime_type,
-        })
+    pub fn send_offer(self: &Rc<Self>, mime_type: &str) {
+        if self.data.is_xwm {
+            if let Some(src) = self.data.source.get() {
+                if !src.data.is_xwm {
+                    self.client.state.xwayland.queue.push(
+                        XWaylandEvent::ClipboardAddOfferMimeType(
+                            self.clone(),
+                            mime_type.to_string(),
+                        ),
+                    );
+                }
+            }
+        } else {
+            self.client.event(Offer {
+                self_id: self.id,
+                mime_type,
+            })
+        }
     }
 
     pub fn send_source_actions(&self) {
-        if let Some(src) = self.data.source.get() {
-            if let Some(source_actions) = src.data.actions.get() {
-                self.client.event(SourceActions {
-                    self_id: self.id,
-                    source_actions,
-                })
+        if !self.data.is_xwm {
+            if let Some(src) = self.data.source.get() {
+                if let Some(source_actions) = src.data.actions.get() {
+                    self.client.event(SourceActions {
+                        self_id: self.id,
+                        source_actions,
+                    })
+                }
             }
         }
     }
 
     pub fn send_action(&self, dnd_action: u32) {
-        self.client.event(Action {
-            self_id: self.id,
-            dnd_action,
-        })
+        if !self.data.is_xwm {
+            self.client.event(Action {
+                self_id: self.id,
+                dnd_action,
+            })
+        }
     }
 
     fn accept(&self, parser: MsgParser<'_, '_>) -> Result<(), WlDataOfferError> {
@@ -85,13 +106,13 @@ impl WlDataOffer {
         if self.data.shared.state.get().contains(OFFER_STATE_FINISHED) {
             return Err(WlDataOfferError::AlreadyFinished);
         }
-        receive::<WlDataDevice>(self, req.mime_type, req.fd);
+        receive_data_offer::<ClipboardIpc>(self, req.mime_type, req.fd);
         Ok(())
     }
 
     fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), WlDataOfferError> {
         let _req: Destroy = self.client.parse(self, parser)?;
-        destroy_offer::<WlDataDevice>(self);
+        destroy_data_offer::<ClipboardIpc>(self);
         self.client.remove_obj(self)?;
         Ok(())
     }
@@ -162,7 +183,7 @@ impl Object for WlDataOffer {
     }
 
     fn break_loops(&self) {
-        break_offer_loops::<WlDataDevice>(self);
+        break_offer_loops::<ClipboardIpc>(self);
     }
 }
 

src/ifs/ipc/wl_data_source.rs

@@ -2,8 +2,8 @@ use {
     crate::{
         client::{Client, ClientError},
         ifs::ipc::{
-            add_mime_type, break_source_loops, cancel_offers, destroy_source,
-            wl_data_device::WlDataDevice,
+            add_data_source_mime_type, break_source_loops, cancel_offers, destroy_data_source,
+            wl_data_device::ClipboardIpc,
             wl_data_device_manager::{DND_ALL, DND_NONE},
             wl_data_offer::WlDataOffer,
             SharedState, SourceData, OFFER_STATE_ACCEPTED, OFFER_STATE_DROPPED,
@@ -15,6 +15,7 @@ use {
             buffd::{MsgParser, MsgParserError},
         },
         wire::{wl_data_source::*, WlDataSourceId},
+        xwayland::XWaylandEvent,
     },
     std::rc::Rc,
     thiserror::Error,
@@ -28,16 +29,16 @@ const INVALID_SOURCE: u32 = 1;
 
 pub struct WlDataSource {
     pub id: WlDataSourceId,
-    pub data: SourceData<WlDataDevice>,
+    pub data: SourceData<ClipboardIpc>,
     pub tracker: Tracker<Self>,
 }
 
 impl WlDataSource {
-    pub fn new(id: WlDataSourceId, client: &Rc<Client>) -> Self {
+    pub fn new(id: WlDataSourceId, client: &Rc<Client>, is_xwm: bool) -> Self {
         Self {
             id,
             tracker: Default::default(),
-            data: SourceData::new(client),
+            data: SourceData::new(client, is_xwm),
         }
     }
 
@@ -55,7 +56,7 @@ impl WlDataSource {
         self.data.shared.set(Rc::new(SharedState::default()));
         self.send_target(None);
         self.send_action(DND_NONE);
-        cancel_offers::<WlDataDevice>(self);
+        cancel_offers::<ClipboardIpc>(self);
     }
 
     pub fn update_selected_action(&self) {
@@ -102,51 +103,81 @@ impl WlDataSource {
         shared.state.or_assign(OFFER_STATE_DROPPED);
     }
 
-    pub fn send_cancelled(&self) {
-        self.data.client.event(Cancelled { self_id: self.id })
+    pub fn send_cancelled(self: &Rc<Self>) {
+        if self.data.is_xwm {
+            self.data
+                .client
+                .state
+                .xwayland
+                .queue
+                .push(XWaylandEvent::ClipboardCancelSource(self.clone()));
+        } else {
+            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,
-        })
+    pub fn send_send(self: &Rc<Self>, mime_type: &str, fd: Rc<OwnedFd>) {
+        if self.data.is_xwm {
+            self.data
+                .client
+                .state
+                .xwayland
+                .queue
+                .push(XWaylandEvent::ClipboardSendSource(
+                    self.clone(),
+                    mime_type.to_string(),
+                    fd,
+                ));
+        } else {
+            self.data.client.event(Send {
+                self_id: self.id,
+                mime_type,
+                fd,
+            })
+        }
     }
 
     pub fn send_target(&self, mime_type: Option<&str>) {
-        self.data.client.event(Target {
-            self_id: self.id,
-            mime_type,
-        })
+        if !self.data.is_xwm {
+            self.data.client.event(Target {
+                self_id: self.id,
+                mime_type,
+            })
+        }
     }
 
     pub fn send_dnd_finished(&self) {
-        self.data.client.event(DndFinished { self_id: self.id })
+        if !self.data.is_xwm {
+            self.data.client.event(DndFinished { self_id: self.id })
+        }
     }
 
     pub fn send_action(&self, dnd_action: u32) {
-        self.data.client.event(Action {
-            self_id: self.id,
-            dnd_action,
-        })
+        if !self.data.is_xwm {
+            self.data.client.event(Action {
+                self_id: self.id,
+                dnd_action,
+            })
+        }
     }
 
     pub fn send_dnd_drop_performed(&self) {
-        self.data
-            .client
-            .event(DndDropPerformed { self_id: self.id })
+        if !self.data.is_xwm {
+            self.data
+                .client
+                .event(DndDropPerformed { self_id: self.id })
+        }
     }
 
     fn offer(&self, parser: MsgParser<'_, '_>) -> Result<(), WlDataSourceError> {
         let req: Offer = self.data.client.parse(self, parser)?;
-        add_mime_type::<WlDataDevice>(self, req.mime_type);
+        add_data_source_mime_type::<ClipboardIpc>(self, req.mime_type);
         Ok(())
     }
 
     fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), WlDataSourceError> {
         let _req: Destroy = self.data.client.parse(self, parser)?;
-        destroy_source::<WlDataDevice>(self);
+        destroy_data_source::<ClipboardIpc>(self);
         self.data.client.remove_obj(self)?;
         Ok(())
     }
@@ -178,7 +209,7 @@ impl Object for WlDataSource {
     }
 
     fn break_loops(&self) {
-        break_source_loops::<WlDataDevice>(self);
+        break_source_loops::<ClipboardIpc>(self);
     }
 }
 

src/ifs/ipc/zwp_primary_selection_device_manager_v1.rs

@@ -55,7 +55,11 @@ impl ZwpPrimarySelectionDeviceManagerV1 {
         parser: MsgParser<'_, '_>,
     ) -> Result<(), ZwpPrimarySelectionDeviceManagerV1Error> {
         let req: CreateSource = self.client.parse(self, parser)?;
-        let res = Rc::new(ZwpPrimarySelectionSourceV1::new(req.id, &self.client));
+        let res = Rc::new(ZwpPrimarySelectionSourceV1::new(
+            req.id,
+            &self.client,
+            false,
+        ));
         track!(self.client, res);
         self.client.add_client_obj(&res)?;
         Ok(())
@@ -67,9 +71,15 @@ impl ZwpPrimarySelectionDeviceManagerV1 {
     ) -> Result<(), ZwpPrimarySelectionDeviceManagerV1Error> {
         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));
+        let dev = Rc::new(ZwpPrimarySelectionDeviceV1::new(
+            req.id,
+            &self.client,
+            self.version,
+            &seat.global,
+            false,
+        ));
         track!(self.client, dev);
-        seat.add_primary_selection_device(&dev);
+        seat.global.add_primary_selection_device(&dev);
         self.client.add_client_obj(&dev)?;
         Ok(())
     }

src/ifs/ipc/zwp_primary_selection_device_v1.rs

@@ -3,21 +3,21 @@ use {
         client::{Client, ClientError, ClientId},
         ifs::{
             ipc::{
-                break_device_loops, destroy_device,
-                zwp_primary_selection_device_manager_v1::ZwpPrimarySelectionDeviceManagerV1,
+                break_device_loops, destroy_data_device,
                 zwp_primary_selection_offer_v1::ZwpPrimarySelectionOfferV1,
                 zwp_primary_selection_source_v1::ZwpPrimarySelectionSourceV1, DeviceData,
-                OfferData, Role, SourceData, Vtable,
+                IpcVtable, OfferData, Role, SourceData,
             },
-            wl_seat::{WlSeat, WlSeatError, WlSeatGlobal},
+            wl_seat::{WlSeatError, WlSeatGlobal},
         },
         leaks::Tracker,
-        object::{Object, ObjectId},
+        object::Object,
         utils::buffd::{MsgParser, MsgParserError},
         wire::{
             zwp_primary_selection_device_v1::*, ZwpPrimarySelectionDeviceV1Id,
-            ZwpPrimarySelectionOfferV1Id,
+            ZwpPrimarySelectionOfferV1Id, ZwpPrimarySelectionSourceV1Id,
         },
+        xwayland::XWaylandEvent,
     },
     std::rc::Rc,
     thiserror::Error,
@@ -26,54 +26,83 @@ use {
 
 pub struct ZwpPrimarySelectionDeviceV1 {
     pub id: ZwpPrimarySelectionDeviceV1Id,
-    pub manager: Rc<ZwpPrimarySelectionDeviceManagerV1>,
-    seat: Rc<WlSeat>,
-    data: DeviceData<Self>,
+    pub client: Rc<Client>,
+    pub version: u32,
+    pub seat: Rc<WlSeatGlobal>,
+    data: DeviceData<PrimarySelectionIpc>,
     pub tracker: Tracker<Self>,
 }
 
 impl ZwpPrimarySelectionDeviceV1 {
     pub fn new(
         id: ZwpPrimarySelectionDeviceV1Id,
-        manager: &Rc<ZwpPrimarySelectionDeviceManagerV1>,
-        seat: &Rc<WlSeat>,
+        client: &Rc<Client>,
+        version: u32,
+        seat: &Rc<WlSeatGlobal>,
+        is_xwm: bool,
     ) -> Self {
         Self {
             id,
-            manager: manager.clone(),
+            client: client.clone(),
+            version,
             seat: seat.clone(),
-            data: DeviceData::default(),
+            data: DeviceData {
+                selection: Default::default(),
+                dnd: Default::default(),
+                is_xwm,
+            },
             tracker: Default::default(),
         }
     }
 
-    pub fn send_data_offer(&self, offer: ZwpPrimarySelectionOfferV1Id) {
-        self.manager.client.event(DataOffer {
-            self_id: self.id,
-            offer,
-        })
+    pub fn send_data_offer(&self, offer: &Rc<ZwpPrimarySelectionOfferV1>) {
+        if self.data.is_xwm {
+            self.client
+                .state
+                .xwayland
+                .queue
+                .push(XWaylandEvent::PrimarySelectionSetOffer(offer.clone()));
+        } else {
+            self.client.event(DataOffer {
+                self_id: self.id,
+                offer: offer.id,
+            })
+        }
     }
 
-    pub fn send_selection(&self, id: ZwpPrimarySelectionOfferV1Id) {
-        self.manager.client.event(Selection {
-            self_id: self.id,
-            id,
-        })
+    pub fn send_selection(&self, offer: Option<&Rc<ZwpPrimarySelectionOfferV1>>) {
+        if self.data.is_xwm {
+            self.client
+                .state
+                .xwayland
+                .queue
+                .push(XWaylandEvent::PrimarySelectionSetSelection(
+                    self.seat.id(),
+                    offer.cloned(),
+                ));
+        } else {
+            let id = offer
+                .map(|o| o.id)
+                .unwrap_or(ZwpPrimarySelectionOfferV1Id::NONE);
+            self.client.event(Selection {
+                self_id: self.id,
+                id,
+            })
+        }
     }
 
     fn set_selection(
         &self,
         parser: MsgParser<'_, '_>,
     ) -> Result<(), ZwpPrimarySelectionDeviceV1Error> {
-        let req: SetSelection = self.manager.client.parse(self, parser)?;
-        if !self.manager.client.valid_serial(req.serial) {
+        let req: SetSelection = self.client.parse(self, parser)?;
+        if !self.client.valid_serial(req.serial) {
             log::warn!("Client tried to set_selection with an invalid serial");
             return Ok(());
         }
         if !self
             .seat
-            .global
-            .may_modify_primary_selection(&self.seat.client, req.serial)
+            .may_modify_primary_selection(&self.client, Some(req.serial))
         {
             log::warn!("Ignoring disallowed set_selection request");
             return Ok(());
@@ -81,40 +110,50 @@ impl ZwpPrimarySelectionDeviceV1 {
         let src = if req.source.is_none() {
             None
         } else {
-            Some(self.manager.client.lookup(req.source)?)
+            Some(self.client.lookup(req.source)?)
         };
-        self.seat
-            .global
-            .set_primary_selection(src, Some(req.serial))?;
+        self.seat.set_primary_selection(src, Some(req.serial))?;
         Ok(())
     }
 
     fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), ZwpPrimarySelectionDeviceV1Error> {
-        let _req: Destroy = self.manager.client.parse(self, parser)?;
-        destroy_device::<Self>(self);
+        let _req: Destroy = self.client.parse(self, parser)?;
+        destroy_data_device::<PrimarySelectionIpc>(self);
         self.seat.remove_primary_selection_device(self);
-        self.manager.client.remove_obj(self)?;
+        self.client.remove_obj(self)?;
         Ok(())
     }
 }
 
-impl Vtable for ZwpPrimarySelectionDeviceV1 {
-    type DeviceId = ZwpPrimarySelectionDeviceV1Id;
-    type OfferId = ZwpPrimarySelectionOfferV1Id;
+pub struct PrimarySelectionIpc;
+
+impl IpcVtable for PrimarySelectionIpc {
     type Device = ZwpPrimarySelectionDeviceV1;
     type Source = ZwpPrimarySelectionSourceV1;
     type Offer = ZwpPrimarySelectionOfferV1;
 
-    fn device_id(dd: &Self::Device) -> Self::DeviceId {
-        dd.id
-    }
-
     fn get_device_data(dd: &Self::Device) -> &DeviceData<Self> {
         &dd.data
     }
 
+    fn get_device_seat(dd: &Self::Device) -> Rc<WlSeatGlobal> {
+        dd.seat.clone()
+    }
+
+    fn create_xwm_source(client: &Rc<Client>) -> Self::Source {
+        ZwpPrimarySelectionSourceV1::new(ZwpPrimarySelectionSourceV1Id::NONE, client, true)
+    }
+
+    fn set_seat_selection(
+        seat: &Rc<WlSeatGlobal>,
+        source: &Rc<Self::Source>,
+        serial: Option<u32>,
+    ) -> Result<(), WlSeatError> {
+        seat.set_primary_selection(Some(source.clone()), serial)
+    }
+
     fn get_offer_data(offer: &Self::Offer) -> &OfferData<Self> {
-        &offer.offer_data
+        &offer.data
     }
 
     fn get_source_data(src: &Self::Source) -> &SourceData<Self> {
@@ -130,37 +169,43 @@ impl Vtable for ZwpPrimarySelectionDeviceV1 {
 
     fn create_offer(
         client: &Rc<Client>,
-        _device: &Rc<ZwpPrimarySelectionDeviceV1>,
+        device: &Rc<ZwpPrimarySelectionDeviceV1>,
         offer_data: OfferData<Self>,
-        id: ObjectId,
-    ) -> Rc<Self::Offer> {
+    ) -> Result<Rc<Self::Offer>, ClientError> {
+        let id = if device.data.is_xwm {
+            ZwpPrimarySelectionOfferV1Id::NONE
+        } else {
+            client.new_id()?
+        };
         let rc = Rc::new(ZwpPrimarySelectionOfferV1 {
-            id: id.into(),
+            id,
+            u64_id: client.state.data_offer_ids.fetch_add(1),
+            seat: device.seat.clone(),
             client: client.clone(),
-            offer_data,
+            data: offer_data,
             tracker: Default::default(),
         });
         track!(client, rc);
-        rc
+        Ok(rc)
     }
 
-    fn send_selection(dd: &Self::Device, offer: Self::OfferId) {
+    fn send_selection(dd: &Self::Device, offer: Option<&Rc<Self::Offer>>) {
         dd.send_selection(offer);
     }
 
-    fn send_cancelled(source: &Self::Source) {
+    fn send_cancelled(source: &Rc<Self::Source>) {
         source.send_cancelled();
     }
 
-    fn get_offer_id(offer: &Self::Offer) -> Self::OfferId {
-        offer.id
+    fn get_offer_id(offer: &Self::Offer) -> u64 {
+        offer.u64_id
     }
 
-    fn send_offer(dd: &Self::Device, offer: &Self::Offer) {
-        dd.send_data_offer(offer.id);
+    fn send_offer(dd: &Self::Device, offer: &Rc<Self::Offer>) {
+        dd.send_data_offer(offer);
     }
 
-    fn send_mime_type(offer: &Self::Offer, mime_type: &str) {
+    fn send_mime_type(offer: &Rc<Self::Offer>, mime_type: &str) {
         offer.send_offer(mime_type);
     }
 
@@ -168,9 +213,17 @@ impl Vtable for ZwpPrimarySelectionDeviceV1 {
         seat.unset_primary_selection();
     }
 
-    fn send_send(src: &Self::Source, mime_type: &str, fd: Rc<OwnedFd>) {
+    fn send_send(src: &Rc<Self::Source>, mime_type: &str, fd: Rc<OwnedFd>) {
         src.send_send(mime_type, fd);
     }
+
+    fn remove_from_seat(device: &Self::Device) {
+        device.seat.remove_primary_selection_device(device);
+    }
+
+    fn get_offer_seat(offer: &Self::Offer) -> Rc<WlSeatGlobal> {
+        offer.seat.clone()
+    }
 }
 
 object_base! {
@@ -186,7 +239,7 @@ impl Object for ZwpPrimarySelectionDeviceV1 {
     }
 
     fn break_loops(&self) {
-        break_device_loops::<Self>(self);
+        break_device_loops::<PrimarySelectionIpc>(self);
         self.seat.remove_primary_selection_device(self);
     }
 }

src/ifs/ipc/zwp_primary_selection_offer_v1.rs

@@ -1,14 +1,18 @@
 use {
     crate::{
         client::{Client, ClientError},
-        ifs::ipc::{
-            break_offer_loops, destroy_offer, receive,
-            zwp_primary_selection_device_v1::ZwpPrimarySelectionDeviceV1, OfferData,
+        ifs::{
+            ipc::{
+                break_offer_loops, destroy_data_offer, receive_data_offer,
+                zwp_primary_selection_device_v1::PrimarySelectionIpc, OfferData,
+            },
+            wl_seat::WlSeatGlobal,
         },
         leaks::Tracker,
         object::Object,
         utils::buffd::{MsgParser, MsgParserError},
         wire::{zwp_primary_selection_offer_v1::*, ZwpPrimarySelectionOfferV1Id},
+        xwayland::XWaylandEvent,
     },
     std::rc::Rc,
     thiserror::Error,
@@ -16,28 +20,43 @@ use {
 
 pub struct ZwpPrimarySelectionOfferV1 {
     pub id: ZwpPrimarySelectionOfferV1Id,
+    pub u64_id: u64,
+    pub seat: Rc<WlSeatGlobal>,
     pub client: Rc<Client>,
-    pub offer_data: OfferData<ZwpPrimarySelectionDeviceV1>,
+    pub data: OfferData<PrimarySelectionIpc>,
     pub tracker: Tracker<Self>,
 }
 
 impl ZwpPrimarySelectionOfferV1 {
-    pub fn send_offer(&self, mime_type: &str) {
-        self.client.event(Offer {
-            self_id: self.id,
-            mime_type,
-        })
+    pub fn send_offer(self: &Rc<Self>, mime_type: &str) {
+        if self.data.is_xwm {
+            if let Some(src) = self.data.source.get() {
+                if !src.data.is_xwm {
+                    self.client.state.xwayland.queue.push(
+                        XWaylandEvent::PrimarySelectionAddOfferMimeType(
+                            self.clone(),
+                            mime_type.to_string(),
+                        ),
+                    );
+                }
+            }
+        } else {
+            self.client.event(Offer {
+                self_id: self.id,
+                mime_type,
+            })
+        }
     }
 
     fn receive(&self, parser: MsgParser<'_, '_>) -> Result<(), ZwpPrimarySelectionOfferV1Error> {
         let req: Receive = self.client.parse(self, parser)?;
-        receive::<ZwpPrimarySelectionDeviceV1>(self, req.mime_type, req.fd);
+        receive_data_offer::<PrimarySelectionIpc>(self, req.mime_type, req.fd);
         Ok(())
     }
 
     fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), ZwpPrimarySelectionOfferV1Error> {
         let _req: Destroy = self.client.parse(self, parser)?;
-        destroy_offer::<ZwpPrimarySelectionDeviceV1>(self);
+        destroy_data_offer::<PrimarySelectionIpc>(self);
         self.client.remove_obj(self)?;
         Ok(())
     }
@@ -56,7 +75,7 @@ impl Object for ZwpPrimarySelectionOfferV1 {
     }
 
     fn break_loops(&self) {
-        break_offer_loops::<ZwpPrimarySelectionDeviceV1>(self);
+        break_offer_loops::<PrimarySelectionIpc>(self);
     }
 }
 

src/ifs/ipc/zwp_primary_selection_source_v1.rs

@@ -2,13 +2,14 @@ use {
     crate::{
         client::{Client, ClientError},
         ifs::ipc::{
-            add_mime_type, break_source_loops, destroy_source,
-            zwp_primary_selection_device_v1::ZwpPrimarySelectionDeviceV1, SourceData,
+            add_data_source_mime_type, break_source_loops, destroy_data_source,
+            zwp_primary_selection_device_v1::PrimarySelectionIpc, SourceData,
         },
         leaks::Tracker,
         object::Object,
         utils::buffd::{MsgParser, MsgParserError},
         wire::{zwp_primary_selection_source_v1::*, ZwpPrimarySelectionSourceV1Id},
+        xwayland::XWaylandEvent,
     },
     std::rc::Rc,
     thiserror::Error,
@@ -17,40 +18,62 @@ use {
 
 pub struct ZwpPrimarySelectionSourceV1 {
     pub id: ZwpPrimarySelectionSourceV1Id,
-    pub data: SourceData<ZwpPrimarySelectionDeviceV1>,
+    pub data: SourceData<PrimarySelectionIpc>,
     pub tracker: Tracker<Self>,
 }
 
 impl ZwpPrimarySelectionSourceV1 {
-    pub fn new(id: ZwpPrimarySelectionSourceV1Id, client: &Rc<Client>) -> Self {
+    pub fn new(id: ZwpPrimarySelectionSourceV1Id, client: &Rc<Client>, is_xwm: bool) -> Self {
         Self {
             id,
-            data: SourceData::new(client),
+            data: SourceData::new(client, is_xwm),
             tracker: Default::default(),
         }
     }
 
-    pub fn send_cancelled(&self) {
-        self.data.client.event(Cancelled { self_id: self.id })
+    pub fn send_cancelled(self: &Rc<Self>) {
+        if self.data.is_xwm {
+            self.data
+                .client
+                .state
+                .xwayland
+                .queue
+                .push(XWaylandEvent::PrimarySelectionCancelSource(self.clone()));
+        } else {
+            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,
-        })
+    pub fn send_send(self: &Rc<Self>, mime_type: &str, fd: Rc<OwnedFd>) {
+        if self.data.is_xwm {
+            self.data
+                .client
+                .state
+                .xwayland
+                .queue
+                .push(XWaylandEvent::PrimarySelectionSendSource(
+                    self.clone(),
+                    mime_type.to_string(),
+                    fd,
+                ));
+        } else {
+            self.data.client.event(Send {
+                self_id: self.id,
+                mime_type,
+                fd,
+            })
+        }
     }
 
     fn offer(&self, parser: MsgParser<'_, '_>) -> Result<(), ZwpPrimarySelectionSourceV1Error> {
         let req: Offer = self.data.client.parse(self, parser)?;
-        add_mime_type::<ZwpPrimarySelectionDeviceV1>(self, req.mime_type);
+        add_data_source_mime_type::<PrimarySelectionIpc>(self, req.mime_type);
         Ok(())
     }
 
     fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), ZwpPrimarySelectionSourceV1Error> {
         let _req: Destroy = self.data.client.parse(self, parser)?;
-        destroy_source::<ZwpPrimarySelectionDeviceV1>(self);
+        destroy_data_source::<PrimarySelectionIpc>(self);
         self.data.client.remove_obj(self)?;
         Ok(())
     }
@@ -69,7 +92,7 @@ impl Object for ZwpPrimarySelectionSourceV1 {
     }
 
     fn break_loops(&self) {
-        break_source_loops::<ZwpPrimarySelectionDeviceV1>(self);
+        break_source_loops::<PrimarySelectionIpc>(self);
     }
 }