kossLAN/wry
1
0
Fork 0
forked from wry/wry
Code Pull requests Activity

xwayland: implement copy/paste

Browse source
This commit is contained in:
Julian Orth 2022-05-10 01:47:10 +02:00
parent c8068ee2e7
commit d6fabcb2b5
22 changed files with 1565 additions and 380 deletions
Download patch file Download diff file Expand all files Collapse all files

128
src/ifs/ipc.rs
View file

@ -1,8 +1,7 @@
use {
crate::{
client::{Client, ClientId, WaylandObject},
ifs::wl_seat::WlSeatGlobal,
object::ObjectId,
client::{Client, ClientError, ClientId, WaylandObject},
ifs::wl_seat::{WlSeatError, WlSeatGlobal},
utils::{
bitflags::BitflagsExt, clonecell::CloneCell, numcell::NumCell, smallmap::SmallMap,
},
@ -32,16 +31,19 @@ pub enum Role {
Dnd,
}
pub trait Vtable: Sized {
type DeviceId: Eq + Copy;
type OfferId: Eq + Copy + From<ObjectId>;
pub trait IpcVtable: Sized {
type Device;
type Source;
type Offer: WaylandObject;
fn device_id(dd: &Self::Device) -> Self::DeviceId;
fn get_device_data(dd: &Self::Device) -> &DeviceData<Self>;
fn get_device_seat(dd: &Self::Device) -> Rc<WlSeatGlobal>;
fn create_xwm_source(client: &Rc<Client>) -> Self::Source;
fn set_seat_selection(
seat: &Rc<WlSeatGlobal>,
source: &Rc<Self::Source>,
serial: Option<u32>,
) -> Result<(), WlSeatError>;
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)
@ -51,35 +53,35 @@ pub trait Vtable: Sized {
client: &Rc<Client>,
dd: &Rc<Self::Device>,
data: OfferData<Self>,
id: ObjectId,
) -> Rc<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);
) -> Result<Rc<Self::Offer>, ClientError>;
fn send_selection(dd: &Self::Device, offer: Option<&Rc<Self::Offer>>);
fn send_cancelled(source: &Rc<Self::Source>);
fn get_offer_id(offer: &Self::Offer) -> u64;
fn send_offer(dd: &Self::Device, offer: &Rc<Self::Offer>);
fn send_mime_type(offer: &Rc<Self::Offer>, mime_type: &str);
fn unset(seat: &Rc<WlSeatGlobal>, role: Role);
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>);
fn remove_from_seat(device: &Self::Device);
fn get_offer_seat(offer: &Self::Offer) -> Rc<WlSeatGlobal>;
}
pub struct DeviceData<T: Vtable> {
pub struct DeviceData<T: IpcVtable> {
selection: CloneCell<Option<Rc<T::Offer>>>,
dnd: CloneCell<Option<Rc<T::Offer>>>,
pub is_xwm: bool,
}
impl<T: Vtable> Default for DeviceData<T> {
fn default() -> Self {
Self {
selection: Default::default(),
dnd: Default::default(),
}
}
}
pub struct OfferData<T: Vtable> {
pub struct OfferData<T: IpcVtable> {
device: CloneCell<Option<Rc<T::Device>>>,
source: CloneCell<Option<Rc<T::Source>>>,
shared: Rc<SharedState>,
pub is_xwm: bool,
}
impl<T: IpcVtable> OfferData<T> {
pub fn source(&self) -> Option<Rc<T::Source>> {
self.source.get()
}
}
#[derive(Debug, Error)]
@ -99,9 +101,9 @@ const OFFER_STATE_DROPPED: u32 = 1 << 2;
const SOURCE_STATE_USED: u32 = 1 << 1;
const SOURCE_STATE_FINISHED: u32 = 1 << 2;
pub struct SourceData<T: Vtable> {
seat: CloneCell<Option<Rc<WlSeatGlobal>>>,
offers: SmallMap<T::OfferId, Rc<T::Offer>, 1>,
pub struct SourceData<T: IpcVtable> {
pub seat: CloneCell<Option<Rc<WlSeatGlobal>>>,
offers: SmallMap<u64, Rc<T::Offer>, 1>,
offer_client: Cell<ClientId>,
mime_types: RefCell<AHashSet<String>>,
client: Rc<Client>,
@ -109,6 +111,7 @@ pub struct SourceData<T: Vtable> {
actions: Cell<Option<u32>>,
role: Cell<Role>,
shared: CloneCell<Rc<SharedState>>,
pub is_xwm: bool,
}
struct SharedState {
@ -131,8 +134,8 @@ impl Default for SharedState {
}
}
impl<T: Vtable> SourceData<T> {
fn new(client: &Rc<Client>) -> Self {
impl<T: IpcVtable> SourceData<T> {
fn new(client: &Rc<Client>, is_xwm: bool) -> Self {
Self {
seat: Default::default(),
offers: Default::default(),
@ -143,11 +146,12 @@ impl<T: Vtable> SourceData<T> {
actions: Cell::new(None),
role: Cell::new(Role::Selection),
shared: Default::default(),
is_xwm,
}
}
}
pub fn attach_seat<T: Vtable>(
pub fn attach_seat<T: IpcVtable>(
src: &T::Source,
seat: &Rc<WlSeatGlobal>,
role: Role,
@ -173,16 +177,16 @@ pub fn attach_seat<T: Vtable>(
Ok(())
}
pub fn cancel_offers<T: Vtable>(src: &T::Source) {
pub fn cancel_offers<T: IpcVtable>(src: &T::Source) {
let data = T::get_source_data(src);
while let Some((_, offer)) = data.offers.pop() {
let data = T::get_offer_data(&offer);
data.source.take();
destroy_offer::<T>(&offer);
destroy_data_offer::<T>(&offer);
}
}
pub fn detach_seat<T: Vtable>(src: &T::Source) {
pub fn detach_seat<T: IpcVtable>(src: &Rc<T::Source>) {
let data = T::get_source_data(src);
data.seat.set(None);
cancel_offers::<T>(src);
@ -192,7 +196,7 @@ pub fn detach_seat<T: Vtable>(src: &T::Source) {
// data.client.flush();
}
pub fn offer_source_to<T: Vtable>(src: &Rc<T::Source>, client: &Rc<Client>) {
pub fn offer_source_to<T: IpcVtable>(src: &Rc<T::Source>, client: &Rc<Client>) {
let data = T::get_source_data(src);
let seat = match data.seat.get() {
Some(a) => a,
@ -206,21 +210,21 @@ pub fn offer_source_to<T: Vtable>(src: &Rc<T::Source>, client: &Rc<Client>) {
let shared = data.shared.get();
shared.role.set(data.role.get());
T::for_each_device(&seat, client.id, |dd| {
let id = match client.new_id() {
Ok(id) => id,
Err(e) => {
client.error(e);
return;
}
};
let device_data = T::get_device_data(dd);
let offer_data = OfferData {
device: CloneCell::new(Some(dd.clone())),
source: CloneCell::new(Some(src.clone())),
shared: shared.clone(),
is_xwm: device_data.is_xwm,
};
let offer = T::create_offer(client, dd, offer_data, id);
data.offers.insert(id.into(), offer.clone());
let offer = match T::create_offer(client, dd, offer_data) {
Ok(o) => o,
Err(e) => {
client.error(e);
return;
}
};
data.offers.insert(T::get_offer_id(&offer), offer.clone());
let mt = data.mime_types.borrow_mut();
T::send_offer(dd, &offer);
for mt in mt.deref() {
@ -228,18 +232,20 @@ pub fn offer_source_to<T: Vtable>(src: &Rc<T::Source>, client: &Rc<Client>) {
}
match data.role.get() {
Role::Selection => {
T::send_selection(dd, T::get_offer_id(&offer));
T::send_selection(dd, Some(&offer));
device_data.selection.set(Some(offer.clone()));
}
Role::Dnd => {
device_data.dnd.set(Some(offer.clone()));
}
}
client.add_server_obj(&offer);
if !device_data.is_xwm {
client.add_server_obj(&offer);
}
});
}
fn add_mime_type<T: Vtable>(src: &T::Source, mime_type: &str) {
pub fn add_data_source_mime_type<T: IpcVtable>(src: &T::Source, mime_type: &str) {
let data = T::get_source_data(src);
if data.mime_types.borrow_mut().insert(mime_type.to_string()) {
for (_, offer) in &data.offers {
@ -250,20 +256,20 @@ fn add_mime_type<T: Vtable>(src: &T::Source, mime_type: &str) {
}
}
fn destroy_source<T: Vtable>(src: &T::Source) {
pub fn destroy_data_source<T: IpcVtable>(src: &T::Source) {
let data = T::get_source_data(src);
if let Some(seat) = data.seat.take() {
T::unset(&seat, data.role.get());
}
}
fn destroy_offer<T: Vtable>(offer: &T::Offer) {
pub fn destroy_data_offer<T: IpcVtable>(offer: &T::Offer) {
let data = T::get_offer_data(offer);
if let Some(device) = data.device.take() {
let device_data = T::get_device_data(&device);
match data.shared.role.get() {
Role::Selection => {
T::send_selection(&device, ObjectId::NONE.into());
T::send_selection(&device, None);
device_data.selection.take();
}
Role::Dnd => {
@ -285,37 +291,37 @@ fn destroy_offer<T: Vtable>(offer: &T::Offer) {
}
}
fn destroy_device<T: Vtable>(dd: &T::Device) {
pub fn destroy_data_device<T: IpcVtable>(dd: &T::Device) {
let data = T::get_device_data(dd);
let offers = [data.selection.take(), data.dnd.take()];
for offer in offers.into_iter().flat_map(|o| o.into_iter()) {
T::get_offer_data(&offer).device.take();
destroy_offer::<T>(&offer);
destroy_data_offer::<T>(&offer);
}
}
fn break_source_loops<T: Vtable>(src: &T::Source) {
fn break_source_loops<T: IpcVtable>(src: &T::Source) {
let data = T::get_source_data(src);
if data.offer_client.get() == data.client.id {
data.offers.take();
}
destroy_source::<T>(src);
destroy_data_source::<T>(src);
}
fn break_offer_loops<T: Vtable>(offer: &T::Offer) {
fn break_offer_loops<T: IpcVtable>(offer: &T::Offer) {
let data = T::get_offer_data(offer);
data.device.set(None);
destroy_offer::<T>(offer);
destroy_data_offer::<T>(offer);
}
fn break_device_loops<T: Vtable>(dd: &T::Device) {
fn break_device_loops<T: IpcVtable>(dd: &T::Device) {
let data = T::get_device_data(dd);
data.selection.take();
data.dnd.take();
destroy_device::<T>(dd);
destroy_data_device::<T>(dd);
}
fn receive<T: Vtable>(offer: &T::Offer, mime_type: &str, fd: Rc<OwnedFd>) {
pub fn receive_data_offer<T: IpcVtable>(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);

210
src/ifs/ipc/wl_data_device.rs
View file

@ -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);
}
}

12
src/ifs/ipc/wl_data_device_manager.rs
View file

@ -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(())
}

65
src/ifs/ipc/wl_data_offer.rs
View file

@ -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);
}
}

89
src/ifs/ipc/wl_data_source.rs
View file

@ -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);
}
}

16
src/ifs/ipc/zwp_primary_selection_device_manager_v1.rs
View file

@ -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(())
}

167
src/ifs/ipc/zwp_primary_selection_device_v1.rs
View file

@ -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);
}
}

43
src/ifs/ipc/zwp_primary_selection_offer_v1.rs
View file

@ -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);
}
}

55
src/ifs/ipc/zwp_primary_selection_source_v1.rs
View file

@ -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);
}
}

100
src/ifs/wl_seat.rs
View file

@ -18,9 +18,13 @@ use {
ifs::{
ipc,
ipc::{
wl_data_device::WlDataDevice, wl_data_source::WlDataSource,
zwp_primary_selection_device_v1::ZwpPrimarySelectionDeviceV1,
zwp_primary_selection_source_v1::ZwpPrimarySelectionSourceV1, IpcError,
wl_data_device::{ClipboardIpc, WlDataDevice},
wl_data_source::WlDataSource,
zwp_primary_selection_device_v1::{
PrimarySelectionIpc, ZwpPrimarySelectionDeviceV1,
},
zwp_primary_selection_source_v1::ZwpPrimarySelectionSourceV1,
IpcError,
},
wl_seat::{
kb_owner::KbOwnerHolder,
@ -33,7 +37,7 @@ use {
wl_surface::WlSurface,
},
leaks::Tracker,
object::{Object, ObjectId},
object::Object,
state::State,
tree::{
generic_node_visitor, ContainerNode, ContainerSplit, FloatNode, FoundNode, Node,
@ -97,7 +101,7 @@ pub struct DroppedDnd {
impl Drop for DroppedDnd {
fn drop(&mut self) {
if let Some(src) = self.dnd.src.take() {
ipc::detach_seat::<WlDataDevice>(&src);
ipc::detach_seat::<ClipboardIpc>(&src);
}
}
}
@ -199,6 +203,40 @@ impl WlSeatGlobal {
slf
}
pub fn add_data_device(&self, device: &Rc<WlDataDevice>) {
let mut dd = self.data_devices.borrow_mut();
dd.entry(device.client.id)
.or_default()
.insert(device.id, device.clone());
}
pub fn remove_data_device(&self, device: &WlDataDevice) {
let mut dd = self.data_devices.borrow_mut();
if let Entry::Occupied(mut e) = dd.entry(device.client.id) {
e.get_mut().remove(&device.id);
if e.get().is_empty() {
e.remove();
}
}
}
pub fn add_primary_selection_device(&self, device: &Rc<ZwpPrimarySelectionDeviceV1>) {
let mut dd = self.primary_selection_devices.borrow_mut();
dd.entry(device.client.id)
.or_default()
.insert(device.id, device.clone());
}
pub fn remove_primary_selection_device(&self, device: &ZwpPrimarySelectionDeviceV1) {
let mut dd = self.primary_selection_devices.borrow_mut();
if let Entry::Occupied(mut e) = dd.entry(device.client.id) {
e.get_mut().remove(&device.id);
if e.get().is_empty() {
e.remove();
}
}
}
pub fn get_output(&self) -> Rc<OutputNode> {
self.output.get()
}
@ -460,7 +498,7 @@ impl WlSeatGlobal {
}
}
fn set_selection_<T: ipc::Vtable>(
fn set_selection_<T: ipc::IpcVtable>(
self: &Rc<Self>,
field: &CloneCell<Option<Rc<T::Source>>>,
src: Option<Rc<T::Source>>,
@ -475,7 +513,7 @@ impl WlSeatGlobal {
match src {
Some(src) => ipc::offer_source_to::<T>(&src, &client),
_ => T::for_each_device(self, client.id, |device| {
T::send_selection(device, ObjectId::NONE.into());
T::send_selection(device, None);
}),
}
// client.flush();
@ -510,7 +548,7 @@ impl WlSeatGlobal {
if let Some(serial) = serial {
self.selection_serial.set(serial);
}
self.set_selection_::<WlDataDevice>(&self.selection, selection)
self.set_selection_::<ClipboardIpc>(&self.selection, selection)
}
pub fn may_modify_selection(&self, client: &Rc<Client>, serial: u32) -> bool {
@ -521,10 +559,12 @@ impl WlSeatGlobal {
self.keyboard_node.get().node_client_id() == Some(client.id)
}
pub fn may_modify_primary_selection(&self, client: &Rc<Client>, serial: u32) -> bool {
let dist = serial.wrapping_sub(self.primary_selection_serial.get()) as i32;
if dist < 0 {
return false;
pub fn may_modify_primary_selection(&self, client: &Rc<Client>, serial: Option<u32>) -> bool {
if let Some(serial) = serial {
let dist = serial.wrapping_sub(self.primary_selection_serial.get()) as i32;
if dist < 0 {
return false;
}
}
self.keyboard_node.get().node_client_id() == Some(client.id)
|| self.pointer_node().and_then(|n| n.node_client_id()) == Some(client.id)
@ -542,7 +582,7 @@ impl WlSeatGlobal {
if let Some(serial) = serial {
self.primary_selection_serial.set(serial);
}
self.set_selection_::<ZwpPrimarySelectionDeviceV1>(&self.primary_selection, selection)
self.set_selection_::<PrimarySelectionIpc>(&self.primary_selection, selection)
}
pub fn set_known_cursor(&self, cursor: KnownCursor) {
@ -710,40 +750,6 @@ impl WlSeat {
})
}
pub fn add_data_device(&self, device: &Rc<WlDataDevice>) {
let mut dd = self.global.data_devices.borrow_mut();
dd.entry(self.client.id)
.or_default()
.insert(device.id, device.clone());
}
pub fn remove_data_device(&self, device: &WlDataDevice) {
let mut dd = self.global.data_devices.borrow_mut();
if let Entry::Occupied(mut e) = dd.entry(self.client.id) {
e.get_mut().remove(&device.id);
if e.get().is_empty() {
e.remove();
}
}
}
pub fn add_primary_selection_device(&self, device: &Rc<ZwpPrimarySelectionDeviceV1>) {
let mut dd = self.global.primary_selection_devices.borrow_mut();
dd.entry(self.client.id)
.or_default()
.insert(device.id, device.clone());
}
pub fn remove_primary_selection_device(&self, device: &ZwpPrimarySelectionDeviceV1) {
let mut dd = self.global.primary_selection_devices.borrow_mut();
if let Entry::Occupied(mut e) = dd.entry(self.client.id) {
e.get_mut().remove(&device.id);
if e.get().is_empty() {
e.remove();
}
}
}
pub fn move_(&self, node: &Rc<FloatNode>) {
self.global.move_(node);
}

24
src/ifs/wl_seat/event_handling.rs
View file

@ -6,8 +6,10 @@ use {
ifs::{
ipc,
ipc::{
wl_data_device::WlDataDevice,
zwp_primary_selection_device_v1::ZwpPrimarySelectionDeviceV1,
wl_data_device::{ClipboardIpc, WlDataDevice},
zwp_primary_selection_device_v1::{
PrimarySelectionIpc, ZwpPrimarySelectionDeviceV1,
},
},
wl_seat::{
wl_keyboard::{self, WlKeyboard},
@ -21,7 +23,6 @@ use {
},
wl_surface::{xdg_surface::xdg_popup::XdgPopup, WlSurface},
},
object::ObjectId,
tree::{FloatNode, Node, ToplevelNode},
utils::{bitflags::BitflagsExt, clonecell::CloneCell, smallmap::SmallMap},
wire::WlDataOfferId,
@ -328,7 +329,7 @@ impl WlSeatGlobal {
self.kb_owner.set_kb_node(self, node);
}
fn offer_selection<T: ipc::Vtable>(
fn offer_selection<T: ipc::IpcVtable>(
&self,
field: &CloneCell<Option<Rc<T::Source>>>,
client: &Rc<Client>,
@ -336,7 +337,7 @@ impl WlSeatGlobal {
match field.get() {
Some(sel) => ipc::offer_source_to::<T>(&sel, client),
None => T::for_each_device(self, client.id, |dd| {
T::send_selection(dd, ObjectId::NONE.into());
T::send_selection(dd, None);
}),
}
}
@ -398,7 +399,7 @@ impl WlSeatGlobal {
let dd = self.data_devices.borrow_mut();
if let Some(dd) = dd.get(&client) {
for dd in dd.values() {
if dd.manager.version >= ver {
if dd.version >= ver {
f(dd);
}
}
@ -412,7 +413,7 @@ impl WlSeatGlobal {
let dd = self.primary_selection_devices.borrow_mut();
if let Some(dd) = dd.get(&client) {
for dd in dd.values() {
if dd.manager.version >= ver {
if dd.version >= ver {
f(dd);
}
}
@ -624,11 +625,8 @@ impl WlSeatGlobal {
});
if self.keyboard_node.get().node_client_id() != Some(surface.client.id) {
self.offer_selection::<WlDataDevice>(&self.selection, &surface.client);
self.offer_selection::<ZwpPrimarySelectionDeviceV1>(
&self.primary_selection,
&surface.client,
);
self.offer_selection::<ClipboardIpc>(&self.selection, &surface.client);
self.offer_selection::<PrimarySelectionIpc>(&self.primary_selection, &surface.client);
}
}
}
@ -692,7 +690,7 @@ impl WlSeatGlobal {
serial: u32,
) {
if let Some(src) = &dnd.src {
ipc::offer_source_to::<WlDataDevice>(src, &surface.client);
ipc::offer_source_to::<ClipboardIpc>(src, &surface.client);
src.for_each_data_offer(|offer| {
offer.device.send_enter(surface.id, x, y, offer.id, serial);
offer.send_source_actions();

8
src/ifs/wl_seat/pointer_owner.rs
View file

@ -4,7 +4,7 @@ use {
fixed::Fixed,
ifs::{
ipc,
ipc::{wl_data_device::WlDataDevice, wl_data_source::WlDataSource},
ipc::{wl_data_device::ClipboardIpc, wl_data_source::WlDataSource},
wl_seat::{wl_pointer::PendingScroll, Dnd, DroppedDnd, WlSeatError, WlSeatGlobal},
wl_surface::WlSurface,
},
@ -341,7 +341,7 @@ impl PointerOwner for GrabPointerOwner {
icon.dnd_icons.insert(seat.id(), seat.clone());
}
if let Some(new) = &src {
ipc::attach_seat::<WlDataDevice>(new, seat, ipc::Role::Dnd)?;
ipc::attach_seat::<ClipboardIpc>(new, seat, ipc::Role::Dnd)?;
}
*seat.dropped_dnd.borrow_mut() = None;
let pointer_owner = Rc::new(DndPointerOwner {
@ -418,7 +418,7 @@ impl PointerOwner for DndPointerOwner {
target.node_seat_state().remove_dnd_target(seat);
if !should_drop {
if let Some(src) = &self.dnd.src {
ipc::detach_seat::<WlDataDevice>(src);
ipc::detach_seat::<ClipboardIpc>(src);
}
}
if let Some(icon) = self.icon.get() {
@ -492,7 +492,7 @@ impl PointerOwner for DndPointerOwner {
target.node_on_dnd_leave(&self.dnd);
target.node_seat_state().remove_dnd_target(seat);
if let Some(src) = &self.dnd.src {
ipc::detach_seat::<WlDataDevice>(src);
ipc::detach_seat::<ClipboardIpc>(src);
}
if let Some(icon) = self.icon.get() {
icon.dnd_icons.remove(&seat.id());