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

wayland: use code generation for wl_usr event handlers

Browse source
This commit is contained in:
Julian Orth 2024-07-24 15:56:18 +02:00
parent b359b2648d
commit 084fe50259
49 changed files with 554 additions and 524 deletions
Download patch file Download diff file Expand all files Collapse all files

78
build/wire.rs
View file

@ -330,6 +330,9 @@ impl<'a> Parser<'a> {
}); });
let safe_name = match name { let safe_name = match name {
"move" => "move_", "move" => "move_",
"type" => "type_",
"drop" => "drop_",
"id" => "id_",
_ => name, _ => name,
}; };
Ok(Lined { Ok(Lined {
@ -717,18 +720,50 @@ fn write_message<W: Write>(f: &mut W, obj: &str, message: &Message) -> Result<()
Ok(()) Ok(())
} }
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
enum RequestHandlerDirection {
Request,
Event,
}
fn write_request_handler<W: Write>( fn write_request_handler<W: Write>(
f: &mut W, f: &mut W,
camel_obj_name: &str, camel_obj_name: &str,
messages: &ParseResult, messages: &[Lined<Message>],
direction: RequestHandlerDirection,
) -> Result<()> { ) -> Result<()> {
let snake_direction;
let camel_direction;
let parent;
let parser;
let error;
let param;
writeln!(f)?; writeln!(f)?;
match direction {
RequestHandlerDirection::Request => {
snake_direction = "request";
camel_direction = "Request";
parent = "crate::object::Object";
parser = "crate::client::Client";
error = "crate::client::ClientError";
param = "req";
}
RequestHandlerDirection::Event => {
snake_direction = "event";
camel_direction = "Event";
parent = "crate::wl_usr::usr_object::UsrObject";
parser = "crate::wl_usr::UsrCon";
error = "crate::wl_usr::UsrConError";
param = "ev";
writeln!(f, " #[allow(dead_code)]")?;
}
}
writeln!( writeln!(
f, f,
" pub trait {camel_obj_name}RequestHandler: crate::object::Object + Sized {{" " pub trait {camel_obj_name}{camel_direction}Handler: {parent} + Sized {{"
)?; )?;
writeln!(f, " type Error: std::error::Error;")?; writeln!(f, " type Error: std::error::Error;")?;
for message in &messages.requests { for message in messages {
let msg = &message.val; let msg = &message.val;
let lt = match msg.has_reference_type { let lt = match msg.has_reference_type {
true => "<'_>", true => "<'_>",
@ -737,34 +772,31 @@ fn write_request_handler<W: Write>(
writeln!(f)?; writeln!(f)?;
writeln!( writeln!(
f, f,
" fn {}(&self, req: {}{lt}, _slf: &Rc<Self>) -> Result<(), Self::Error>;", " fn {}(&self, {param}: {}{lt}, _slf: &Rc<Self>) -> Result<(), Self::Error>;",
msg.safe_name, msg.camel_name msg.safe_name, msg.camel_name
)?; )?;
} }
writeln!(f)?; writeln!(f)?;
writeln!(f, " #[inline(always)]")?; writeln!(f, " #[inline(always)]")?;
writeln!(f, " fn handle_request_impl(")?; writeln!(f, " fn handle_{snake_direction}_impl(")?;
writeln!(f, " self: Rc<Self>,")?; writeln!(f, " self: Rc<Self>,")?;
writeln!(f, " client: &crate::client::Client,")?; writeln!(f, " client: &{parser},")?;
writeln!(f, " req: u32,")?; writeln!(f, " req: u32,")?;
writeln!( writeln!(
f, f,
" parser: crate::utils::buffd::MsgParser<'_, '_>," " parser: crate::utils::buffd::MsgParser<'_, '_>,"
)?; )?;
writeln!(f, " ) -> Result<(), crate::client::ClientError> {{")?; writeln!(f, " ) -> Result<(), {error}> {{")?;
if messages.requests.is_empty() { if messages.is_empty() {
writeln!(f, " #![allow(unused_variables)]")?; writeln!(f, " #![allow(unused_variables)]")?;
writeln!( writeln!(f, " Err({error}::InvalidMethod)")?;
f,
" Err(crate::client::ClientError::InvalidMethod)"
)?;
} else { } else {
writeln!(f, " let method;")?; writeln!(f, " let method;")?;
writeln!( writeln!(
f, f,
" let error: Box<dyn std::error::Error> = match req {{" " let error: Box<dyn std::error::Error> = match req {{"
)?; )?;
for message in &messages.requests { for message in messages {
let msg = &message.val; let msg = &message.val;
write!(f, " {} ", msg.id)?; write!(f, " {} ", msg.id)?;
if let Some(since) = msg.attribs.since { if let Some(since) = msg.attribs.since {
@ -793,13 +825,10 @@ fn write_request_handler<W: Write>(
} }
writeln!( writeln!(
f, f,
" _ => return Err(crate::client::ClientError::InvalidMethod)," " _ => return Err({error}::InvalidMethod),"
)?; )?;
writeln!(f, " }};")?; writeln!(f, " }};")?;
writeln!( writeln!(f, " Err({error}::MethodError {{")?;
f,
" Err(crate::client::ClientError::MethodError {{"
)?;
writeln!(f, " interface: {camel_obj_name},")?; writeln!(f, " interface: {camel_obj_name},")?;
writeln!(f, " method,")?; writeln!(f, " method,")?;
writeln!(f, " error,")?; writeln!(f, " error,")?;
@ -832,7 +861,18 @@ fn write_file<W: Write>(f: &mut W, file: &DirEntry) -> Result<()> {
for message in messages.requests.iter().chain(messages.events.iter()) { for message in messages.requests.iter().chain(messages.events.iter()) {
write_message(f, &camel_obj_name, &message.val)?; write_message(f, &camel_obj_name, &message.val)?;
} }
write_request_handler(f, &camel_obj_name, &messages)?; write_request_handler(
f,
&camel_obj_name,
&messages.requests,
RequestHandlerDirection::Request,
)?;
write_request_handler(
f,
&camel_obj_name,
&messages.events,
RequestHandlerDirection::Event,
)?;
writeln!(f, "}}")?; writeln!(f, "}}")?;
Ok(()) Ok(())
} }

37
src/macros.rs
View file

@ -12,39 +12,26 @@ macro_rules! efrom {
} }
macro_rules! usr_object_base { macro_rules! usr_object_base {
($oname:ident, $iname:ident; $($code:ident => $f:ident,)*) => { ($self:ident = $oname:ident = $iname:ident; version = $version:expr;) => {
impl crate::wl_usr::usr_object::UsrObjectBase for $oname { impl crate::wl_usr::usr_object::UsrObjectBase for $oname {
fn id(&self) -> crate::object::ObjectId { fn id(&$self) -> crate::object::ObjectId {
self.id.into() $self.id.into()
}
fn version(&$self) -> crate::object::Version {
$version
} }
#[allow(unused_variables, unreachable_code)]
fn handle_event( fn handle_event(
self: std::rc::Rc<Self>, $self: std::rc::Rc<Self>,
con: &crate::wl_usr::UsrCon,
event: u32, event: u32,
parser: crate::utils::buffd::MsgParser<'_, '_>, parser: crate::utils::buffd::MsgParser<'_, '_>,
) -> Result<(), crate::wl_usr::usr_object::UsrObjectError> { ) -> Result<(), crate::wl_usr::UsrConError> {
let res: std::result::Result<(), _> = match event { $self.handle_event_impl(con, event, parser)
$(
$code => $oname::$f(&self, parser).map_err(|e| crate::wl_usr::usr_object::UsrObjectErrorType::EventError {
event: stringify!($f),
error: Box::new(e),
}),
)*
_ => Err(crate::wl_usr::usr_object::UsrObjectErrorType::UnknownEventError {
event,
}),
};
if let Err(e) = res {
return Err(crate::wl_usr::usr_object::UsrObjectError {
interface: crate::wire::$iname,
ty: e,
});
}
Ok(())
} }
fn interface(&self) -> crate::object::Interface { fn interface(&$self) -> crate::object::Interface {
crate::wire::$iname crate::wire::$iname
} }
} }

10
src/portal/ptl_display.rs
View file

@ -2,6 +2,7 @@ use {
crate::{ crate::{
gfx_apis::create_gfx_context, gfx_apis::create_gfx_context,
ifs::wl_seat::POINTER, ifs::wl_seat::POINTER,
object::Version,
portal::{ portal::{
ptl_render_ctx::PortalRenderCtx, ptl_screencast::ScreencastSession, ptl_render_ctx::PortalRenderCtx, ptl_screencast::ScreencastSession,
ptr_gui::WindowData, PortalState, ptr_gui::WindowData, PortalState,
@ -213,6 +214,7 @@ impl UsrWlRegistryOwner for PortalDisplay {
id: self.con.id(), id: self.con.id(),
con: self.con.clone(), con: self.con.clone(),
owner: Default::default(), owner: Default::default(),
version: Version(version.min(5)),
}); });
self.con.add_object(ls.clone()); self.con.add_object(ls.clone());
self.registry.request_bind(name, version, ls.deref()); self.registry.request_bind(name, version, ls.deref());
@ -301,6 +303,7 @@ fn finish_display_connect(dpy: Rc<PortalDisplayPrelude>) {
con: dpy.con.clone(), con: dpy.con.clone(),
owner: Default::default(), owner: Default::default(),
caps: Default::default(), caps: Default::default(),
version: Version(version.min(4)),
}); });
dpy.con.add_object(jc.clone()); dpy.con.add_object(jc.clone());
dpy.registry.request_bind(name, version, jc.deref()); dpy.registry.request_bind(name, version, jc.deref());
@ -309,6 +312,7 @@ fn finish_display_connect(dpy: Rc<PortalDisplayPrelude>) {
let ls = Rc::new(UsrWpFractionalScaleManager { let ls = Rc::new(UsrWpFractionalScaleManager {
id: dpy.con.id(), id: dpy.con.id(),
con: dpy.con.clone(), con: dpy.con.clone(),
version: Version(version.min(1)),
}); });
dpy.con.add_object(ls.clone()); dpy.con.add_object(ls.clone());
dpy.registry.request_bind(name, version, ls.deref()); dpy.registry.request_bind(name, version, ls.deref());
@ -317,6 +321,7 @@ fn finish_display_connect(dpy: Rc<PortalDisplayPrelude>) {
let ls = Rc::new(UsrWlrLayerShell { let ls = Rc::new(UsrWlrLayerShell {
id: dpy.con.id(), id: dpy.con.id(),
con: dpy.con.clone(), con: dpy.con.clone(),
version: Version(version.min(5)),
}); });
dpy.con.add_object(ls.clone()); dpy.con.add_object(ls.clone());
dpy.registry.request_bind(name, version, ls.deref()); dpy.registry.request_bind(name, version, ls.deref());
@ -325,6 +330,7 @@ fn finish_display_connect(dpy: Rc<PortalDisplayPrelude>) {
let ls = Rc::new(UsrWpViewporter { let ls = Rc::new(UsrWpViewporter {
id: dpy.con.id(), id: dpy.con.id(),
con: dpy.con.clone(), con: dpy.con.clone(),
version: Version(version.min(1)),
}); });
dpy.con.add_object(ls.clone()); dpy.con.add_object(ls.clone());
dpy.registry.request_bind(name, version, ls.deref()); dpy.registry.request_bind(name, version, ls.deref());
@ -333,6 +339,7 @@ fn finish_display_connect(dpy: Rc<PortalDisplayPrelude>) {
let ls = Rc::new(UsrWlCompositor { let ls = Rc::new(UsrWlCompositor {
id: dpy.con.id(), id: dpy.con.id(),
con: dpy.con.clone(), con: dpy.con.clone(),
version: Version(version.min(6)),
}); });
dpy.con.add_object(ls.clone()); dpy.con.add_object(ls.clone());
dpy.registry.request_bind(name, version, ls.deref()); dpy.registry.request_bind(name, version, ls.deref());
@ -342,6 +349,7 @@ fn finish_display_connect(dpy: Rc<PortalDisplayPrelude>) {
id: dpy.con.id(), id: dpy.con.id(),
con: dpy.con.clone(), con: dpy.con.clone(),
owner: Default::default(), owner: Default::default(),
version: Version(version.min(5)),
}); });
dpy.con.add_object(ls.clone()); dpy.con.add_object(ls.clone());
dpy.registry.request_bind(name, version, ls.deref()); dpy.registry.request_bind(name, version, ls.deref());
@ -410,6 +418,7 @@ fn add_seat(dpy: &Rc<PortalDisplay>, name: u32, version: u32) {
id: dpy.con.id(), id: dpy.con.id(),
con: dpy.con.clone(), con: dpy.con.clone(),
owner: Default::default(), owner: Default::default(),
version: Version(version.min(9)),
}); });
dpy.con.add_object(wl.clone()); dpy.con.add_object(wl.clone());
dpy.registry.request_bind(name, version, wl.deref()); dpy.registry.request_bind(name, version, wl.deref());
@ -433,6 +442,7 @@ fn add_output(dpy: &Rc<PortalDisplay>, name: u32, version: u32) {
id: dpy.con.id(), id: dpy.con.id(),
con: dpy.con.clone(), con: dpy.con.clone(),
owner: Default::default(), owner: Default::default(),
version: Version(version.min(4)),
}); });
dpy.con.add_object(wl.clone()); dpy.con.add_object(wl.clone());
dpy.registry.request_bind(name, version, wl.deref()); dpy.registry.request_bind(name, version, wl.deref());

20
src/wl_usr.rs
View file

@ -6,7 +6,7 @@ use {
async_engine::{AsyncEngine, SpawnedFuture}, async_engine::{AsyncEngine, SpawnedFuture},
client::{EventFormatter, RequestParser, MIN_SERVER_ID}, client::{EventFormatter, RequestParser, MIN_SERVER_ID},
io_uring::{IoUring, IoUringError}, io_uring::{IoUring, IoUringError},
object::{ObjectId, WL_DISPLAY_ID}, object::{Interface, ObjectId, Version, WL_DISPLAY_ID},
utils::{ utils::{
asyncevent::AsyncEvent, asyncevent::AsyncEvent,
bitfield::Bitfield, bitfield::Bitfield,
@ -29,12 +29,13 @@ use {
usr_wl_callback::UsrWlCallback, usr_wl_display::UsrWlDisplay, usr_wl_callback::UsrWlCallback, usr_wl_display::UsrWlDisplay,
usr_wl_registry::UsrWlRegistry, usr_wl_registry::UsrWlRegistry,
}, },
usr_object::{UsrObject, UsrObjectError}, usr_object::UsrObject,
}, },
}, },
std::{ std::{
cell::{Cell, RefCell}, cell::{Cell, RefCell},
collections::VecDeque, collections::VecDeque,
error::Error,
mem, mem,
rc::Rc, rc::Rc,
}, },
@ -60,10 +61,17 @@ pub enum UsrConError {
Read(#[source] BufFdError), Read(#[source] BufFdError),
#[error("Could not write to the compositor")] #[error("Could not write to the compositor")]
Write(#[source] BufFdError), Write(#[source] BufFdError),
#[error(transparent)]
UsrObjectError(#[from] UsrObjectError),
#[error("Server sent an event for object {0} that does not exist")] #[error("Server sent an event for object {0} that does not exist")]
MissingObject(ObjectId), MissingObject(ObjectId),
#[error("Could not process a `{}.{}` event", .interface.name(), .method)]
MethodError {
interface: Interface,
method: &'static str,
#[source]
error: Box<dyn Error + 'static>,
},
#[error("Client tried to invoke a non-existent method")]
InvalidMethod,
} }
pub struct UsrCon { pub struct UsrCon {
@ -133,6 +141,7 @@ impl UsrCon {
Some(Rc::new(UsrWlDisplay { Some(Rc::new(UsrWlDisplay {
id: WL_DISPLAY_ID, id: WL_DISPLAY_ID,
con: slf.clone(), con: slf.clone(),
version: Version(1),
})), })),
); );
slf.incoming.set(Some( slf.incoming.set(Some(
@ -198,6 +207,7 @@ impl UsrCon {
id: self.id(), id: self.id(),
con: self.clone(), con: self.clone(),
owner: Default::default(), owner: Default::default(),
version: Version(1),
}); });
self.request(wl_display::GetRegistry { self.request(wl_display::GetRegistry {
self_id: WL_DISPLAY_ID, self_id: WL_DISPLAY_ID,
@ -352,7 +362,7 @@ impl Incoming {
if let Some(obj) = self.con.objects.get(&obj_id) { if let Some(obj) = self.con.objects.get(&obj_id) {
if let Some(obj) = obj { if let Some(obj) = obj {
let parser = MsgParser::new(&mut self.buf, &self.data); let parser = MsgParser::new(&mut self.buf, &self.data);
obj.handle_event(event, parser)?; obj.handle_event(&self.con, event, parser)?;
} }
} else if obj_id.raw() < MIN_SERVER_ID { } else if obj_id.raw() < MIN_SERVER_ID {
return Err(UsrConError::MissingObject(obj_id)); return Err(UsrConError::MissingObject(obj_id));

36
src/wl_usr/usr_ifs/usr_jay_compositor.rs
View file

@ -1,10 +1,8 @@
use { use {
crate::{ crate::{
ifs::jay_compositor::Cap, ifs::jay_compositor::Cap,
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
wire::{jay_compositor::*, JayCompositorId}, wire::{jay_compositor::*, JayCompositorId},
wl_usr::{ wl_usr::{
usr_ifs::{ usr_ifs::{
@ -19,7 +17,7 @@ use {
UsrCon, UsrCon,
}, },
}, },
std::{cell::Cell, rc::Rc}, std::{cell::Cell, convert::Infallible, rc::Rc},
}; };
pub struct UsrJayCompositor { pub struct UsrJayCompositor {
@ -27,6 +25,7 @@ pub struct UsrJayCompositor {
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrJayCompositorOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrJayCompositorOwner>>>,
pub caps: UsrJayCompositorCaps, pub caps: UsrJayCompositorCaps,
pub version: Version,
} }
#[derive(Default)] #[derive(Default)]
@ -51,6 +50,7 @@ impl UsrJayCompositor {
id: self.con.id(), id: self.con.id(),
con: self.con.clone(), con: self.con.clone(),
owner: Default::default(), owner: Default::default(),
version: self.version,
}); });
self.con.request(GetRenderCtx { self.con.request(GetRenderCtx {
self_id: self.id, self_id: self.id,
@ -65,6 +65,7 @@ impl UsrJayCompositor {
id: self.con.id(), id: self.con.id(),
con: self.con.clone(), con: self.con.clone(),
owner: Default::default(), owner: Default::default(),
version: self.version,
pending_buffers: Default::default(), pending_buffers: Default::default(),
pending_planes: Default::default(), pending_planes: Default::default(),
pending_config: Default::default(), pending_config: Default::default(),
@ -82,6 +83,7 @@ impl UsrJayCompositor {
id: self.con.id(), id: self.con.id(),
con: self.con.clone(), con: self.con.clone(),
owner: Default::default(), owner: Default::default(),
version: self.version,
}); });
self.con.request(GetOutput { self.con.request(GetOutput {
self_id: self.id, self_id: self.id,
@ -98,6 +100,7 @@ impl UsrJayCompositor {
id: self.con.id(), id: self.con.id(),
con: self.con.clone(), con: self.con.clone(),
owner: Default::default(), owner: Default::default(),
version: self.version,
}); });
self.con.request(WatchWorkspaces { self.con.request(WatchWorkspaces {
self_id: self.id, self_id: self.id,
@ -111,6 +114,7 @@ impl UsrJayCompositor {
let jp = Rc::new(UsrJayPointer { let jp = Rc::new(UsrJayPointer {
id: self.con.id(), id: self.con.id(),
con: self.con.clone(), con: self.con.clone(),
version: self.version,
}); });
self.con.add_object(jp.clone()); self.con.add_object(jp.clone());
self.con.request(GetPointer { self.con.request(GetPointer {
@ -126,6 +130,7 @@ impl UsrJayCompositor {
id: self.con.id(), id: self.con.id(),
con: self.con.clone(), con: self.con.clone(),
owner: Default::default(), owner: Default::default(),
version: self.version,
}); });
self.con.request(SelectToplevel { self.con.request(SelectToplevel {
self_id: self.id, self_id: self.id,
@ -141,6 +146,7 @@ impl UsrJayCompositor {
id: self.con.id(), id: self.con.id(),
con: self.con.clone(), con: self.con.clone(),
owner: Default::default(), owner: Default::default(),
version: self.version,
}); });
self.con.request(SelectWorkspace { self.con.request(SelectWorkspace {
self_id: self.id, self_id: self.id,
@ -150,25 +156,26 @@ impl UsrJayCompositor {
self.con.add_object(sc.clone()); self.con.add_object(sc.clone());
sc sc
} }
}
fn client_id(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { impl JayCompositorEventHandler for UsrJayCompositor {
let ev: ClientId = self.con.parse(self, parser)?; type Error = Infallible;
fn client_id(&self, ev: ClientId, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.client_id(ev); owner.client_id(ev);
} }
Ok(()) Ok(())
} }
fn seat(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn seat(&self, ev: Seat<'_>, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Seat = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.seat(ev); owner.seat(ev);
} }
Ok(()) Ok(())
} }
fn capabilities(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn capabilities(&self, ev: Capabilities<'_>, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Capabilities = self.con.parse(self, parser)?;
for &cap in ev.cap { for &cap in ev.cap {
match cap { match cap {
Cap::NONE => {} Cap::NONE => {}
@ -182,11 +189,8 @@ impl UsrJayCompositor {
} }
usr_object_base! { usr_object_base! {
UsrJayCompositor, JayCompositor; self = UsrJayCompositor = JayCompositor;
version = self.version;
CLIENT_ID => client_id,
SEAT => seat,
CAPABILITIES => capabilities,
} }
impl UsrObject for UsrJayCompositor { impl UsrObject for UsrJayCompositor {

29
src/wl_usr/usr_ifs/usr_jay_output.rs
View file

@ -1,19 +1,18 @@
use { use {
crate::{ crate::{
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
wire::{jay_output::*, JayOutputId}, wire::{jay_output::*, JayOutputId},
wl_usr::{usr_object::UsrObject, UsrCon}, wl_usr::{usr_object::UsrObject, UsrCon},
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrJayOutput { pub struct UsrJayOutput {
pub id: JayOutputId, pub id: JayOutputId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrJayOutputOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrJayOutputOwner>>>,
pub version: Version,
} }
pub trait UsrJayOutputOwner { pub trait UsrJayOutputOwner {
@ -24,17 +23,21 @@ pub trait UsrJayOutputOwner {
fn destroyed(&self) {} fn destroyed(&self) {}
} }
impl UsrJayOutput { impl JayOutputEventHandler for UsrJayOutput {
fn linear_id(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { type Error = Infallible;
let ev: LinearId = self.con.parse(self, parser)?;
fn linear_id(&self, ev: LinearId, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.linear_id(&ev); owner.linear_id(&ev);
} }
Ok(()) Ok(())
} }
fn destroyed(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn unused(&self, _ev: Unused, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let _ev: Destroyed = self.con.parse(self, parser)?; unimplemented!();
}
fn destroyed(&self, _ev: Destroyed, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.destroyed(); owner.destroyed();
} }
@ -43,10 +46,8 @@ impl UsrJayOutput {
} }
usr_object_base! { usr_object_base! {
UsrJayOutput, JayOutput; self = UsrJayOutput = JayOutput;
version = self.version;
LINEAR_ID => linear_id,
DESTROYED => destroyed,
} }
impl UsrObject for UsrJayOutput { impl UsrObject for UsrJayOutput {

11
src/wl_usr/usr_ifs/usr_jay_pointer.rs
View file

@ -1,15 +1,17 @@
use { use {
crate::{ crate::{
cursor::KnownCursor, cursor::KnownCursor,
object::Version,
wire::{jay_pointer::*, JayPointerId}, wire::{jay_pointer::*, JayPointerId},
wl_usr::{usr_object::UsrObject, UsrCon}, wl_usr::{usr_object::UsrObject, UsrCon},
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrJayPointer { pub struct UsrJayPointer {
pub id: JayPointerId, pub id: JayPointerId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub version: Version,
} }
impl UsrJayPointer { impl UsrJayPointer {
@ -21,8 +23,13 @@ impl UsrJayPointer {
} }
} }
impl JayPointerEventHandler for UsrJayPointer {
type Error = Infallible;
}
usr_object_base! { usr_object_base! {
UsrJayPointer, JayPointer; self = UsrJayPointer = JayPointer;
version = self.version;
} }
impl UsrObject for UsrJayPointer { impl UsrObject for UsrJayPointer {

25
src/wl_usr/usr_ifs/usr_jay_render_ctx.rs
View file

@ -1,13 +1,11 @@
use { use {
crate::{ crate::{
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
wire::{jay_render_ctx::*, JayRenderCtxId}, wire::{jay_render_ctx::*, JayRenderCtxId},
wl_usr::{usr_object::UsrObject, UsrCon}, wl_usr::{usr_object::UsrObject, UsrCon},
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
uapi::OwnedFd, uapi::OwnedFd,
}; };
@ -15,6 +13,7 @@ pub struct UsrJayRenderCtx {
pub id: JayRenderCtxId, pub id: JayRenderCtxId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrJayRenderCtxOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrJayRenderCtxOwner>>>,
pub version: Version,
} }
pub trait UsrJayRenderCtxOwner { pub trait UsrJayRenderCtxOwner {
@ -24,17 +23,17 @@ pub trait UsrJayRenderCtxOwner {
} }
} }
impl UsrJayRenderCtx { impl JayRenderCtxEventHandler for UsrJayRenderCtx {
fn no_device(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { type Error = Infallible;
let _ev: NoDevice = self.con.parse(self, parser)?;
fn no_device(&self, _ev: NoDevice, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.no_device(); owner.no_device();
} }
Ok(()) Ok(())
} }
fn device(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn device(&self, ev: Device, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Device = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.device(ev.fd); owner.device(ev.fd);
} }
@ -43,10 +42,8 @@ impl UsrJayRenderCtx {
} }
usr_object_base! { usr_object_base! {
UsrJayRenderCtx, JayRenderCtx; self = UsrJayRenderCtx = JayRenderCtx;
version = self.version;
NO_DEVICE => no_device,
DEVICE => device,
} }
impl UsrObject for UsrJayRenderCtx { impl UsrObject for UsrJayRenderCtx {

93
src/wl_usr/usr_ifs/usr_jay_screencast.rs
View file

@ -1,10 +1,8 @@
use { use {
crate::{ crate::{
format::formats, format::formats,
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
video::dmabuf::{DmaBuf, DmaBufPlane, PlaneVec}, video::dmabuf::{DmaBuf, DmaBufPlane, PlaneVec},
wire::{jay_screencast::*, JayScreencastId}, wire::{jay_screencast::*, JayScreencastId},
wl_usr::{ wl_usr::{
@ -24,6 +22,7 @@ pub struct UsrJayScreencast {
pub id: JayScreencastId, pub id: JayScreencastId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrJayScreencastOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrJayScreencastOwner>>>,
pub version: Version,
pub pending_buffers: RefCell<PlaneVec<DmaBuf>>, pub pending_buffers: RefCell<PlaneVec<DmaBuf>>,
pub pending_planes: RefCell<PlaneVec<DmaBufPlane>>, pub pending_planes: RefCell<PlaneVec<DmaBufPlane>>,
@ -117,9 +116,12 @@ impl UsrJayScreencast {
idx: idx as _, idx: idx as _,
}); });
} }
}
fn plane(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { impl JayScreencastEventHandler for UsrJayScreencast {
let ev: Plane = self.con.parse(self, parser)?; type Error = UsrJayScreencastError;
fn plane(&self, ev: Plane, _slf: &Rc<Self>) -> Result<(), Self::Error> {
self.pending_planes.borrow_mut().push(DmaBufPlane { self.pending_planes.borrow_mut().push(DmaBufPlane {
offset: ev.offset, offset: ev.offset,
stride: ev.stride, stride: ev.stride,
@ -128,8 +130,7 @@ impl UsrJayScreencast {
Ok(()) Ok(())
} }
fn buffer(&self, parser: MsgParser<'_, '_>) -> Result<(), UsrJayScreencastError> { fn buffer(&self, ev: Buffer, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Buffer = self.con.parse(self, parser)?;
let format = match formats().get(&ev.format) { let format = match formats().get(&ev.format) {
Some(f) => f, Some(f) => f,
_ => return Err(UsrJayScreencastError::UnknownFormat(ev.format)), _ => return Err(UsrJayScreencastError::UnknownFormat(ev.format)),
@ -145,8 +146,7 @@ impl UsrJayScreencast {
Ok(()) Ok(())
} }
fn buffers_done(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn buffers_done(&self, ev: BuffersDone, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: BuffersDone = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.buffers(mem::take(self.pending_buffers.borrow_mut().deref_mut())); owner.buffers(mem::take(self.pending_buffers.borrow_mut().deref_mut()));
} }
@ -157,56 +157,46 @@ impl UsrJayScreencast {
Ok(()) Ok(())
} }
fn ready(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn ready(&self, ev: Ready, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Ready = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.ready(&ev); owner.ready(&ev);
} }
Ok(()) Ok(())
} }
fn destroyed(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn destroyed(&self, _ev: Destroyed, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let _ev: Destroyed = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.destroyed(); owner.destroyed();
} }
Ok(()) Ok(())
} }
fn missed_frame(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn missed_frame(&self, _ev: MissedFrame, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let _ev: MissedFrame = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.missed_frame(); owner.missed_frame();
} }
Ok(()) Ok(())
} }
fn config_output(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn config_output(&self, ev: ConfigOutput, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: ConfigOutput = self.con.parse(self, parser)?;
self.pending_config.borrow_mut().output = Some(ev.linear_id); self.pending_config.borrow_mut().output = Some(ev.linear_id);
Ok(()) Ok(())
} }
fn config_allow_all_workspaces(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn config_allow_all_workspaces(
let ev: ConfigAllowAllWorkspaces = self.con.parse(self, parser)?; &self,
ev: ConfigAllowAllWorkspaces,
_slf: &Rc<Self>,
) -> Result<(), Self::Error> {
self.pending_config.borrow_mut().show_all = ev.allow_all != 0; self.pending_config.borrow_mut().show_all = ev.allow_all != 0;
Ok(()) Ok(())
} }
fn config_use_linear_buffers(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn config_allow_workspace(
let ev: ConfigUseLinearBuffers = self.con.parse(self, parser)?; &self,
self.pending_config.borrow_mut().use_linear_buffers = ev.use_linear != 0; ev: ConfigAllowWorkspace,
Ok(()) _slf: &Rc<Self>,
} ) -> Result<(), Self::Error> {
fn config_running(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> {
let ev: ConfigRunning = self.con.parse(self, parser)?;
self.pending_config.borrow_mut().running = ev.running != 0;
Ok(())
}
fn config_allow_workspace(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> {
let ev: ConfigAllowWorkspace = self.con.parse(self, parser)?;
self.pending_config self.pending_config
.borrow_mut() .borrow_mut()
.allowed_workspaces .allowed_workspaces
@ -214,8 +204,21 @@ impl UsrJayScreencast {
Ok(()) Ok(())
} }
fn config_done(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn config_use_linear_buffers(
let ev: ConfigDone = self.con.parse(self, parser)?; &self,
ev: ConfigUseLinearBuffers,
_slf: &Rc<Self>,
) -> Result<(), Self::Error> {
self.pending_config.borrow_mut().use_linear_buffers = ev.use_linear != 0;
Ok(())
}
fn config_running(&self, ev: ConfigRunning, _slf: &Rc<Self>) -> Result<(), Self::Error> {
self.pending_config.borrow_mut().running = ev.running != 0;
Ok(())
}
fn config_done(&self, ev: ConfigDone, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.config(mem::take(self.pending_config.borrow_mut().deref_mut())); owner.config(mem::take(self.pending_config.borrow_mut().deref_mut()));
} }
@ -228,20 +231,8 @@ impl UsrJayScreencast {
} }
usr_object_base! { usr_object_base! {
UsrJayScreencast, JayScreencast; self = UsrJayScreencast = JayScreencast;
version = self.version;
PLANE => plane,
BUFFER => buffer,
BUFFERS_DONE => buffers_done,
READY => ready,
DESTROYED => destroyed,
MISSED_FRAME => missed_frame,
CONFIG_OUTPUT => config_output,
CONFIG_ALLOW_ALL_WORKSPACES => config_allow_all_workspaces,
CONFIG_ALLOW_WORKSPACE => config_allow_workspace,
CONFIG_USE_LINEAR_BUFFERS => config_use_linear_buffers,
CONFIG_RUNNING => config_running,
CONFIG_DONE => config_done,
} }
impl UsrObject for UsrJayScreencast { impl UsrObject for UsrJayScreencast {
@ -256,8 +247,6 @@ impl UsrObject for UsrJayScreencast {
#[derive(Debug, Error)] #[derive(Debug, Error)]
pub enum UsrJayScreencastError { pub enum UsrJayScreencastError {
#[error("Parsing failed")]
MsgParserError(#[from] MsgParserError),
#[error("The server sent an unknown format {0}")] #[error("The server sent an unknown format {0}")]
UnknownFormat(u32), UnknownFormat(u32),
} }

29
src/wl_usr/usr_ifs/usr_jay_select_toplevel.rs
View file

@ -1,29 +1,28 @@
use { use {
crate::{ crate::{
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
wire::{jay_select_toplevel::*, JaySelectToplevelId}, wire::{jay_select_toplevel::*, JaySelectToplevelId},
wl_usr::{usr_ifs::usr_jay_toplevel::UsrJayToplevel, usr_object::UsrObject, UsrCon}, wl_usr::{usr_ifs::usr_jay_toplevel::UsrJayToplevel, usr_object::UsrObject, UsrCon},
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
thiserror::Error,
}; };
pub struct UsrJaySelectToplevel { pub struct UsrJaySelectToplevel {
pub id: JaySelectToplevelId, pub id: JaySelectToplevelId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrJaySelectToplevelOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrJaySelectToplevelOwner>>>,
pub version: Version,
} }
pub trait UsrJaySelectToplevelOwner { pub trait UsrJaySelectToplevelOwner {
fn done(&self, toplevel: Option<Rc<UsrJayToplevel>>); fn done(&self, toplevel: Option<Rc<UsrJayToplevel>>);
} }
impl UsrJaySelectToplevel { impl JaySelectToplevelEventHandler for UsrJaySelectToplevel {
fn done(&self, parser: MsgParser<'_, '_>) -> Result<(), UsrJaySelectToplevelError> { type Error = Infallible;
let ev: Done = self.con.parse(self, parser)?;
fn done(&self, ev: Done, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let tl = if ev.id.is_none() { let tl = if ev.id.is_none() {
None None
} else { } else {
@ -31,6 +30,7 @@ impl UsrJaySelectToplevel {
id: ev.id, id: ev.id,
con: self.con.clone(), con: self.con.clone(),
owner: Default::default(), owner: Default::default(),
version: self.version,
}); });
self.con.add_object(tl.clone()); self.con.add_object(tl.clone());
Some(tl) Some(tl)
@ -49,9 +49,8 @@ impl UsrJaySelectToplevel {
} }
usr_object_base! { usr_object_base! {
UsrJaySelectToplevel, JaySelectToplevel; self = UsrJaySelectToplevel = JaySelectToplevel;
version = self.version;
DONE => done,
} }
impl UsrObject for UsrJaySelectToplevel { impl UsrObject for UsrJaySelectToplevel {
@ -63,9 +62,3 @@ impl UsrObject for UsrJaySelectToplevel {
self.owner.take(); self.owner.take();
} }
} }
#[derive(Debug, Error)]
pub enum UsrJaySelectToplevelError {
#[error("Parsing failed")]
MsgParserError(#[from] MsgParserError),
}

33
src/wl_usr/usr_ifs/usr_jay_select_workspace.rs
View file

@ -1,29 +1,28 @@
use { use {
crate::{ crate::{
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
wire::{jay_select_workspace::*, JaySelectWorkspaceId}, wire::{jay_select_workspace::*, JaySelectWorkspaceId},
wl_usr::{usr_ifs::usr_jay_workspace::UsrJayWorkspace, usr_object::UsrObject, UsrCon}, wl_usr::{usr_ifs::usr_jay_workspace::UsrJayWorkspace, usr_object::UsrObject, UsrCon},
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
thiserror::Error,
}; };
pub struct UsrJaySelectWorkspace { pub struct UsrJaySelectWorkspace {
pub id: JaySelectWorkspaceId, pub id: JaySelectWorkspaceId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrJaySelectWorkspaceOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrJaySelectWorkspaceOwner>>>,
pub version: Version,
} }
pub trait UsrJaySelectWorkspaceOwner { pub trait UsrJaySelectWorkspaceOwner {
fn done(&self, output: u32, ws: Option<Rc<UsrJayWorkspace>>); fn done(&self, output: u32, ws: Option<Rc<UsrJayWorkspace>>);
} }
impl UsrJaySelectWorkspace { impl JaySelectWorkspaceEventHandler for UsrJaySelectWorkspace {
fn cancelled(&self, parser: MsgParser<'_, '_>) -> Result<(), UsrJaySelectWorkspaceError> { type Error = Infallible;
let _ev: Cancelled = self.con.parse(self, parser)?;
fn cancelled(&self, _ev: Cancelled, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.done(0, None); owner.done(0, None);
} }
@ -31,12 +30,12 @@ impl UsrJaySelectWorkspace {
Ok(()) Ok(())
} }
fn selected(&self, parser: MsgParser<'_, '_>) -> Result<(), UsrJaySelectWorkspaceError> { fn selected(&self, ev: Selected, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Selected = self.con.parse(self, parser)?;
let tl = Rc::new(UsrJayWorkspace { let tl = Rc::new(UsrJayWorkspace {
id: ev.id, id: ev.id,
con: self.con.clone(), con: self.con.clone(),
owner: Default::default(), owner: Default::default(),
version: self.version,
}); });
self.con.add_object(tl.clone()); self.con.add_object(tl.clone());
match self.owner.get() { match self.owner.get() {
@ -49,10 +48,8 @@ impl UsrJaySelectWorkspace {
} }
usr_object_base! { usr_object_base! {
UsrJaySelectWorkspace, JaySelectWorkspace; self = UsrJaySelectWorkspace = JaySelectWorkspace;
version = self.version;
CANCELLED => cancelled,
SELECTED => selected,
} }
impl UsrObject for UsrJaySelectWorkspace { impl UsrObject for UsrJaySelectWorkspace {
@ -64,9 +61,3 @@ impl UsrObject for UsrJaySelectWorkspace {
self.owner.take(); self.owner.take();
} }
} }
#[derive(Debug, Error)]
pub enum UsrJaySelectWorkspaceError {
#[error("Parsing failed")]
MsgParserError(#[from] MsgParserError),
}

21
src/wl_usr/usr_ifs/usr_jay_toplevel.rs
View file

@ -1,28 +1,28 @@
use { use {
crate::{ crate::{
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
wire::{jay_toplevel::*, JayToplevelId}, wire::{jay_toplevel::*, JayToplevelId},
wl_usr::{usr_object::UsrObject, UsrCon}, wl_usr::{usr_object::UsrObject, UsrCon},
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrJayToplevel { pub struct UsrJayToplevel {
pub id: JayToplevelId, pub id: JayToplevelId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrJayToplevelOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrJayToplevelOwner>>>,
pub version: Version,
} }
pub trait UsrJayToplevelOwner { pub trait UsrJayToplevelOwner {
fn destroyed(&self) {} fn destroyed(&self) {}
} }
impl UsrJayToplevel { impl JayToplevelEventHandler for UsrJayToplevel {
fn destroyed(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { type Error = Infallible;
let _ev: Destroyed = self.con.parse(self, parser)?;
fn destroyed(&self, _ev: Destroyed, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.destroyed(); owner.destroyed();
} }
@ -31,9 +31,8 @@ impl UsrJayToplevel {
} }
usr_object_base! { usr_object_base! {
UsrJayToplevel, JayToplevel; self = UsrJayToplevel = JayToplevel;
version = self.version;
DESTROYED => destroyed,
} }
impl UsrObject for UsrJayToplevel { impl UsrObject for UsrJayToplevel {

41
src/wl_usr/usr_ifs/usr_jay_workspace.rs
View file

@ -1,19 +1,18 @@
use { use {
crate::{ crate::{
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
wire::{jay_workspace::*, JayWorkspaceId}, wire::{jay_workspace::*, JayWorkspaceId},
wl_usr::{usr_object::UsrObject, UsrCon}, wl_usr::{usr_object::UsrObject, UsrCon},
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrJayWorkspace { pub struct UsrJayWorkspace {
pub id: JayWorkspaceId, pub id: JayWorkspaceId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrJayWorkspaceOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrJayWorkspaceOwner>>>,
pub version: Version,
} }
pub trait UsrJayWorkspaceOwner { pub trait UsrJayWorkspaceOwner {
@ -38,49 +37,45 @@ pub trait UsrJayWorkspaceOwner {
} }
} }
impl UsrJayWorkspace { impl JayWorkspaceEventHandler for UsrJayWorkspace {
fn linear_id(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { type Error = Infallible;
let ev: LinearId = self.con.parse(self, parser)?;
fn linear_id(&self, ev: LinearId, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.linear_id(&ev); owner.linear_id(&ev);
} }
Ok(()) Ok(())
} }
fn name(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn name(&self, ev: Name<'_>, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Name = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.name(&ev); owner.name(&ev);
} }
Ok(()) Ok(())
} }
fn destroyed(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn destroyed(&self, _ev: Destroyed, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let _ev: Destroyed = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.destroyed(); owner.destroyed();
} }
Ok(()) Ok(())
} }
fn done(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn done(&self, _ev: Done, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let _ev: Done = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.done(); owner.done();
} }
Ok(()) Ok(())
} }
fn output(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn output(&self, ev: Output, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Output = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.output(&ev); owner.output(&ev);
} }
Ok(()) Ok(())
} }
fn visible(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn visible(&self, ev: Visible, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Visible = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.visible(ev.visible != 0); owner.visible(ev.visible != 0);
} }
@ -89,14 +84,8 @@ impl UsrJayWorkspace {
} }
usr_object_base! { usr_object_base! {
UsrJayWorkspace, JayWorkspace; self = UsrJayWorkspace = JayWorkspace;
version = self.version;
LINEAR_ID => linear_id,
NAME => name,
DESTROYED => destroyed,
DONE => done,
OUTPUT => output,
VISIBLE => visible,
} }
impl UsrObject for UsrJayWorkspace { impl UsrObject for UsrJayWorkspace {

22
src/wl_usr/usr_ifs/usr_jay_workspace_watcher.rs
View file

@ -1,19 +1,18 @@
use { use {
crate::{ crate::{
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
wire::{jay_workspace_watcher::*, JayWorkspaceWatcherId}, wire::{jay_workspace_watcher::*, JayWorkspaceWatcherId},
wl_usr::{usr_ifs::usr_jay_workspace::UsrJayWorkspace, usr_object::UsrObject, UsrCon}, wl_usr::{usr_ifs::usr_jay_workspace::UsrJayWorkspace, usr_object::UsrObject, UsrCon},
}, },
std::{ops::Deref, rc::Rc}, std::{convert::Infallible, ops::Deref, rc::Rc},
}; };
pub struct UsrJayWorkspaceWatcher { pub struct UsrJayWorkspaceWatcher {
pub id: JayWorkspaceWatcherId, pub id: JayWorkspaceWatcherId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrJayWorkspaceWatcherOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrJayWorkspaceWatcherOwner>>>,
pub version: Version,
} }
pub trait UsrJayWorkspaceWatcherOwner { pub trait UsrJayWorkspaceWatcherOwner {
@ -23,13 +22,15 @@ pub trait UsrJayWorkspaceWatcherOwner {
} }
} }
impl UsrJayWorkspaceWatcher { impl JayWorkspaceWatcherEventHandler for UsrJayWorkspaceWatcher {
fn new(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { type Error = Infallible;
let ev: New = self.con.parse(self, parser)?;
fn new(&self, ev: New, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let jw = Rc::new(UsrJayWorkspace { let jw = Rc::new(UsrJayWorkspace {
id: ev.id, id: ev.id,
con: self.con.clone(), con: self.con.clone(),
owner: Default::default(), owner: Default::default(),
version: self.version,
}); });
self.con.add_object(jw.clone()); self.con.add_object(jw.clone());
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
@ -42,9 +43,8 @@ impl UsrJayWorkspaceWatcher {
} }
usr_object_base! { usr_object_base! {
UsrJayWorkspaceWatcher, JayWorkspaceWatcher; self = UsrJayWorkspaceWatcher = JayWorkspaceWatcher;
version = self.version;
NEW => new,
} }
impl UsrObject for UsrJayWorkspaceWatcher { impl UsrObject for UsrJayWorkspaceWatcher {

26
src/wl_usr/usr_ifs/usr_linux_buffer_params.rs
View file

@ -1,20 +1,19 @@
use { use {
crate::{ crate::{
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
video::dmabuf::DmaBuf, video::dmabuf::DmaBuf,
wire::{zwp_linux_buffer_params_v1::*, ZwpLinuxBufferParamsV1Id}, wire::{zwp_linux_buffer_params_v1::*, ZwpLinuxBufferParamsV1Id},
wl_usr::{usr_ifs::usr_wl_buffer::UsrWlBuffer, usr_object::UsrObject, UsrCon}, wl_usr::{usr_ifs::usr_wl_buffer::UsrWlBuffer, usr_object::UsrObject, UsrCon},
}, },
std::{ops::Deref, rc::Rc}, std::{convert::Infallible, ops::Deref, rc::Rc},
}; };
pub struct UsrLinuxBufferParams { pub struct UsrLinuxBufferParams {
pub id: ZwpLinuxBufferParamsV1Id, pub id: ZwpLinuxBufferParamsV1Id,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrLinuxBufferParamsOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrLinuxBufferParamsOwner>>>,
pub version: Version,
} }
pub trait UsrLinuxBufferParamsOwner { pub trait UsrLinuxBufferParamsOwner {
@ -46,13 +45,17 @@ impl UsrLinuxBufferParams {
flags: 0, flags: 0,
}); });
} }
}
fn created(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { impl ZwpLinuxBufferParamsV1EventHandler for UsrLinuxBufferParams {
let ev: Created = self.con.parse(self, parser)?; type Error = Infallible;
fn created(&self, ev: Created, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let buffer = Rc::new(UsrWlBuffer { let buffer = Rc::new(UsrWlBuffer {
id: ev.buffer, id: ev.buffer,
con: self.con.clone(), con: self.con.clone(),
owner: Default::default(), owner: Default::default(),
version: self.version,
}); });
self.con.add_object(buffer.clone()); self.con.add_object(buffer.clone());
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
@ -63,8 +66,7 @@ impl UsrLinuxBufferParams {
Ok(()) Ok(())
} }
fn failed(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn failed(&self, _ev: Failed, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let _ev: Failed = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.failed(); owner.failed();
} }
@ -73,10 +75,8 @@ impl UsrLinuxBufferParams {
} }
usr_object_base! { usr_object_base! {
UsrLinuxBufferParams, ZwpLinuxBufferParamsV1; self = UsrLinuxBufferParams = ZwpLinuxBufferParamsV1;
version = self.version;
CREATED => created,
FAILED => failed,
} }
impl UsrObject for UsrLinuxBufferParams { impl UsrObject for UsrLinuxBufferParams {

26
src/wl_usr/usr_ifs/usr_linux_dmabuf.rs
View file

@ -1,10 +1,8 @@
use { use {
crate::{ crate::{
format::{formats, Format}, format::{formats, Format},
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
wire::{ wire::{
zwp_linux_dmabuf_v1::{self, *}, zwp_linux_dmabuf_v1::{self, *},
ZwpLinuxDmabufV1Id, ZwpLinuxDmabufV1Id,
@ -13,13 +11,14 @@ use {
usr_ifs::usr_linux_buffer_params::UsrLinuxBufferParams, usr_object::UsrObject, UsrCon, usr_ifs::usr_linux_buffer_params::UsrLinuxBufferParams, usr_object::UsrObject, UsrCon,
}, },
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrLinuxDmabuf { pub struct UsrLinuxDmabuf {
pub id: ZwpLinuxDmabufV1Id, pub id: ZwpLinuxDmabufV1Id,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrLinuxDmabufOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrLinuxDmabufOwner>>>,
pub version: Version,
} }
pub trait UsrLinuxDmabufOwner { pub trait UsrLinuxDmabufOwner {
@ -35,6 +34,7 @@ impl UsrLinuxDmabuf {
id: self.con.id(), id: self.con.id(),
con: self.con.clone(), con: self.con.clone(),
owner: Default::default(), owner: Default::default(),
version: self.version,
}); });
self.con.request(CreateParams { self.con.request(CreateParams {
self_id: self.id, self_id: self.id,
@ -43,14 +43,16 @@ impl UsrLinuxDmabuf {
self.con.add_object(params.clone()); self.con.add_object(params.clone());
params params
} }
}
fn format(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { impl ZwpLinuxDmabufV1EventHandler for UsrLinuxDmabuf {
let _ev: zwp_linux_dmabuf_v1::Format = self.con.parse(self, parser)?; type Error = Infallible;
fn format(&self, _ev: zwp_linux_dmabuf_v1::Format, _slf: &Rc<Self>) -> Result<(), Self::Error> {
Ok(()) Ok(())
} }
fn modifier(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn modifier(&self, ev: Modifier, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Modifier = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
if let Some(format) = formats().get(&ev.format) { if let Some(format) = formats().get(&ev.format) {
owner.modifier( owner.modifier(
@ -64,10 +66,8 @@ impl UsrLinuxDmabuf {
} }
usr_object_base! { usr_object_base! {
UsrLinuxDmabuf, ZwpLinuxDmabufV1; self = UsrLinuxDmabuf = ZwpLinuxDmabufV1;
version = self.version;
FORMAT => format,
MODIFIER => modifier,
} }
impl UsrObject for UsrLinuxDmabuf { impl UsrObject for UsrLinuxDmabuf {

21
src/wl_usr/usr_ifs/usr_wl_buffer.rs
View file

@ -1,28 +1,28 @@
use { use {
crate::{ crate::{
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
wire::{wl_buffer::*, WlBufferId}, wire::{wl_buffer::*, WlBufferId},
wl_usr::{usr_object::UsrObject, UsrCon}, wl_usr::{usr_object::UsrObject, UsrCon},
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrWlBuffer { pub struct UsrWlBuffer {
pub id: WlBufferId, pub id: WlBufferId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrWlBufferOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrWlBufferOwner>>>,
pub version: Version,
} }
pub trait UsrWlBufferOwner { pub trait UsrWlBufferOwner {
fn release(&self) {} fn release(&self) {}
} }
impl UsrWlBuffer { impl WlBufferEventHandler for UsrWlBuffer {
fn release(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { type Error = Infallible;
let _ev: Release = self.con.parse(self, parser)?;
fn release(&self, _ev: Release, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.release(); owner.release();
} }
@ -31,9 +31,8 @@ impl UsrWlBuffer {
} }
usr_object_base! { usr_object_base! {
UsrWlBuffer, WlBuffer; self = UsrWlBuffer = WlBuffer;
version = self.version;
RELEASE => release,
} }
impl UsrObject for UsrWlBuffer { impl UsrObject for UsrWlBuffer {

18
src/wl_usr/usr_ifs/usr_wl_callback.rs
View file

@ -1,16 +1,17 @@
use { use {
crate::{ crate::{
utils::buffd::{MsgParser, MsgParserError}, object::Version,
wire::{wl_callback::*, WlCallbackId}, wire::{wl_callback::*, WlCallbackId},
wl_usr::{usr_object::UsrObject, UsrCon}, wl_usr::{usr_object::UsrObject, UsrCon},
}, },
std::{cell::Cell, rc::Rc}, std::{cell::Cell, convert::Infallible, rc::Rc},
}; };
pub struct UsrWlCallback { pub struct UsrWlCallback {
pub id: WlCallbackId, pub id: WlCallbackId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub handler: Cell<Option<Box<dyn FnOnce()>>>, pub handler: Cell<Option<Box<dyn FnOnce()>>>,
pub version: Version,
} }
impl UsrWlCallback { impl UsrWlCallback {
@ -22,11 +23,15 @@ impl UsrWlCallback {
id: con.id(), id: con.id(),
con: con.clone(), con: con.clone(),
handler: Cell::new(Some(Box::new(handler))), handler: Cell::new(Some(Box::new(handler))),
version: Version(1),
} }
} }
}
fn done(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { impl WlCallbackEventHandler for UsrWlCallback {
let _ev: Done = self.con.parse(self, parser)?; type Error = Infallible;
fn done(&self, _ev: Done, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(handler) = self.handler.take() { if let Some(handler) = self.handler.take() {
handler(); handler();
} }
@ -36,9 +41,8 @@ impl UsrWlCallback {
} }
usr_object_base! { usr_object_base! {
UsrWlCallback, WlCallback; self = UsrWlCallback = WlCallback;
version = self.version;
DONE => done,
} }
impl UsrObject for UsrWlCallback { impl UsrObject for UsrWlCallback {

17
src/wl_usr/usr_ifs/usr_wl_compositor.rs
View file

@ -1,14 +1,19 @@
use { use {
crate::{ crate::{
wire::{wl_compositor::CreateSurface, WlCompositorId}, object::Version,
wire::{
wl_compositor::{CreateSurface, WlCompositorEventHandler},
WlCompositorId,
},
wl_usr::{usr_ifs::usr_wl_surface::UsrWlSurface, usr_object::UsrObject, UsrCon}, wl_usr::{usr_ifs::usr_wl_surface::UsrWlSurface, usr_object::UsrObject, UsrCon},
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrWlCompositor { pub struct UsrWlCompositor {
pub id: WlCompositorId, pub id: WlCompositorId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub version: Version,
} }
impl UsrWlCompositor { impl UsrWlCompositor {
@ -16,6 +21,7 @@ impl UsrWlCompositor {
let sfc = Rc::new(UsrWlSurface { let sfc = Rc::new(UsrWlSurface {
id: self.con.id(), id: self.con.id(),
con: self.con.clone(), con: self.con.clone(),
version: self.version,
}); });
self.con.request(CreateSurface { self.con.request(CreateSurface {
self_id: self.id, self_id: self.id,
@ -26,8 +32,13 @@ impl UsrWlCompositor {
} }
} }
impl WlCompositorEventHandler for UsrWlCompositor {
type Error = Infallible;
}
usr_object_base! { usr_object_base! {
UsrWlCompositor, WlCompositor; self = UsrWlCompositor = WlCompositor;
version = self.version;
} }
impl UsrObject for UsrWlCompositor { impl UsrObject for UsrWlCompositor {

21
src/wl_usr/usr_ifs/usr_wl_display.rs
View file

@ -1,6 +1,6 @@
use { use {
crate::{ crate::{
utils::buffd::{MsgParser, MsgParserError}, object::Version,
wire::{wl_display::*, WlDisplayId}, wire::{wl_display::*, WlDisplayId},
wl_usr::{usr_object::UsrObject, UsrCon}, wl_usr::{usr_object::UsrObject, UsrCon},
}, },
@ -10,16 +10,17 @@ use {
pub struct UsrWlDisplay { pub struct UsrWlDisplay {
pub id: WlDisplayId, pub id: WlDisplayId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub version: Version,
} }
impl UsrWlDisplay { impl WlDisplayEventHandler for UsrWlDisplay {
fn error(&self, parser: MsgParser<'_, '_>) -> Result<(), UsrWlDisplayError> { type Error = UsrWlDisplayError;
let ev: Error = self.con.parse(self, parser)?;
fn error(&self, ev: Error<'_>, _slf: &Rc<Self>) -> Result<(), Self::Error> {
Err(UsrWlDisplayError::ServerError(ev.message.to_owned())) Err(UsrWlDisplayError::ServerError(ev.message.to_owned()))
} }
fn delete_id(&self, parser: MsgParser<'_, '_>) -> Result<(), UsrWlDisplayError> { fn delete_id(&self, ev: DeleteId, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: DeleteId = self.con.parse(self, parser)?;
self.con.release_id(ev.id); self.con.release_id(ev.id);
Ok(()) Ok(())
} }
@ -29,15 +30,11 @@ impl UsrWlDisplay {
pub enum UsrWlDisplayError { pub enum UsrWlDisplayError {
#[error("The server emitted an error: {0}")] #[error("The server emitted an error: {0}")]
ServerError(String), ServerError(String),
#[error(transparent)]
MsgParserError(#[from] MsgParserError),
} }
usr_object_base! { usr_object_base! {
UsrWlDisplay, WlDisplay; self = UsrWlDisplay = WlDisplay;
version = self.version;
ERROR => error,
DELETE_ID => delete_id,
} }
impl UsrObject for UsrWlDisplay { impl UsrObject for UsrWlDisplay {

41
src/wl_usr/usr_ifs/usr_wl_output.rs
View file

@ -1,19 +1,18 @@
use { use {
crate::{ crate::{
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
wire::{wl_output::*, WlOutputId}, wire::{wl_output::*, WlOutputId},
wl_usr::{usr_object::UsrObject, UsrCon}, wl_usr::{usr_object::UsrObject, UsrCon},
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrWlOutput { pub struct UsrWlOutput {
pub id: WlOutputId, pub id: WlOutputId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrWlOutputOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrWlOutputOwner>>>,
pub version: Version,
} }
pub trait UsrWlOutputOwner { pub trait UsrWlOutputOwner {
@ -40,49 +39,45 @@ pub trait UsrWlOutputOwner {
} }
} }
impl UsrWlOutput { impl WlOutputEventHandler for UsrWlOutput {
fn geometry(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { type Error = Infallible;
let ev: Geometry = self.con.parse(self, parser)?;
fn geometry(&self, ev: Geometry<'_>, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.geometry(&ev); owner.geometry(&ev);
} }
Ok(()) Ok(())
} }
fn mode(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn mode(&self, ev: Mode, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Mode = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.mode(&ev); owner.mode(&ev);
} }
Ok(()) Ok(())
} }
fn done(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn done(&self, _ev: Done, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let _ev: Done = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.done(); owner.done();
} }
Ok(()) Ok(())
} }
fn scale(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn scale(&self, ev: Scale, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Scale = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.scale(&ev); owner.scale(&ev);
} }
Ok(()) Ok(())
} }
fn name(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn name(&self, ev: Name<'_>, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Name = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.name(&ev); owner.name(&ev);
} }
Ok(()) Ok(())
} }
fn description(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn description(&self, ev: Description<'_>, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Description = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.description(&ev); owner.description(&ev);
} }
@ -91,14 +86,8 @@ impl UsrWlOutput {
} }
usr_object_base! { usr_object_base! {
UsrWlOutput, WlOutput; self = UsrWlOutput = WlOutput;
version = self.version;
GEOMETRY => geometry,
MODE => mode,
DONE => done,
SCALE => scale,
NAME => name,
DESCRIPTION => description,
} }
impl UsrObject for UsrWlOutput { impl UsrObject for UsrWlOutput {

65
src/wl_usr/usr_ifs/usr_wl_pointer.rs
View file

@ -1,14 +1,12 @@
use { use {
crate::{ crate::{
ifs::wl_seat::wl_pointer::PendingScroll, ifs::wl_seat::wl_pointer::PendingScroll,
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
wire::{wl_pointer::*, WlPointerId}, wire::{wl_pointer::*, WlPointerId},
wl_usr::{usr_ifs::usr_wl_surface::UsrWlSurface, usr_object::UsrObject, UsrCon}, wl_usr::{usr_ifs::usr_wl_surface::UsrWlSurface, usr_object::UsrObject, UsrCon},
}, },
std::{cell::Cell, rc::Rc}, std::{cell::Cell, convert::Infallible, rc::Rc},
}; };
pub struct UsrWlPointer { pub struct UsrWlPointer {
@ -17,6 +15,7 @@ pub struct UsrWlPointer {
pub owner: CloneCell<Option<Rc<dyn UsrWlPointerOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrWlPointerOwner>>>,
pub any_scroll_events: Cell<bool>, pub any_scroll_events: Cell<bool>,
pub pending_scroll: PendingScroll, pub pending_scroll: PendingScroll,
pub version: Version,
} }
pub trait UsrWlPointerOwner { pub trait UsrWlPointerOwner {
@ -52,41 +51,40 @@ impl UsrWlPointer {
hotspot_y: hot_y, hotspot_y: hot_y,
}); });
} }
}
fn enter(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { impl WlPointerEventHandler for UsrWlPointer {
let ev: Enter = self.con.parse(self, parser)?; type Error = Infallible;
fn enter(&self, ev: Enter, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.enter(&ev); owner.enter(&ev);
} }
Ok(()) Ok(())
} }
fn leave(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn leave(&self, ev: Leave, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Leave = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.leave(&ev); owner.leave(&ev);
} }
Ok(()) Ok(())
} }
fn motion(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn motion(&self, ev: Motion, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Motion = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.motion(&ev); owner.motion(&ev);
} }
Ok(()) Ok(())
} }
fn button(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn button(&self, ev: Button, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Button = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.button(&ev); owner.button(&ev);
} }
Ok(()) Ok(())
} }
fn axis(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn axis(&self, ev: Axis, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Axis = self.con.parse(self, parser)?;
self.pending_scroll.time_usec.set(ev.time as u64 * 1000); self.pending_scroll.time_usec.set(ev.time as u64 * 1000);
if ev.axis < 2 { if ev.axis < 2 {
self.pending_scroll.px[ev.axis as usize].set(Some(ev.value)); self.pending_scroll.px[ev.axis as usize].set(Some(ev.value));
@ -95,8 +93,7 @@ impl UsrWlPointer {
Ok(()) Ok(())
} }
fn frame(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn frame(&self, _ev: Frame, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let _ev: Frame = self.con.parse(self, parser)?;
if self.any_scroll_events.take() { if self.any_scroll_events.take() {
let pe = self.pending_scroll.take(); let pe = self.pending_scroll.take();
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
@ -106,15 +103,13 @@ impl UsrWlPointer {
Ok(()) Ok(())
} }
fn axis_source(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn axis_source(&self, ev: AxisSource, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: AxisSource = self.con.parse(self, parser)?;
self.pending_scroll.source.set(Some(ev.axis_source)); self.pending_scroll.source.set(Some(ev.axis_source));
self.any_scroll_events.set(true); self.any_scroll_events.set(true);
Ok(()) Ok(())
} }
fn axis_stop(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn axis_stop(&self, ev: AxisStop, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: AxisStop = self.con.parse(self, parser)?;
self.pending_scroll.time_usec.set(ev.time as u64 * 1000); self.pending_scroll.time_usec.set(ev.time as u64 * 1000);
if ev.axis < 2 { if ev.axis < 2 {
self.pending_scroll.stop[ev.axis as usize].set(true); self.pending_scroll.stop[ev.axis as usize].set(true);
@ -123,35 +118,31 @@ impl UsrWlPointer {
Ok(()) Ok(())
} }
fn axis_discrete(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn axis_discrete(&self, _ev: AxisDiscrete, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let _ev: AxisDiscrete = self.con.parse(self, parser)?;
self.any_scroll_events.set(true); self.any_scroll_events.set(true);
Ok(()) Ok(())
} }
fn axis_value120(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn axis_value120(&self, ev: AxisValue120, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: AxisValue120 = self.con.parse(self, parser)?;
if ev.axis < 2 { if ev.axis < 2 {
self.pending_scroll.v120[ev.axis as usize].set(Some(ev.value120)); self.pending_scroll.v120[ev.axis as usize].set(Some(ev.value120));
} }
self.any_scroll_events.set(true); self.any_scroll_events.set(true);
Ok(()) Ok(())
} }
fn axis_relative_direction(
&self,
_ev: AxisRelativeDirection,
_slf: &Rc<Self>,
) -> Result<(), Self::Error> {
Ok(())
}
} }
usr_object_base! { usr_object_base! {
UsrWlPointer, WlPointer; self = UsrWlPointer = WlPointer;
version = self.version;
ENTER => enter,
LEAVE => leave,
MOTION => motion,
BUTTON => button,
AXIS => axis,
FRAME => frame,
AXIS_SOURCE => axis_source,
AXIS_STOP => axis_stop,
AXIS_DISCRETE => axis_discrete,
AXIS_VALUE120 => axis_value120,
} }
impl UsrObject for UsrWlPointer { impl UsrObject for UsrWlPointer {

25
src/wl_usr/usr_ifs/usr_wl_registry.rs
View file

@ -1,19 +1,18 @@
use { use {
crate::{ crate::{
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
wire::{wl_registry::*, WlRegistryId}, wire::{wl_registry::*, WlRegistryId},
wl_usr::{usr_object::UsrObject, UsrCon}, wl_usr::{usr_object::UsrObject, UsrCon},
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrWlRegistry { pub struct UsrWlRegistry {
pub id: WlRegistryId, pub id: WlRegistryId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrWlRegistryOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrWlRegistryOwner>>>,
pub version: Version,
} }
pub trait UsrWlRegistryOwner { pub trait UsrWlRegistryOwner {
@ -38,17 +37,19 @@ impl UsrWlRegistry {
id: obj.id(), id: obj.id(),
}); });
} }
}
fn global(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { impl WlRegistryEventHandler for UsrWlRegistry {
let ev: Global = self.con.parse(self, parser)?; type Error = Infallible;
fn global(&self, ev: Global<'_>, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.global(ev.name, ev.interface, ev.version); owner.global(ev.name, ev.interface, ev.version);
} }
Ok(()) Ok(())
} }
fn global_remove(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn global_remove(&self, ev: GlobalRemove, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: GlobalRemove = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.global_remove(ev.name); owner.global_remove(ev.name);
} }
@ -57,10 +58,8 @@ impl UsrWlRegistry {
} }
usr_object_base! { usr_object_base! {
UsrWlRegistry, WlRegistry; self = UsrWlRegistry = WlRegistry;
version = self.version;
GLOBAL => global,
GLOBAL_REMOVE => global_remove,
} }
impl UsrObject for UsrWlRegistry { impl UsrObject for UsrWlRegistry {

26
src/wl_usr/usr_ifs/usr_wl_seat.rs
View file

@ -1,19 +1,18 @@
use { use {
crate::{ crate::{
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
wire::{wl_seat::*, WlSeatId}, wire::{wl_seat::*, WlSeatId},
wl_usr::{usr_ifs::usr_wl_pointer::UsrWlPointer, usr_object::UsrObject, UsrCon}, wl_usr::{usr_ifs::usr_wl_pointer::UsrWlPointer, usr_object::UsrObject, UsrCon},
}, },
std::{cell::Cell, rc::Rc}, std::{cell::Cell, convert::Infallible, rc::Rc},
}; };
pub struct UsrWlSeat { pub struct UsrWlSeat {
pub id: WlSeatId, pub id: WlSeatId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrWlSeatOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrWlSeatOwner>>>,
pub version: Version,
} }
pub trait UsrWlSeatOwner { pub trait UsrWlSeatOwner {
@ -34,6 +33,7 @@ impl UsrWlSeat {
owner: Default::default(), owner: Default::default(),
any_scroll_events: Cell::new(false), any_scroll_events: Cell::new(false),
pending_scroll: Default::default(), pending_scroll: Default::default(),
version: self.version,
}); });
self.con.add_object(ptr.clone()); self.con.add_object(ptr.clone());
self.con.request(GetPointer { self.con.request(GetPointer {
@ -42,17 +42,19 @@ impl UsrWlSeat {
}); });
ptr ptr
} }
}
fn capabilities(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { impl WlSeatEventHandler for UsrWlSeat {
let ev: Capabilities = self.con.parse(self, parser)?; type Error = Infallible;
fn capabilities(&self, ev: Capabilities, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.capabilities(ev.capabilities); owner.capabilities(ev.capabilities);
} }
Ok(()) Ok(())
} }
fn name(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn name(&self, ev: Name<'_>, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Name = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.name(ev.name); owner.name(ev.name);
} }
@ -61,10 +63,8 @@ impl UsrWlSeat {
} }
usr_object_base! { usr_object_base! {
UsrWlSeat, WlSeat; self = UsrWlSeat = WlSeat;
version = self.version;
CAPABILITIES => capabilities,
NAME => name,
} }
impl UsrObject for UsrWlSeat { impl UsrObject for UsrWlSeat {

22
src/wl_usr/usr_ifs/usr_wl_shm.rs
View file

@ -1,14 +1,12 @@
use { use {
crate::{ crate::{
format::{formats, map_wayland_format_id}, format::{formats, map_wayland_format_id},
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::copyhashmap::CopyHashMap,
copyhashmap::CopyHashMap,
},
wire::{wl_shm::*, WlShmId}, wire::{wl_shm::*, WlShmId},
wl_usr::{usr_ifs::usr_wl_shm_pool::UsrWlShmPool, usr_object::UsrObject, UsrCon}, wl_usr::{usr_ifs::usr_wl_shm_pool::UsrWlShmPool, usr_object::UsrObject, UsrCon},
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
uapi::OwnedFd, uapi::OwnedFd,
}; };
@ -16,6 +14,7 @@ pub struct UsrWlShm {
pub id: WlShmId, pub id: WlShmId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub formats: CopyHashMap<u32, &'static crate::format::Format>, pub formats: CopyHashMap<u32, &'static crate::format::Format>,
pub version: Version,
} }
impl UsrWlShm { impl UsrWlShm {
@ -24,6 +23,7 @@ impl UsrWlShm {
let pool = Rc::new(UsrWlShmPool { let pool = Rc::new(UsrWlShmPool {
id: self.con.id(), id: self.con.id(),
con: self.con.clone(), con: self.con.clone(),
version: self.version,
}); });
self.con.request(CreatePool { self.con.request(CreatePool {
self_id: self.id, self_id: self.id,
@ -34,9 +34,12 @@ impl UsrWlShm {
self.con.add_object(pool.clone()); self.con.add_object(pool.clone());
pool pool
} }
}
fn format(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { impl WlShmEventHandler for UsrWlShm {
let ev: Format = self.con.parse(self, parser)?; type Error = Infallible;
fn format(&self, ev: Format, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let format = map_wayland_format_id(ev.format); let format = map_wayland_format_id(ev.format);
if let Some(format) = formats().get(&format) { if let Some(format) = formats().get(&format) {
self.formats.set(format.drm, *format); self.formats.set(format.drm, *format);
@ -46,9 +49,8 @@ impl UsrWlShm {
} }
usr_object_base! { usr_object_base! {
UsrWlShm, WlShm; self = UsrWlShm = WlShm;
version = self.version;
FORMAT => format,
} }
impl UsrObject for UsrWlShm { impl UsrObject for UsrWlShm {

11
src/wl_usr/usr_ifs/usr_wl_shm_pool.rs
View file

@ -1,14 +1,16 @@
use { use {
crate::{ crate::{
object::Version,
wire::{wl_shm_pool::*, WlShmPoolId}, wire::{wl_shm_pool::*, WlShmPoolId},
wl_usr::{usr_object::UsrObject, UsrCon}, wl_usr::{usr_object::UsrObject, UsrCon},
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrWlShmPool { pub struct UsrWlShmPool {
pub id: WlShmPoolId, pub id: WlShmPoolId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub version: Version,
} }
impl UsrWlShmPool { impl UsrWlShmPool {
@ -21,8 +23,13 @@ impl UsrWlShmPool {
} }
} }
impl WlShmPoolEventHandler for UsrWlShmPool {
type Error = Infallible;
}
usr_object_base! { usr_object_base! {
UsrWlShmPool, WlShmPool; self = UsrWlShmPool = WlShmPool;
version = self.version;
} }
impl UsrObject for UsrWlShmPool { impl UsrObject for UsrWlShmPool {

37
src/wl_usr/usr_ifs/usr_wl_surface.rs
View file

@ -1,6 +1,6 @@
use { use {
crate::{ crate::{
utils::buffd::{MsgParser, MsgParserError}, object::Version,
wire::{wl_surface::*, WlSurfaceId}, wire::{wl_surface::*, WlSurfaceId},
wl_usr::{ wl_usr::{
usr_ifs::{usr_wl_buffer::UsrWlBuffer, usr_wl_callback::UsrWlCallback}, usr_ifs::{usr_wl_buffer::UsrWlBuffer, usr_wl_callback::UsrWlCallback},
@ -8,12 +8,13 @@ use {
UsrCon, UsrCon,
}, },
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrWlSurface { pub struct UsrWlSurface {
pub id: WlSurfaceId, pub id: WlSurfaceId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub version: Version,
} }
impl UsrWlSurface { impl UsrWlSurface {
@ -41,35 +42,39 @@ impl UsrWlSurface {
pub fn commit(&self) { pub fn commit(&self) {
self.con.request(Commit { self_id: self.id }); self.con.request(Commit { self_id: self.id });
} }
}
fn enter(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { impl WlSurfaceEventHandler for UsrWlSurface {
let _ev: Enter = self.con.parse(self, parser)?; type Error = Infallible;
fn enter(&self, _ev: Enter, _slf: &Rc<Self>) -> Result<(), Self::Error> {
Ok(()) Ok(())
} }
fn leave(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn leave(&self, _ev: Leave, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let _ev: Leave = self.con.parse(self, parser)?;
Ok(()) Ok(())
} }
fn preferred_buffer_scale(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn preferred_buffer_scale(
let _ev: PreferredBufferScale = self.con.parse(self, parser)?; &self,
_ev: PreferredBufferScale,
_slf: &Rc<Self>,
) -> Result<(), Self::Error> {
Ok(()) Ok(())
} }
fn preferred_buffer_transform(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn preferred_buffer_transform(
let _ev: PreferredBufferTransform = self.con.parse(self, parser)?; &self,
_ev: PreferredBufferTransform,
_slf: &Rc<Self>,
) -> Result<(), Self::Error> {
Ok(()) Ok(())
} }
} }
usr_object_base! { usr_object_base! {
UsrWlSurface, WlSurface; self = UsrWlSurface = WlSurface;
version = self.version;
ENTER => enter,
LEAVE => leave,
PREFERRED_BUFFER_SCALE => preferred_buffer_scale,
PREFERRED_BUFFER_TRANSFORM => preferred_buffer_transform,
} }
impl UsrObject for UsrWlSurface { impl UsrObject for UsrWlSurface {

12
src/wl_usr/usr_ifs/usr_wlr_layer_shell.rs
View file

@ -1,5 +1,6 @@
use { use {
crate::{ crate::{
object::Version,
wire::{zwlr_layer_shell_v1::*, ZwlrLayerShellV1Id}, wire::{zwlr_layer_shell_v1::*, ZwlrLayerShellV1Id},
wl_usr::{ wl_usr::{
usr_ifs::{ usr_ifs::{
@ -10,12 +11,13 @@ use {
UsrCon, UsrCon,
}, },
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrWlrLayerShell { pub struct UsrWlrLayerShell {
pub id: ZwlrLayerShellV1Id, pub id: ZwlrLayerShellV1Id,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub version: Version,
} }
impl UsrWlrLayerShell { impl UsrWlrLayerShell {
@ -29,6 +31,7 @@ impl UsrWlrLayerShell {
id: self.con.id(), id: self.con.id(),
con: self.con.clone(), con: self.con.clone(),
owner: Default::default(), owner: Default::default(),
version: self.version,
}); });
self.con.add_object(sfc.clone()); self.con.add_object(sfc.clone());
self.con.request(GetLayerSurface { self.con.request(GetLayerSurface {
@ -43,8 +46,13 @@ impl UsrWlrLayerShell {
} }
} }
impl ZwlrLayerShellV1EventHandler for UsrWlrLayerShell {
type Error = Infallible;
}
usr_object_base! { usr_object_base! {
UsrWlrLayerShell, ZwlrLayerShellV1; self = UsrWlrLayerShell = ZwlrLayerShellV1;
version = self.version;
} }
impl UsrObject for UsrWlrLayerShell { impl UsrObject for UsrWlrLayerShell {

25
src/wl_usr/usr_ifs/usr_wlr_layer_surface.rs
View file

@ -1,19 +1,18 @@
use { use {
crate::{ crate::{
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
wire::{zwlr_layer_surface_v1::*, ZwlrLayerSurfaceV1Id}, wire::{zwlr_layer_surface_v1::*, ZwlrLayerSurfaceV1Id},
wl_usr::{usr_object::UsrObject, UsrCon}, wl_usr::{usr_object::UsrObject, UsrCon},
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrWlrLayerSurface { pub struct UsrWlrLayerSurface {
pub id: ZwlrLayerSurfaceV1Id, pub id: ZwlrLayerSurfaceV1Id,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrWlrLayerSurfaceOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrWlrLayerSurfaceOwner>>>,
pub version: Version,
} }
pub trait UsrWlrLayerSurfaceOwner { pub trait UsrWlrLayerSurfaceOwner {
@ -48,9 +47,12 @@ impl UsrWlrLayerSurface {
layer, layer,
}); });
} }
}
fn configure(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { impl ZwlrLayerSurfaceV1EventHandler for UsrWlrLayerSurface {
let ev: Configure = self.con.parse(self, parser)?; type Error = Infallible;
fn configure(&self, ev: Configure, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.configure(&ev); owner.configure(&ev);
} }
@ -61,8 +63,7 @@ impl UsrWlrLayerSurface {
Ok(()) Ok(())
} }
fn closed(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn closed(&self, _ev: Closed, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let _ev: Closed = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.closed(); owner.closed();
} }
@ -71,10 +72,8 @@ impl UsrWlrLayerSurface {
} }
usr_object_base! { usr_object_base! {
UsrWlrLayerSurface, ZwlrLayerSurfaceV1; self = UsrWlrLayerSurface = ZwlrLayerSurfaceV1;
version = self.version;
CONFIGURE => configure,
CLOSED => closed,
} }
impl UsrObject for UsrWlrLayerSurface { impl UsrObject for UsrWlrLayerSurface {

21
src/wl_usr/usr_ifs/usr_wp_fractional_scale.rs
View file

@ -1,19 +1,18 @@
use { use {
crate::{ crate::{
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
wire::{wp_fractional_scale_v1::*, WpFractionalScaleV1Id}, wire::{wp_fractional_scale_v1::*, WpFractionalScaleV1Id},
wl_usr::{usr_object::UsrObject, UsrCon}, wl_usr::{usr_object::UsrObject, UsrCon},
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrWpFractionalScale { pub struct UsrWpFractionalScale {
pub id: WpFractionalScaleV1Id, pub id: WpFractionalScaleV1Id,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrWpFractionalScaleOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrWpFractionalScaleOwner>>>,
pub version: Version,
} }
pub trait UsrWpFractionalScaleOwner { pub trait UsrWpFractionalScaleOwner {
@ -22,9 +21,10 @@ pub trait UsrWpFractionalScaleOwner {
} }
} }
impl UsrWpFractionalScale { impl WpFractionalScaleV1EventHandler for UsrWpFractionalScale {
fn preferred_scale(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { type Error = Infallible;
let ev: PreferredScale = self.con.parse(self, parser)?;
fn preferred_scale(&self, ev: PreferredScale, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.preferred_scale(&ev); owner.preferred_scale(&ev);
} }
@ -33,9 +33,8 @@ impl UsrWpFractionalScale {
} }
usr_object_base! { usr_object_base! {
UsrWpFractionalScale, WpFractionalScaleV1; self = UsrWpFractionalScale = WpFractionalScaleV1;
version = self.version;
PREFERRED_SCALE => preferred_scale,
} }
impl UsrObject for UsrWpFractionalScale { impl UsrObject for UsrWpFractionalScale {

12
src/wl_usr/usr_ifs/usr_wp_fractional_scale_manager.rs
View file

@ -1,5 +1,6 @@
use { use {
crate::{ crate::{
object::Version,
wire::{wp_fractional_scale_manager_v1::*, WpFractionalScaleManagerV1Id}, wire::{wp_fractional_scale_manager_v1::*, WpFractionalScaleManagerV1Id},
wl_usr::{ wl_usr::{
usr_ifs::{ usr_ifs::{
@ -9,12 +10,13 @@ use {
UsrCon, UsrCon,
}, },
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrWpFractionalScaleManager { pub struct UsrWpFractionalScaleManager {
pub id: WpFractionalScaleManagerV1Id, pub id: WpFractionalScaleManagerV1Id,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub version: Version,
} }
impl UsrWpFractionalScaleManager { impl UsrWpFractionalScaleManager {
@ -23,6 +25,7 @@ impl UsrWpFractionalScaleManager {
id: self.con.id(), id: self.con.id(),
con: self.con.clone(), con: self.con.clone(),
owner: Default::default(), owner: Default::default(),
version: self.version,
}); });
self.con.add_object(fs.clone()); self.con.add_object(fs.clone());
self.con.request(GetFractionalScale { self.con.request(GetFractionalScale {
@ -34,8 +37,13 @@ impl UsrWpFractionalScaleManager {
} }
} }
impl WpFractionalScaleManagerV1EventHandler for UsrWpFractionalScaleManager {
type Error = Infallible;
}
usr_object_base! { usr_object_base! {
UsrWpFractionalScaleManager, WpFractionalScaleManagerV1; self = UsrWpFractionalScaleManager = WpFractionalScaleManagerV1;
version = self.version;
} }
impl UsrObject for UsrWpFractionalScaleManager { impl UsrObject for UsrWpFractionalScaleManager {

11
src/wl_usr/usr_ifs/usr_wp_viewport.rs
View file

@ -1,15 +1,17 @@
use { use {
crate::{ crate::{
fixed::Fixed, fixed::Fixed,
object::Version,
wire::{wp_viewport::*, WpViewportId}, wire::{wp_viewport::*, WpViewportId},
wl_usr::{usr_object::UsrObject, UsrCon}, wl_usr::{usr_object::UsrObject, UsrCon},
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrWpViewport { pub struct UsrWpViewport {
pub id: WpViewportId, pub id: WpViewportId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub version: Version,
} }
impl UsrWpViewport { impl UsrWpViewport {
@ -33,8 +35,13 @@ impl UsrWpViewport {
} }
} }
impl WpViewportEventHandler for UsrWpViewport {
type Error = Infallible;
}
usr_object_base! { usr_object_base! {
UsrWpViewport, WpViewport; self = UsrWpViewport = WpViewport;
version = self.version;
} }
impl UsrObject for UsrWpViewport { impl UsrObject for UsrWpViewport {

12
src/wl_usr/usr_ifs/usr_wp_viewporter.rs
View file

@ -1,5 +1,6 @@
use { use {
crate::{ crate::{
object::Version,
wire::{wp_viewporter::*, WpViewporterId}, wire::{wp_viewporter::*, WpViewporterId},
wl_usr::{ wl_usr::{
usr_ifs::{usr_wl_surface::UsrWlSurface, usr_wp_viewport::UsrWpViewport}, usr_ifs::{usr_wl_surface::UsrWlSurface, usr_wp_viewport::UsrWpViewport},
@ -7,12 +8,13 @@ use {
UsrCon, UsrCon,
}, },
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrWpViewporter { pub struct UsrWpViewporter {
pub id: WpViewporterId, pub id: WpViewporterId,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub version: Version,
} }
impl UsrWpViewporter { impl UsrWpViewporter {
@ -20,6 +22,7 @@ impl UsrWpViewporter {
let wv = Rc::new(UsrWpViewport { let wv = Rc::new(UsrWpViewport {
id: self.con.id(), id: self.con.id(),
con: self.con.clone(), con: self.con.clone(),
version: self.version,
}); });
self.con.add_object(wv.clone()); self.con.add_object(wv.clone());
self.con.request(GetViewport { self.con.request(GetViewport {
@ -31,8 +34,13 @@ impl UsrWpViewporter {
} }
} }
impl WpViewporterEventHandler for UsrWpViewporter {
type Error = Infallible;
}
usr_object_base! { usr_object_base! {
UsrWpViewporter, WpViewporter; self = UsrWpViewporter = WpViewporter;
version = self.version;
} }
impl UsrObject for UsrWpViewporter { impl UsrObject for UsrWpViewporter {

45
src/wl_usr/usr_ifs/usr_zwlr_screencopy_frame.rs
View file

@ -1,19 +1,18 @@
use { use {
crate::{ crate::{
utils::{ object::Version,
buffd::{MsgParser, MsgParserError}, utils::clonecell::CloneCell,
clonecell::CloneCell,
},
wire::{zwlr_screencopy_frame_v1::*, ZwlrScreencopyFrameV1Id}, wire::{zwlr_screencopy_frame_v1::*, ZwlrScreencopyFrameV1Id},
wl_usr::{usr_ifs::usr_wl_buffer::UsrWlBuffer, usr_object::UsrObject, UsrCon}, wl_usr::{usr_ifs::usr_wl_buffer::UsrWlBuffer, usr_object::UsrObject, UsrCon},
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrZwlrScreencopyFrame { pub struct UsrZwlrScreencopyFrame {
pub id: ZwlrScreencopyFrameV1Id, pub id: ZwlrScreencopyFrameV1Id,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrZwlrScreencopyFrameOwner>>>, pub owner: CloneCell<Option<Rc<dyn UsrZwlrScreencopyFrameOwner>>>,
pub version: Version,
} }
pub trait UsrZwlrScreencopyFrameOwner { pub trait UsrZwlrScreencopyFrameOwner {
@ -58,57 +57,54 @@ impl UsrZwlrScreencopyFrame {
buffer: buffer.id, buffer: buffer.id,
}); });
} }
}
fn buffer(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { impl ZwlrScreencopyFrameV1EventHandler for UsrZwlrScreencopyFrame {
let ev: Buffer = self.con.parse(self, parser)?; type Error = Infallible;
fn buffer(&self, ev: Buffer, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.buffer(&ev); owner.buffer(&ev);
} }
Ok(()) Ok(())
} }
fn flags(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn flags(&self, ev: Flags, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Flags = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.flags(&ev); owner.flags(&ev);
} }
Ok(()) Ok(())
} }
fn ready(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn ready(&self, ev: Ready, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Ready = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.ready(&ev); owner.ready(&ev);
} }
Ok(()) Ok(())
} }
fn failed(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn failed(&self, _ev: Failed, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let _ev: Failed = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.failed(); owner.failed();
} }
Ok(()) Ok(())
} }
fn damage(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn damage(&self, ev: Damage, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: Damage = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.damage(&ev); owner.damage(&ev);
} }
Ok(()) Ok(())
} }
fn linux_dmabuf(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn linux_dmabuf(&self, ev: LinuxDmabuf, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let ev: LinuxDmabuf = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.linux_dmabuf(&ev); owner.linux_dmabuf(&ev);
} }
Ok(()) Ok(())
} }
fn buffer_done(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> { fn buffer_done(&self, _ev: BufferDone, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let _ev: BufferDone = self.con.parse(self, parser)?;
if let Some(owner) = self.owner.get() { if let Some(owner) = self.owner.get() {
owner.buffer_done(); owner.buffer_done();
} }
@ -117,15 +113,8 @@ impl UsrZwlrScreencopyFrame {
} }
usr_object_base! { usr_object_base! {
UsrZwlrScreencopyFrame, ZwlrScreencopyFrameV1; self = UsrZwlrScreencopyFrame = ZwlrScreencopyFrameV1;
version = self.version;
BUFFER => buffer,
FLAGS => flags,
READY => ready,
FAILED => failed,
DAMAGE => damage,
LINUX_DMABUF => linux_dmabuf,
BUFFER_DONE => buffer_done,
} }
impl UsrObject for UsrZwlrScreencopyFrame { impl UsrObject for UsrZwlrScreencopyFrame {

13
src/wl_usr/usr_ifs/usr_zwlr_screencopy_manager.rs
View file

@ -1,5 +1,6 @@
use { use {
crate::{ crate::{
object::Version,
wire::{zwlr_screencopy_manager_v1::*, ZwlrScreencopyManagerV1Id}, wire::{zwlr_screencopy_manager_v1::*, ZwlrScreencopyManagerV1Id},
wl_usr::{ wl_usr::{
usr_ifs::{ usr_ifs::{
@ -9,11 +10,13 @@ use {
UsrCon, UsrCon,
}, },
}, },
std::rc::Rc, std::{convert::Infallible, rc::Rc},
}; };
pub struct UsrZwlrScreencopyManager { pub struct UsrZwlrScreencopyManager {
pub id: ZwlrScreencopyManagerV1Id, pub id: ZwlrScreencopyManagerV1Id,
pub con: Rc<UsrCon>, pub con: Rc<UsrCon>,
pub version: Version,
} }
impl UsrZwlrScreencopyManager { impl UsrZwlrScreencopyManager {
@ -23,6 +26,7 @@ impl UsrZwlrScreencopyManager {
id: self.con.id(), id: self.con.id(),
con: self.con.clone(), con: self.con.clone(),
owner: Default::default(), owner: Default::default(),
version: self.version,
}); });
self.con.request(CaptureOutput { self.con.request(CaptureOutput {
self_id: self.id, self_id: self.id,
@ -35,8 +39,13 @@ impl UsrZwlrScreencopyManager {
} }
} }
impl ZwlrScreencopyManagerV1EventHandler for UsrZwlrScreencopyManager {
type Error = Infallible;
}
usr_object_base! { usr_object_base! {
UsrZwlrScreencopyManager, ZwlrScreencopyManagerV1; self = UsrZwlrScreencopyManager = ZwlrScreencopyManagerV1;
version = self.version;
} }
impl UsrObject for UsrZwlrScreencopyManager { impl UsrObject for UsrZwlrScreencopyManager {

28
src/wl_usr/usr_object.rs
View file

@ -1,40 +1,22 @@
use { use {
crate::{ crate::{
object::{Interface, ObjectId}, object::{Interface, ObjectId, Version},
utils::buffd::MsgParser, utils::buffd::MsgParser,
wl_usr::{UsrCon, UsrConError},
}, },
std::rc::Rc, std::rc::Rc,
thiserror::Error,
}; };
#[derive(Debug, Error)]
pub enum UsrObjectErrorType {
#[error("Could not process a `{event}` event")]
EventError {
event: &'static str,
#[source]
error: Box<dyn std::error::Error>,
},
#[error("Unknown event {event}")]
UnknownEventError { event: u32 },
}
#[derive(Debug, Error)]
#[error("An error occurred in a `{}`", .interface.name())]
pub struct UsrObjectError {
pub interface: Interface,
#[source]
pub ty: UsrObjectErrorType,
}
pub trait UsrObjectBase { pub trait UsrObjectBase {
fn id(&self) -> ObjectId; fn id(&self) -> ObjectId;
fn handle_event( fn handle_event(
self: Rc<Self>, self: Rc<Self>,
con: &UsrCon,
event: u32, event: u32,
parser: MsgParser<'_, '_>, parser: MsgParser<'_, '_>,
) -> Result<(), UsrObjectError>; ) -> Result<(), UsrConError>;
fn interface(&self) -> Interface; fn interface(&self) -> Interface;
fn version(&self) -> Version;
} }
pub trait UsrObject: UsrObjectBase + 'static { pub trait UsrObject: UsrObjectBase + 'static {

4
wire/wl_data_offer.txt
View file

@ -27,10 +27,10 @@ event offer {
mime_type: str, mime_type: str,
} }
event source_actions { event source_actions (since = 3) {
source_actions: u32, source_actions: u32,
} }
event action { event action (since = 3) {
dnd_action: u32, dnd_action: u32,
} }

6
wire/wl_data_source.txt
View file

@ -27,14 +27,14 @@ event cancelled {
} }
event dnd_drop_performed { event dnd_drop_performed (since = 3) {
} }
event dnd_finished { event dnd_finished (since = 3) {
} }
event action { event action (since = 3) {
dnd_action: u32, dnd_action: u32,
} }

2
wire/wl_keyboard.txt
View file

@ -38,7 +38,7 @@ event modifiers {
group: u32, group: u32,
} }
event repeat_info { event repeat_info (since = 4) {
rate: i32, rate: i32,
delay: i32, delay: i32,
} }

8
wire/wl_output.txt
View file

@ -24,18 +24,18 @@ event mode {
refresh : i32, refresh : i32,
} }
event done { event done (since = 2) {
} }
event scale { event scale (since = 2) {
factor: i32, factor: i32,
} }
event name { event name (since = 4) {
name: str, name: str,
} }
event description { event description (since = 4) {
description: str, description: str,
} }

12
wire/wl_pointer.txt
View file

@ -44,30 +44,30 @@ event axis {
value: fixed, value: fixed,
} }
event frame { event frame (since = 5) {
} }
event axis_source { event axis_source (since = 5) {
axis_source: u32, axis_source: u32,
} }
event axis_stop { event axis_stop (since = 5) {
time: u32, time: u32,
axis: u32, axis: u32,
} }
event axis_discrete { event axis_discrete (since = 5) {
axis: u32, axis: u32,
discrete: i32, discrete: i32,
} }
event axis_value120 { event axis_value120 (since = 8) {
axis: u32, axis: u32,
value120: i32, value120: i32,
} }
event axis_relative_direction { event axis_relative_direction (since = 9) {
axis: u32, axis: u32,
direction: u32, direction: u32,
} }

2
wire/wl_seat.txt
View file

@ -21,6 +21,6 @@ event capabilities {
capabilities: u32, capabilities: u32,
} }
event name { event name (since = 2) {
name: str, name: str,
} }

4
wire/wl_surface.txt
View file

@ -61,10 +61,10 @@ event leave {
output: id(wl_output), output: id(wl_output),
} }
event preferred_buffer_scale { event preferred_buffer_scale (since = 6) {
factor: i32, factor: i32,
} }
event preferred_buffer_transform { event preferred_buffer_transform (since = 6) {
transform: u32, transform: u32,
} }

4
wire/wl_touch.txt
View file

@ -36,13 +36,13 @@ event cancel {
} }
event shape { event shape (since = 6) {
id: i32, id: i32,
major: fixed, major: fixed,
minor: fixed, minor: fixed,
} }
event orientation { event orientation (since = 6) {
id: i32, id: i32,
orientation: fixed, orientation: fixed,
} }

2
wire/xdg_popup.txt
View file

@ -25,6 +25,6 @@ event popup_done {
} }
event repositioned { event repositioned (since = 3) {
token: u32, token: u32,
} }

4
wire/xdg_toplevel.txt
View file

@ -68,11 +68,11 @@ event configure {
event close { } event close { }
event configure_bounds { event configure_bounds (since = 4) {
width: i32, width: i32,
height: i32, height: i32,
} }
event wm_capabilities { event wm_capabilities (since = 5) {
capabilities: array(u32), capabilities: array(u32),
} }

2
wire/zwp_linux_dmabuf_v1.txt
View file

@ -21,7 +21,7 @@ event format {
format: u32, format: u32,
} }
event modifier { event modifier (since = 3) {
format: u32, format: u32,
modifier_hi: u32, modifier_hi: u32,
modifier_lo: u32, modifier_lo: u32,

4
wire/zwp_pointer_gesture_hold_v1.txt
View file

@ -2,14 +2,14 @@ request destroy (since = 3) {
} }
event begin { event begin (since = 3) {
serial: u32, serial: u32,
time: u32, time: u32,
surface: id(wl_surface), surface: id(wl_surface),
fingers: u32, fingers: u32,
} }
event end { event end (since = 3) {
serial: u32, serial: u32,
time: u32, time: u32,
cancelled: i32, cancelled: i32,

4
wire/zxdg_output_v1.txt
View file

@ -16,10 +16,10 @@ event logical_size {
event done { } event done { }
event name { event name (since = 2) {
name: str, name: str,
} }
event description { event description (since = 2) {
description: str, description: str,
} }