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

autocommit 2022-02-05 02:07:07 CET

Browse source
This commit is contained in:
Julian Orth 2022-02-05 02:07:07 +01:00
parent 89bfd2ffcd
commit 2d8b3a200e
21 changed files with 328 additions and 87 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/client/error.rs
View file

@ -6,7 +6,7 @@ use crate::ifs::wl_compositor::WlCompositorError;
use crate::ifs::wl_data_device::WlDataDeviceError;
use crate::ifs::wl_data_device_manager::WlDataDeviceManagerError;
use crate::ifs::wl_data_offer::WlDataOfferError;
use crate::ifs::wl_data_source::WlDataSourceError;
use crate::ifs::wl_data_source::{WlDataSourceError, WlDataSourceId};
use crate::ifs::wl_display::WlDisplayError;
use crate::ifs::wl_drm::WlDrmError;
use crate::ifs::wl_output::WlOutputError;
@ -61,6 +61,8 @@ pub enum ClientError {
SurfaceDoesNotExist(WlSurfaceId),
#[error("There is no xdg_surface with id {0}")]
XdgSurfaceDoesNotExist(XdgSurfaceId),
#[error("There is no wl_data_source with id {0}")]
WlDataSourceDoesNotExist(WlDataSourceId),
#[error("There is no xdg_toplevel with id {0}")]
XdgToplevelDoesNotExist(XdgToplevelId),
#[error("There is no xdg_positioner with id {0}")]

28
src/client/mod.rs
View file

@ -8,7 +8,7 @@ use crate::ifs::wl_compositor::WlCompositorObj;
use crate::ifs::wl_data_device::WlDataDevice;
use crate::ifs::wl_data_device_manager::WlDataDeviceManagerObj;
use crate::ifs::wl_data_offer::WlDataOffer;
use crate::ifs::wl_data_source::WlDataSource;
use crate::ifs::wl_data_source::{WlDataSource, WlDataSourceId};
use crate::ifs::wl_display::WlDisplay;
use crate::ifs::wl_drm::WlDrmObj;
use crate::ifs::wl_output::WlOutputObj;
@ -42,6 +42,7 @@ use crate::ErrorFmt;
use ahash::AHashMap;
pub use error::ClientError;
use std::cell::{Cell, RefCell, RefMut};
use std::error::Error;
use std::fmt::{Debug, Display, Formatter};
use std::mem;
use std::rc::Rc;
@ -273,6 +274,22 @@ impl Client {
Ok(res)
}
pub fn error(&self, message: impl Error) {
let msg = ErrorFmt(message).to_string();
log::error!("Client {}: A fatal error occurred: {}", self.id.0, msg,);
match self.display() {
Ok(d) => self.fatal_event(d.implementation_error(msg)),
Err(e) => {
log::error!(
"Could not retrieve display of client {}: {}",
self.id,
ErrorFmt(e),
);
self.state.clients.kill(self.id);
}
}
}
pub fn protocol_error(&self, obj: &dyn Object, code: u32, message: String) {
if let Ok(d) = self.display() {
self.fatal_event(d.error(obj.id(), code, message));
@ -343,6 +360,13 @@ impl Client {
}
}
pub fn get_wl_data_source(&self, id: WlDataSourceId) -> Result<Rc<WlDataSource>, ClientError> {
match self.objects.wl_data_source.get(&id) {
Some(r) => Ok(r),
_ => Err(ClientError::WlDataSourceDoesNotExist(id)),
}
}
pub fn get_xdg_toplevel(&self, id: XdgToplevelId) -> Result<Rc<XdgToplevel>, ClientError> {
match self.objects.xdg_toplevel.get(&id) {
Some(r) => Ok(r),
@ -440,7 +464,6 @@ simple_add_obj!(WlTouch);
simple_add_obj!(WlDataDeviceManagerObj);
simple_add_obj!(WlDataDevice);
simple_add_obj!(WlDataOffer);
simple_add_obj!(WlDataSource);
simple_add_obj!(ZwpLinuxDmabufV1Obj);
simple_add_obj!(ZwpLinuxBufferParamsV1);
simple_add_obj!(WlDrmObj);
@ -470,3 +493,4 @@ dedicated_add_obj!(WlBuffer, buffers);
dedicated_add_obj!(WlSeatObj, seats);
dedicated_add_obj!(XdgPositioner, xdg_positioners);
dedicated_add_obj!(XdgToplevel, xdg_toplevel);
dedicated_add_obj!(WlDataSource, wl_data_source);

6
src/client/objects.rs
View file

@ -1,5 +1,6 @@
use crate::client::{Client, ClientError};
use crate::ifs::wl_buffer::{WlBuffer, WlBufferId};
use crate::ifs::wl_data_source::{WlDataSource, WlDataSourceId};
use crate::ifs::wl_display::WlDisplay;
use crate::ifs::wl_region::{WlRegion, WlRegionId};
use crate::ifs::wl_registry::{WlRegistry, WlRegistryId};
@ -25,6 +26,7 @@ pub struct Objects {
pub surfaces: CopyHashMap<WlSurfaceId, Rc<WlSurface>>,
pub xdg_surfaces: CopyHashMap<XdgSurfaceId, Rc<XdgSurface>>,
pub xdg_toplevel: CopyHashMap<XdgToplevelId, Rc<XdgToplevel>>,
pub wl_data_source: CopyHashMap<WlDataSourceId, Rc<WlDataSource>>,
pub xdg_positioners: CopyHashMap<XdgPositionerId, Rc<XdgPositioner>>,
pub regions: CopyHashMap<WlRegionId, Rc<WlRegion>>,
pub buffers: CopyHashMap<WlBufferId, Rc<WlBuffer>>,
@ -45,6 +47,7 @@ impl Objects {
surfaces: Default::default(),
xdg_surfaces: Default::default(),
xdg_toplevel: Default::default(),
wl_data_source: Default::default(),
xdg_positioners: Default::default(),
regions: Default::default(),
buffers: Default::default(),
@ -141,8 +144,9 @@ impl Objects {
return Err(ClientError::ServerIdOutOfBounds);
}
ids[pos] |= 1 << seg_offset;
} else {
client_data.event(client_data.display()?.delete_id(id));
}
client_data.event(client_data.display()?.delete_id(id));
Ok(())
}

27
src/ifs/wl_data_device/mod.rs
View file

@ -1,9 +1,9 @@
mod types;
use crate::client::{Client, DynEventFormatter};
use crate::client::{DynEventFormatter};
use crate::ifs::wl_data_device_manager::WlDataDeviceManagerObj;
use crate::ifs::wl_data_offer::WlDataOfferId;
use crate::ifs::wl_seat::WlSeatObj;
use crate::ifs::wl_seat::{WlSeatObj};
use crate::object::{Interface, Object, ObjectId};
use crate::utils::buffd::MsgParser;
use std::rc::Rc;
@ -28,7 +28,6 @@ id!(WlDataDeviceId);
pub struct WlDataDevice {
pub id: WlDataDeviceId,
pub manager: Rc<WlDataDeviceManagerObj>,
client: Rc<Client>,
seat: Rc<WlSeatObj>,
}
@ -41,11 +40,17 @@ impl WlDataDevice {
Self {
id,
manager: manager.clone(),
client: seat.client().clone(),
seat: seat.clone(),
}
}
pub fn data_offer(self: &Rc<Self>, id: WlDataOfferId) -> DynEventFormatter {
Box::new(DataOffer {
obj: self.clone(),
id,
})
}
pub fn selection(self: &Rc<Self>, id: WlDataOfferId) -> DynEventFormatter {
Box::new(Selection {
obj: self.clone(),
@ -54,19 +59,25 @@ impl WlDataDevice {
}
fn start_drag(&self, parser: MsgParser<'_, '_>) -> Result<(), StartDragError> {
let _req: StartDrag = self.client.parse(self, parser)?;
let _req: StartDrag = self.manager.client.parse(self, parser)?;
Ok(())
}
fn set_selection(&self, parser: MsgParser<'_, '_>) -> Result<(), SetSelectionError> {
let _req: SetSelection = self.client.parse(self, parser)?;
let req: SetSelection = self.manager.client.parse(self, parser)?;
let src = if req.source.is_none() {
None
} else {
Some(self.manager.client.get_wl_data_source(req.source)?)
};
self.seat.global.set_selection(src)?;
Ok(())
}
fn release(&self, parser: MsgParser<'_, '_>) -> Result<(), ReleaseError> {
let _req: Release = self.client.parse(self, parser)?;
let _req: Release = self.manager.client.parse(self, parser)?;
self.seat.remove_data_device(self);
self.client.remove_obj(self)?;
self.manager.client.remove_obj(self)?;
Ok(())
}

5
src/ifs/wl_data_device/types.rs
View file

@ -2,7 +2,7 @@ use crate::client::{ClientError, EventFormatter, RequestParser};
use crate::fixed::Fixed;
use crate::ifs::wl_data_device::{WlDataDevice, DATA_OFFER, DROP, ENTER, LEAVE, MOTION, SELECTION};
use crate::ifs::wl_data_offer::WlDataOfferId;
use crate::ifs::wl_data_source::WlDataSourceId;
use crate::ifs::wl_data_source::{WlDataSourceError, WlDataSourceId};
use crate::ifs::wl_surface::WlSurfaceId;
use crate::object::Object;
use crate::utils::buffd::{MsgFormatter, MsgParser, MsgParserError};
@ -39,9 +39,12 @@ pub enum SetSelectionError {
ParseFailed(#[source] Box<MsgParserError>),
#[error(transparent)]
ClientError(Box<ClientError>),
#[error(transparent)]
WlDataSourceError(Box<WlDataSourceError>),
}
efrom!(SetSelectionError, ParseFailed, MsgParserError);
efrom!(SetSelectionError, ClientError);
efrom!(SetSelectionError, WlDataSourceError);
#[derive(Debug, Error)]
pub enum ReleaseError {

4
src/ifs/wl_data_device_manager/mod.rs
View file

@ -28,8 +28,8 @@ pub struct WlDataDeviceManagerGlobal {
}
pub struct WlDataDeviceManagerObj {
id: WlDataDeviceManagerId,
client: Rc<Client>,
pub id: WlDataDeviceManagerId,
pub client: Rc<Client>,
pub version: u32,
}

75
src/ifs/wl_data_offer/mod.rs
View file

@ -1,8 +1,12 @@
mod types;
use crate::client::Client;
use crate::client::{Client, DynEventFormatter};
use crate::ifs::wl_data_source::{WlDataSource};
use crate::ifs::wl_seat::WlSeatGlobal;
use crate::object::{Interface, Object, ObjectId};
use crate::utils::buffd::MsgParser;
use crate::utils::clonecell::CloneCell;
use std::ops::Deref;
use std::rc::Rc;
pub use types::*;
@ -27,24 +31,83 @@ const INVALID_OFFER: u32 = 3;
id!(WlDataOfferId);
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub enum DataOfferRole {
Selection,
}
pub struct WlDataOffer {
id: WlDataOfferId,
client: Rc<Client>,
pub id: WlDataOfferId,
pub client: Rc<Client>,
pub role: DataOfferRole,
pub source: CloneCell<Option<Rc<WlDataSource>>>,
}
impl WlDataOffer {
pub fn create(
client: &Rc<Client>,
role: DataOfferRole,
src: &Rc<WlDataSource>,
seat: &Rc<WlSeatGlobal>,
) -> Option<Rc<Self>> {
let id = match client.new_id() {
Ok(id) => id,
Err(e) => {
client.error(e);
return None;
}
};
let slf = Rc::new(Self {
id,
client: client.clone(),
role,
source: CloneCell::new(Some(src.clone())),
});
let mt = src.mime_types.borrow_mut();
seat.for_each_data_device(0, client.id, |device| {
client.event(device.data_offer(slf.id));
for mt in mt.deref() {
client.event(slf.offer(mt));
}
let ev = match role {
DataOfferRole::Selection => device.selection(id),
};
client.event(ev);
});
client.add_server_obj(&slf);
Some(slf)
}
pub fn offer(self: &Rc<Self>, mime_type: &str) -> DynEventFormatter {
Box::new(Offer {
obj: self.clone(),
mime_type: mime_type.to_string(),
})
}
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)?;
let req: Receive = self.client.parse(self, parser)?;
if let Some(src) = self.source.get() {
src.client.event(src.send(req.mime_type, req.fd));
src.client.flush();
}
Ok(())
}
fn disconnect(&self) {
if let Some(src) = self.source.set(None) {
src.destroy_offer();
}
}
fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), DestroyError> {
let _req: Destroy = self.client.parse(self, parser)?;
self.disconnect();
self.client.remove_obj(self)?;
Ok(())
}
@ -90,4 +153,8 @@ impl Object for WlDataOffer {
fn num_requests(&self) -> u32 {
SET_ACTIONS + 1
}
fn break_loops(&self) {
self.disconnect();
}
}

10
src/ifs/wl_data_offer/types.rs
View file

@ -2,7 +2,7 @@ use crate::client::{ClientError, EventFormatter, RequestParser};
use crate::ifs::wl_data_offer::{WlDataOffer, ACTION, OFFER, SOURCE_ACTIONS};
use crate::object::Object;
use crate::utils::buffd::{MsgFormatter, MsgParser, MsgParserError};
use bstr::{BStr, BString};
use bstr::{BStr};
use std::fmt::{Debug, Formatter};
use std::rc::Rc;
use thiserror::Error;
@ -83,7 +83,7 @@ impl<'a> RequestParser<'a> for Accept<'a> {
fn parse(parser: &mut MsgParser<'_, 'a>) -> Result<Self, MsgParserError> {
Ok(Self {
serial: parser.uint()?,
mime_type: parser.string()?,
mime_type: parser.bstr()?,
})
}
}
@ -98,13 +98,13 @@ impl Debug for Accept<'_> {
}
pub(super) struct Receive<'a> {
pub mime_type: &'a BStr,
pub mime_type: &'a str,
pub fd: OwnedFd,
}
impl<'a> RequestParser<'a> for Receive<'a> {
fn parse(parser: &mut MsgParser<'_, 'a>) -> Result<Self, MsgParserError> {
Ok(Self {
mime_type: parser.string()?,
mime_type: parser.str()?,
fd: parser.fd()?,
})
}
@ -168,7 +168,7 @@ impl Debug for SetActions {
pub(super) struct Offer {
pub obj: Rc<WlDataOffer>,
pub mime_type: BString,
pub mime_type: String,
}
impl EventFormatter for Offer {
fn format(self: Box<Self>, fmt: &mut MsgFormatter<'_>) {

116
src/ifs/wl_data_source/mod.rs
View file

@ -1,9 +1,15 @@
mod types;
use crate::client::Client;
use crate::client::{Client, DynEventFormatter};
use crate::ifs::wl_data_offer::{DataOfferRole, WlDataOffer};
use crate::ifs::wl_seat::WlSeatGlobal;
use crate::object::{Interface, Object, ObjectId};
use crate::utils::buffd::MsgParser;
use crate::utils::clonecell::{CloneCell, UnsafeCellCloneSafe};
use ahash::AHashSet;
use std::cell::RefCell;
use std::rc::Rc;
use uapi::OwnedFd;
pub use types::*;
const OFFER: u32 = 0;
@ -24,9 +30,20 @@ const INVALID_SOURCE: u32 = 1;
id!(WlDataSourceId);
#[derive(Clone)]
struct Attachment {
seat: Rc<WlSeatGlobal>,
role: DataOfferRole,
}
unsafe impl UnsafeCellCloneSafe for Attachment {}
pub struct WlDataSource {
id: WlDataSourceId,
client: Rc<Client>,
pub id: WlDataSourceId,
pub client: Rc<Client>,
pub mime_types: RefCell<AHashSet<String>>,
attachment: CloneCell<Option<Attachment>>,
offer: CloneCell<Option<Rc<WlDataOffer>>>,
}
impl WlDataSource {
@ -34,16 +51,101 @@ impl WlDataSource {
Self {
id,
client: client.clone(),
mime_types: RefCell::new(Default::default()),
attachment: Default::default(),
offer: Default::default(),
}
}
fn offer(&self, parser: MsgParser<'_, '_>) -> Result<(), OfferError> {
let _req: Offer = self.client.parse(self, parser)?;
pub fn attach(
&self,
seat: &Rc<WlSeatGlobal>,
role: DataOfferRole,
) -> Result<(), WlDataSourceError> {
let old = self.attachment.set(
Some(Attachment {
seat: seat.clone(),
role,
}),
);
if old.is_some() {
return Err(WlDataSourceError::AlreadyAttached);
}
Ok(())
}
pub fn detach(self: &Rc<Self>) {
self.attachment.set(None);
if let Some(offer) = self.offer.set(None) {
offer.source.set(None);
}
self.client.event(self.cancelled());
self.client.flush();
}
pub fn create_offer(self: &Rc<Self>, client: &Rc<Client>) {
let attachment = match self.attachment.get() {
Some(a) => a,
_ => {
log::error!("Trying to create an offer from a unattached data source");
return;
}
};
let offer = WlDataOffer::create(client, attachment.role, self, &attachment.seat);
let old = self.offer.set(offer);
if let Some(offer) = old {
offer.source.set(None);
}
}
pub fn destroy_offer(&self) {
self.offer.take();
}
pub fn cancelled(self: &Rc<Self>) -> DynEventFormatter {
Box::new(Cancelled {
obj: self.clone(),
})
}
pub fn send(self: &Rc<Self>, mime_type: &str, fd: OwnedFd) -> DynEventFormatter {
Box::new(Send {
obj: self.clone(),
mime_type: mime_type.to_string(),
fd: Rc::new(fd),
})
}
fn offer(&self, parser: MsgParser<'_, '_>) -> Result<(), OfferError> {
let req: Offer = self.client.parse(self, parser)?;
if self
.mime_types
.borrow_mut()
.insert(req.mime_type.to_string())
{
if let Some(offer) = self.offer.get() {
offer.client.event(offer.offer(req.mime_type));
}
}
Ok(())
}
fn disconnect(&self) {
if let Some(offer) = self.offer.take() {
offer.source.set(None);
}
if let Some(attachment) = self.attachment.get() {
match attachment.role {
DataOfferRole::Selection => {
let _ = attachment.seat.set_selection(None);
},
}
}
}
fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), DestroyError> {
let _req: Destroy = self.client.parse(self, parser)?;
self.disconnect();
self.client.remove_obj(self)?;
Ok(())
}
@ -82,4 +184,8 @@ impl Object for WlDataSource {
fn num_requests(&self) -> u32 {
SET_ACTIONS + 1
}
fn break_loops(&self) {
self.disconnect();
}
}

10
src/ifs/wl_data_source/types.rs
View file

@ -4,7 +4,7 @@ use crate::ifs::wl_data_source::{
};
use crate::object::Object;
use crate::utils::buffd::{MsgFormatter, MsgParser, MsgParserError};
use bstr::{BStr, BString};
use bstr::{BString};
use std::fmt::{Debug, Formatter};
use std::rc::Rc;
use thiserror::Error;
@ -20,6 +20,8 @@ pub enum WlDataSourceError {
DestroyError(#[from] DestroyError),
#[error("Could not process `set_actions` request")]
SetActionsError(#[from] SetActionsError),
#[error("The data source is already attached")]
AlreadyAttached,
}
efrom!(WlDataSourceError, ClientError);
@ -54,12 +56,12 @@ efrom!(SetActionsError, ParseFailed, MsgParserError);
efrom!(SetActionsError, ClientError);
pub(super) struct Offer<'a> {
pub mime_type: &'a BStr,
pub mime_type: &'a str,
}
impl<'a> RequestParser<'a> for Offer<'a> {
fn parse(parser: &mut MsgParser<'_, 'a>) -> Result<Self, MsgParserError> {
Ok(Self {
mime_type: parser.string()?,
mime_type: parser.str()?,
})
}
}
@ -117,7 +119,7 @@ impl Debug for Target {
pub(super) struct Send {
pub obj: Rc<WlDataSource>,
pub mime_type: BString,
pub mime_type: String,
pub fd: Rc<OwnedFd>,
}
impl EventFormatter for Send {

2
src/ifs/wl_registry/types.rs
View file

@ -101,7 +101,7 @@ impl<'a> RequestParser<'a> for Bind<'a> {
fn parse(parser: &mut MsgParser<'_, 'a>) -> Result<Self, MsgParserError> {
Ok(Self {
name: parser.global()?,
interface: parser.string()?,
interface: parser.bstr()?,
version: parser.uint()?,
id: parser.object()?,
})

17
src/ifs/wl_seat/handling.rs
View file

@ -2,7 +2,7 @@ use crate::backend::{KeyState, OutputId, ScrollAxis, SeatEvent, SeatId};
use crate::client::{ClientId, DynEventFormatter};
use crate::fixed::Fixed;
use crate::ifs::wl_data_device::WlDataDevice;
use crate::ifs::wl_data_offer::WlDataOfferId;
use crate::ifs::wl_data_offer::{WlDataOfferId};
use crate::ifs::wl_seat::wl_keyboard::WlKeyboard;
use crate::ifs::wl_seat::wl_pointer::{WlPointer, POINTER_FRAME_SINCE_VERSION};
use crate::ifs::wl_seat::{
@ -241,7 +241,18 @@ impl WlSeatGlobal {
k.modifiers(serial, mods_depressed, mods_latched, mods_locked, group)
});
self.surface_data_device_event(0, &surface, |dd| dd.selection(WlDataOfferId::NONE));
if old.client_id() != Some(surface.client.id) {
match self.selection.get() {
None => {
self.surface_data_device_event(0, &surface, |dd| {
dd.selection(WlDataOfferId::NONE)
});
}
Some(sel) => {
sel.create_offer(&surface.client);
}
}
}
}
fn for_each_seat<C>(&self, ver: u32, client: ClientId, mut f: C)
@ -282,7 +293,7 @@ impl WlSeatGlobal {
})
}
fn for_each_data_device<C>(&self, ver: u32, client: ClientId, mut f: C)
pub fn for_each_data_device<C>(&self, ver: u32, client: ClientId, mut f: C)
where
C: FnMut(&Rc<WlDataDevice>),
{

40
src/ifs/wl_seat/mod.rs
View file

@ -10,6 +10,8 @@ use crate::cursor::{Cursor, KnownCursor};
use crate::fixed::Fixed;
use crate::globals::{Global, GlobalName};
use crate::ifs::wl_data_device::{WlDataDevice, WlDataDeviceId};
use crate::ifs::wl_data_offer::{DataOfferRole, WlDataOfferId};
use crate::ifs::wl_data_source::{WlDataSource, WlDataSourceError};
use crate::ifs::wl_seat::wl_keyboard::{WlKeyboard, WlKeyboardId, REPEAT_INFO_SINCE};
use crate::ifs::wl_seat::wl_pointer::{WlPointer, WlPointerId};
use crate::ifs::wl_seat::wl_touch::WlTouch;
@ -95,6 +97,7 @@ pub struct WlSeatGlobal {
serial: NumCell<u32>,
grabber: RefCell<Option<PointerGrabber>>,
tree_changed: Rc<AsyncEvent>,
selection: CloneCell<Option<Rc<WlDataSource>>>,
}
impl WlSeatGlobal {
@ -144,20 +147,31 @@ impl WlSeatGlobal {
serial: Default::default(),
grabber: RefCell::new(None),
tree_changed: tree_changed.clone(),
selection: Default::default(),
}
}
// pub fn grab_pointer(self: &Rc<Self>, node: Rc<dyn Node>) -> Option<PointerGrab> {
// let mut grabber = self.grabber.borrow_mut();
// if grabber.is_some() {
// return None;
// }
// *grabber = Some(PointerGrabber {
// node,
// buttons: Default::default(),
// });
// Some(PointerGrab { seat: self.clone() })
// }
pub fn set_selection(self: &Rc<Self>, selection: Option<Rc<WlDataSource>>) -> Result<(), WlDataSourceError> {
if let Some(new) = &selection {
new.attach(self, DataOfferRole::Selection)?;
}
if let Some(old) = self.selection.set(selection.clone()) {
old.detach();
}
if let Some(client) = self.keyboard_node.get().client() {
match selection {
Some(sel) => {
sel.create_offer(&client);
}
_ => {
self.for_each_data_device(0, client.id, |device| {
client.event(device.selection(WlDataOfferId::NONE));
});
}
}
}
Ok(())
}
pub fn set_known_cursor(&self, cursor: KnownCursor) {
let cursors = match self.state.cursors.get() {
@ -292,10 +306,6 @@ impl WlSeatObj {
}
}
pub fn client(&self) -> &Rc<Client> {
&self.client
}
pub fn move_(&self, node: &Rc<FloatNode>) {
self.global.move_(node);
}

10
src/ifs/wl_surface/mod.rs
View file

@ -4,7 +4,7 @@ pub mod wl_subsurface;
pub mod xdg_surface;
use crate::backend::{KeyState, ScrollAxis, SeatId};
use crate::client::{Client, ClientId, DynEventFormatter, RequestParser};
use crate::client::{Client, DynEventFormatter, RequestParser};
use crate::fixed::Fixed;
use crate::ifs::wl_buffer::WlBuffer;
use crate::ifs::wl_callback::WlCallback;
@ -17,7 +17,9 @@ use crate::object::{Interface, Object, ObjectId};
use crate::pixman::Region;
use crate::rect::Rect;
use crate::render::Renderer;
use crate::tree::{Node, NodeId};
use crate::tree::{
Node, NodeId,
};
use crate::utils::buffd::{MsgParser, MsgParserError};
use crate::utils::clonecell::CloneCell;
use crate::utils::linkedlist::LinkedList;
@ -662,7 +664,7 @@ impl Node for WlSurface {
renderer.render_surface(self, x, y);
}
fn client_id(&self) -> Option<ClientId> {
Some(self.client.id)
fn client(&self) -> Option<Rc<Client>> {
Some(self.client.clone())
}
}

6
src/ifs/wl_surface/xdg_surface/xdg_popup/mod.rs
View file

@ -1,6 +1,6 @@
mod types;
use crate::client::{ClientId, DynEventFormatter};
use crate::client::{Client, DynEventFormatter};
use crate::cursor::KnownCursor;
use crate::fixed::Fixed;
use crate::ifs::wl_seat::{NodeSeatState, WlSeatGlobal};
@ -311,8 +311,8 @@ impl Node for XdgPopup {
self.xdg.set_workspace(ws);
}
fn client_id(&self) -> Option<ClientId> {
Some(self.xdg.surface.client.id)
fn client(&self) -> Option<Rc<Client>> {
Some(self.xdg.surface.client.clone())
}
}

6
src/ifs/wl_surface/xdg_surface/xdg_toplevel/mod.rs
View file

@ -2,7 +2,7 @@ mod types;
use crate::backend::SeatId;
use crate::bugs::Bugs;
use crate::client::{ClientId, DynEventFormatter};
use crate::client::{Client, DynEventFormatter};
use crate::cursor::KnownCursor;
use crate::fixed::Fixed;
use crate::ifs::wl_seat::{NodeSeatState, WlSeatGlobal};
@ -496,8 +496,8 @@ impl Node for XdgToplevel {
self.xdg.set_workspace(ws);
}
fn client_id(&self) -> Option<ClientId> {
Some(self.xdg.surface.client.id)
fn client(&self) -> Option<Rc<Client>> {
Some(self.xdg.surface.client.clone())
}
}

4
src/ifs/wl_surface/xdg_surface/xdg_toplevel/types.rs
View file

@ -219,7 +219,7 @@ pub(super) struct SetTitle<'a> {
impl<'a> RequestParser<'a> for SetTitle<'a> {
fn parse(parser: &mut MsgParser<'_, 'a>) -> Result<Self, MsgParserError> {
Ok(Self {
title: parser.string()?,
title: parser.bstr()?,
})
}
}
@ -235,7 +235,7 @@ pub(super) struct SetAppId<'a> {
impl<'a> RequestParser<'a> for SetAppId<'a> {
fn parse(parser: &mut MsgParser<'_, 'a>) -> Result<Self, MsgParserError> {
Ok(Self {
app_id: parser.string()?,
app_id: parser.bstr()?,
})
}
}

19
src/rect.rs
View file

@ -1,17 +1,5 @@
use std::fmt::{Debug, Formatter};
#[derive(Copy, Clone, Eq, PartialEq, Default)]
pub struct Point {
pub x: i32,
pub y: i32,
}
impl Point {
pub fn translate(&self, x: i32, y: i32) -> (i32, i32) {
(x - self.x, y - self.y)
}
}
#[derive(Copy, Clone, Eq, PartialEq, Default)]
pub struct Rect {
x1: i32,
@ -65,13 +53,6 @@ impl Rect {
}
}
pub fn to_point(&self) -> Point {
Point {
x: self.x1,
y: self.y1,
}
}
pub fn new(x1: i32, y1: i32, x2: i32, y2: i32) -> Option<Self> {
if x2 < x1 || y2 < y1 {
return None;

8
src/tree/mod.rs
View file

@ -1,5 +1,5 @@
use crate::backend::{KeyState, OutputId, ScrollAxis};
use crate::client::ClientId;
use crate::client::{Client, ClientId};
use crate::cursor::KnownCursor;
use crate::fixed::Fixed;
use crate::ifs::wl_output::WlOutputGlobal;
@ -169,9 +169,13 @@ pub trait Node {
let _ = ws;
}
fn client_id(&self) -> Option<ClientId> {
fn client(&self) -> Option<Rc<Client>> {
None
}
fn client_id(&self) -> Option<ClientId> {
self.client().map(|c| c.id)
}
}
pub struct FoundNode {

11
src/utils/buffd/parser.rs
View file

@ -16,6 +16,8 @@ pub enum MsgParserError {
MissingFd,
#[error("There is trailing data after the message")]
TrailingData,
#[error("String is not UTF-8")]
NonUtf8,
}
pub struct MsgParser<'a, 'b> {
@ -62,7 +64,7 @@ impl<'a, 'b> MsgParser<'a, 'b> {
self.int().map(Fixed)
}
pub fn string(&mut self) -> Result<&'b BStr, MsgParserError> {
pub fn bstr(&mut self) -> Result<&'b BStr, MsgParserError> {
let len = self.uint()? as usize;
if len == 0 {
return Err(MsgParserError::EmptyString);
@ -77,6 +79,13 @@ impl<'a, 'b> MsgParser<'a, 'b> {
Ok(s)
}
pub fn str(&mut self) -> Result<&'b str, MsgParserError> {
match self.bstr()?.to_str() {
Ok(s) => Ok(s),
_ => Err(MsgParserError::NonUtf8),
}
}
pub fn fd(&mut self) -> Result<OwnedFd, MsgParserError> {
match self.buf.get_fd() {
Ok(fd) => Ok(fd),

7
todo.md
View file

@ -1,4 +1,5 @@
- Container resizing
# todo
- Container moving (mouse)
- Container moving (kb)
- Float toggle
@ -14,3 +15,7 @@
- presentation time
- viewporter
- session lock
# done
- Container resizing