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

Merge pull request #237 from mahkoh/jorth/next

Browse source 
Jorth/next
This commit is contained in:
mahkoh 2024-07-25 22:02:52 +02:00 • committed by GitHub
commit 6fff9be164
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
55 changed files with 631 additions and 599 deletions
Download patch file Download diff file Expand all files Collapse all files

10
build/tokens.rs
View file

@ -1,6 +1,6 @@
use {
anyhow::{bail, Context, Result},
bstr::{BStr, BString, ByteSlice},
bstr::{BString, ByteSlice},
};
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
@ -54,14 +54,14 @@ pub struct Token<'a> {
#[derive(Debug, Eq, PartialEq)]
pub enum TokenKind<'a> {
Ident(&'a BStr),
Ident(&'a str),
Num(u32),
Tree {
delim: TreeDelim,
body: Vec<Token<'a>>,
},
Symbol(Symbol),
String(BString),
String(String),
}
impl TokenKind<'_> {
@ -148,7 +148,7 @@ impl<'a> Tokenizer<'a> {
{
c.pos += 1;
}
TokenKind::Ident(c.s[b_pos..c.pos].as_bstr())
TokenKind::Ident(c.s[b_pos..c.pos].as_bstr().to_str()?)
}
b'0'..=b'9' => {
c.pos -= 1;
@ -201,7 +201,7 @@ impl<'a> Tokenizer<'a> {
bail!("Unterminated string in line {}", self.line);
}
c.pos += 1;
TokenKind::String(res.into())
TokenKind::String(BString::from(res).to_string())
}
_ => bail!("Unexpected byte {:?} in line {}", b as char, self.line),
};

78
build/wire.rs
View file

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

18
build/wire_dbus.rs
View file

@ -35,26 +35,26 @@ enum Type {
#[derive(Debug)]
struct Field {
name: BString,
name: String,
ty: Type,
}
#[derive(Debug)]
struct Function {
name: BString,
name: String,
in_fields: Vec<Field>,
out_fields: Vec<Field>,
}
#[derive(Debug)]
struct Property {
name: BString,
name: String,
ty: Type,
}
#[derive(Debug)]
struct Signal {
name: BString,
name: String,
fields: Vec<Field>,
}
@ -181,7 +181,7 @@ impl<'a> Parser<'a> {
res.with_context(|| format!("While parsing field starting at line {}", line))
}
fn expect_ident(&mut self) -> Result<(u32, &'a BStr)> {
fn expect_ident(&mut self) -> Result<(u32, &'a str)> {
self.not_eof()?;
let token = &self.tokens[self.pos];
self.pos += 1;
@ -468,7 +468,7 @@ fn write_type2<W: Write>(f: &mut W, lt: &str, ty: &Type) -> Result<()> {
fn write_message<W: Write>(
f: &mut W,
el: &Element,
msg_name: &BStr,
msg_name: &str,
name: &str,
indent: &str,
fields: &[Field],
@ -614,7 +614,7 @@ fn write_signal<W: Write>(f: &mut W, element: &Element, sig: &Signal, indent: &s
write_message(
f,
element,
sig.name.as_bstr(),
&sig.name,
&name,
indent,
&sig.fields,
@ -640,7 +640,7 @@ fn write_function<W: Write>(
write_message(
f,
element,
fun.name.as_bstr(),
&fun.name,
&in_name,
indent,
&fun.in_fields,
@ -650,7 +650,7 @@ fn write_function<W: Write>(
write_message(
f,
element,
fun.name.as_bstr(),
&fun.name,
&out_name,
indent,
&fun.out_fields,

88
build/wire_xcon.rs
View file

@ -4,7 +4,7 @@ use {
tokens::{tokenize, Symbol, Token, TokenKind, TreeDelim},
},
anyhow::{bail, Context, Result},
bstr::{BStr, BString, ByteSlice},
bstr::ByteSlice,
std::{cell::Cell, collections::HashMap, io::Write, mem, os::unix::ffi::OsStrExt, rc::Rc},
};
@ -70,7 +70,7 @@ impl<'a> Parser<'a> {
Ok(())
}
fn parse_extension(&mut self, line: u32) -> Result<BString> {
fn parse_extension(&mut self, line: u32) -> Result<String> {
let res: Result<_> = (|| {
let (_, name) = self.expect_string()?;
Ok(name.to_owned())
@ -208,7 +208,7 @@ impl<'a> Parser<'a> {
res.with_context(|| format!("While parsing bitmask starting at line {}", line))
}
fn parse_struct_body(&mut self, name: &BStr) -> Result<Struct> {
fn parse_struct_body(&mut self, name: &str) -> Result<Struct> {
let mut fields = vec![];
while !self.eof() {
fields.push(self.parse_field()?);
@ -272,7 +272,7 @@ impl<'a> Parser<'a> {
}
}
fn expect_ident(&mut self) -> Result<(u32, &'a BStr)> {
fn expect_ident(&mut self) -> Result<(u32, &'a str)> {
self.not_eof()?;
let token = &self.tokens[self.pos];
self.pos += 1;
@ -286,7 +286,7 @@ impl<'a> Parser<'a> {
}
}
fn expect_string(&mut self) -> Result<(u32, &'a BString)> {
fn expect_string(&mut self) -> Result<(u32, &'a String)> {
self.not_eof()?;
let token = &self.tokens[self.pos];
self.pos += 1;
@ -459,7 +459,7 @@ impl<'a> Parser<'a> {
Ok(name)
}
fn parse_field_name_expr(&mut self) -> Result<BString> {
fn parse_field_name_expr(&mut self) -> Result<String> {
let (_, tree) = self.expect_tree(TreeDelim::Paren)?;
let mut parser = Parser::new(tree);
let (_, name) = parser.expect_ident()?;
@ -560,7 +560,7 @@ fn needs_lifetime(ty: &Type, protocols: &Protocols) -> Result<bool> {
Type::U64 => false,
Type::Fd => false,
Type::List(_, _) => true,
Type::Named(n) => named_needs_lt(n.as_bstr(), protocols)?,
Type::Named(n) => named_needs_lt(n, protocols)?,
Type::String(_) => true,
Type::Bitmask(_, _) => false,
Type::Enum(n, _) => needs_lifetime(n, protocols)?,
@ -568,7 +568,7 @@ fn needs_lifetime(ty: &Type, protocols: &Protocols) -> Result<bool> {
Ok(res)
}
fn named_needs_lt(name: &BStr, protocols: &Protocols) -> Result<bool> {
fn named_needs_lt(name: &str, protocols: &Protocols) -> Result<bool> {
let s = match protocols.types_by_name.get(name) {
Some(s) => s,
_ => bail!("Struct {} referenced but not defined", name),
@ -640,14 +640,14 @@ fn type_has_fds(ty: &Type, protocols: &Protocols) -> Result<bool> {
Type::String(_) => false,
Type::Fd => true,
Type::List(ty, _) => return type_has_fds(ty, protocols),
Type::Named(n) => return named_has_fds(n.as_bstr(), protocols),
Type::Named(n) => return named_has_fds(n, protocols),
Type::Bitmask(_, _) => false,
Type::Enum(n, _) => return type_has_fds(n, protocols),
};
Ok(res)
}
fn named_has_fds(s: &BStr, protocols: &Protocols) -> Result<bool> {
fn named_has_fds(s: &str, protocols: &Protocols) -> Result<bool> {
let s = match protocols.types_by_name.get(s) {
Some(s) => s,
_ => bail!("Struct {} referenced but not defined", s),
@ -698,19 +698,19 @@ enum Type {
Fd,
String(Expr),
List(Box<Type>, Option<Expr>),
Bitmask(BString, Expr),
Bitmask(String, Expr),
Enum(Box<Type>, Expr),
Named(BString),
Named(String),
}
#[derive(Debug, Clone)]
enum Expr {
It,
Field(BString),
Len(BString),
Field(String),
Len(String),
Literal(u32),
Bitmask(BString),
Variant(BString),
Bitmask(String),
Variant(String),
Sum(Box<Expr>),
Mul(Box<Expr>, Box<Expr>),
Map(Box<Expr>, Box<Expr>),
@ -722,7 +722,7 @@ enum Expr {
#[derive(Debug, Clone)]
struct RealField {
name: BString,
name: String,
ty: Type,
value: Option<Expr>,
}
@ -738,7 +738,7 @@ enum Field {
#[derive(Debug)]
struct Struct {
name: BString,
name: String,
fields: Vec<Field>,
needs_lt: Cell<Option<bool>>,
has_fds: Cell<Option<bool>>,
@ -746,27 +746,27 @@ struct Struct {
#[derive(Debug)]
struct BitmaskVariant {
name: BString,
name: String,
ty: Type,
bit: u32,
}
#[derive(Debug)]
struct Bitmask {
name: BString,
name: String,
variants: Vec<BitmaskVariant>,
}
#[derive(Debug)]
struct EnumVariant {
name: BString,
name: String,
ty: Type,
value: u32,
}
#[derive(Debug)]
struct Enum {
name: BString,
name: String,
variants: Vec<EnumVariant>,
}
@ -780,9 +780,9 @@ struct Event {
#[derive(Debug)]
struct EventCopy {
name: BString,
name: String,
opcode: u32,
original: BString,
original: String,
}
#[derive(Debug)]
@ -795,7 +795,7 @@ struct Request {
#[derive(Debug)]
struct Protocol {
extension: Option<BString>,
extension: Option<String>,
structs: Vec<Struct>,
requests: Vec<Request>,
bitmasks: Vec<Bitmask>,
@ -806,8 +806,8 @@ struct Protocol {
#[derive(Debug)]
struct Extension {
name: BString,
ident: BString,
name: String,
ident: String,
}
#[derive(Debug)]
@ -824,8 +824,8 @@ struct Protocols {
bitmasks: Vec<Rc<Bitmask>>,
enums: Vec<Rc<Enum>>,
requests: Vec<Request>,
types_by_name: HashMap<BString, NamedType>,
events_by_name: HashMap<BString, Rc<Event>>,
types_by_name: HashMap<String, NamedType>,
events_by_name: HashMap<String, Rc<Event>>,
events: Vec<Rc<Event>>,
eventcopies: Vec<EventCopy>,
}
@ -869,7 +869,7 @@ fn write_type<F: Write>(f: &mut F, ty: &Type, protocols: &Protocols) -> Result<(
return Ok(());
}
Type::Named(n) => {
let lt = if named_needs_lt(n.as_bstr(), protocols)? {
let lt = if named_needs_lt(n, protocols)? {
"<'a>"
} else {
""
@ -944,7 +944,7 @@ enum StructUsecase<'a> {
fn format_xevent<F: Write>(
f: &mut F,
name: &BStr,
name: &str,
s: &Struct,
opcode: u32,
protocols: &Protocols,
@ -965,18 +965,11 @@ fn format_xevent<F: Write>(
fn format_event<F: Write>(f: &mut F, s: &Event, protocols: &Protocols) -> Result<()> {
format_struct(f, &s.data, protocols, &StructUsecase::Event { xge: s.xge })?;
format_xevent(
f,
s.data.name.as_bstr(),
&s.data,
s.opcode,
protocols,
s.ext_idx,
)
format_xevent(f, &s.data.name, &s.data, s.opcode, protocols, s.ext_idx)
}
fn format_eventcopy<F: Write>(f: &mut F, s: &EventCopy, protocols: &Protocols) -> Result<()> {
let original = match protocols.events_by_name.get(s.original.as_bstr()) {
let original = match protocols.events_by_name.get(&s.original) {
Some(o) => o,
_ => bail!("Event {} referenced but not defined", s.original),
};
@ -992,7 +985,7 @@ fn format_eventcopy<F: Write>(f: &mut F, s: &EventCopy, protocols: &Protocols) -
)?;
format_xevent(
f,
s.name.as_bstr(),
&s.name,
&original.data,
s.opcode,
protocols,
@ -1591,16 +1584,13 @@ pub fn main() -> Result<()> {
}
protocols.eventcopies.extend(protocol.eventcopies);
if let Some(ext) = protocol.extension {
let mut ident = vec![];
for c in ext.as_bytes() {
if matches!(*c, b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9') {
ident.push(*c);
let mut ident = String::new();
for c in ext.chars() {
if matches!(c, 'a'..='z' | 'A'..='Z' | '0'..='9') {
ident.push(c);
}
}
protocols.extensions.push(Extension {
name: ext,
ident: ident.into(),
});
protocols.extensions.push(Extension { name: ext, ident });
}
}

37
src/macros.rs
View file

@ -12,39 +12,26 @@ macro_rules! efrom {
}
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 {
fn id(&self) -> crate::object::ObjectId {
self.id.into()
fn id(&$self) -> crate::object::ObjectId {
$self.id.into()
}
fn version(&$self) -> crate::object::Version {
$version
}
#[allow(unused_variables, unreachable_code)]
fn handle_event(
self: std::rc::Rc<Self>,
$self: std::rc::Rc<Self>,
con: &crate::wl_usr::UsrCon,
event: u32,
parser: crate::utils::buffd::MsgParser<'_, '_>,
) -> Result<(), crate::wl_usr::usr_object::UsrObjectError> {
let res: std::result::Result<(), _> = match event {
$(
$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(())
) -> Result<(), crate::wl_usr::UsrConError> {
$self.handle_event_impl(con, event, parser)
}
fn interface(&self) -> crate::object::Interface {
fn interface(&$self) -> crate::object::Interface {
crate::wire::$iname
}
}

17
src/portal.rs
View file

@ -14,7 +14,7 @@ use {
forker::ForkerError,
io_uring::IoUring,
logger::Logger,
pipewire::pw_con::{PwCon, PwConHolder, PwConOwner},
pipewire::pw_con::{PwConHolder, PwConOwner},
portal::{
ptl_display::{watch_displays, PortalDisplay, PortalDisplayId},
ptl_render_ctx::PortalRenderCtx,
@ -181,9 +181,10 @@ async fn run_async(
}
};
let pw_con = match PwConHolder::new(&eng, &ring).await {
Ok(p) => p,
Ok(p) => Some(p),
Err(e) => {
fatal!("Could not connect to pipewire: {}", ErrorFmt(e));
log::error!("Could not connect to pipewire: {}", ErrorFmt(e));
None
}
};
let state = Rc::new(PortalState {
@ -191,7 +192,6 @@ async fn run_async(
ring,
eng,
wheel,
pw_con: pw_con.con.clone(),
displays: Default::default(),
dbus,
screencasts: Default::default(),
@ -199,15 +199,19 @@ async fn run_async(
render_ctxs: Default::default(),
dma_buf_ids: Default::default(),
});
if let Some(pw_con) = &pw_con {
pw_con.con.owner.set(Some(state.clone()));
}
let _root = {
let obj = state
.dbus
.add_object("/org/freedesktop/portal/desktop")
.unwrap();
add_screencast_dbus_members(&state, &obj);
if let Some(pw_con) = &pw_con {
add_screencast_dbus_members(&state, &pw_con.con, &obj);
}
obj
};
state.pw_con.owner.set(Some(state.clone()));
watch_displays(state.clone()).await;
}
@ -281,7 +285,6 @@ struct PortalState {
ring: Rc<IoUring>,
eng: Rc<AsyncEngine>,
wheel: Rc<Wheel>,
pw_con: Rc<PwCon>,
displays: CopyHashMap<PortalDisplayId, Rc<PortalDisplay>>,
dbus: Rc<DbusSocket>,
screencasts: CopyHashMap<String, Rc<ScreencastSession>>,

10
src/portal/ptl_display.rs
View file

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

15
src/portal/ptl_screencast.rs
View file

@ -4,6 +4,7 @@ use {
crate::{
dbus::{prelude::Variant, DbusObject, DictEntry, DynamicType, PendingReply},
pipewire::{
pw_con::PwCon,
pw_ifs::pw_client_node::{
PwClientNode, PwClientNodeBufferConfig, PwClientNodeOwner, PwClientNodePort,
PwClientNodePortSupportedFormats, SUPPORTED_META_VIDEO_CROP,
@ -56,6 +57,7 @@ shared_ids!(ScreencastSessionId);
pub struct ScreencastSession {
_id: ScreencastSessionId,
state: Rc<PortalState>,
pw_con: Rc<PwCon>,
pub app: String,
session_obj: DbusObject,
pub phase: CloneCell<ScreencastPhase>,
@ -234,7 +236,7 @@ impl PwClientNodeOwner for StartedScreencast {
impl SelectingScreencastCore {
pub fn starting(&self, dpy: &Rc<PortalDisplay>, target: ScreencastTarget) {
let node = dpy.state.pw_con.create_client_node(&[
let node = self.session.pw_con.create_client_node(&[
("media.class".to_string(), "Video/Source".to_string()),
("node.name".to_string(), "jay-desktop-portal".to_string()),
("node.driver".to_string(), "true".to_string()),
@ -462,11 +464,16 @@ impl UsrJayScreencastOwner for StartedScreencast {
}
}
pub(super) fn add_screencast_dbus_members(state_: &Rc<PortalState>, object: &DbusObject) {
pub(super) fn add_screencast_dbus_members(
state_: &Rc<PortalState>,
pw_con: &Rc<PwCon>,
object: &DbusObject,
) {
use org::freedesktop::impl_::portal::screen_cast::*;
let state = state_.clone();
let pw_con = pw_con.clone();
object.add_method::<CreateSession, _>(move |req, pr| {
dbus_create_session(&state, req, pr);
dbus_create_session(&state, &pw_con, req, pr);
});
let state = state_.clone();
object.add_method::<SelectSources, _>(move |req, pr| {
@ -483,6 +490,7 @@ pub(super) fn add_screencast_dbus_members(state_: &Rc<PortalState>, object: &Dbu
fn dbus_create_session(
state: &Rc<PortalState>,
pw_con: &Rc<PwCon>,
req: CreateSession,
reply: PendingReply<CreateSessionReply<'static>>,
) {
@ -501,6 +509,7 @@ fn dbus_create_session(
let session = Rc::new(ScreencastSession {
_id: state.id(),
state: state.clone(),
pw_con: pw_con.clone(),
app: req.app_id.to_string(),
session_obj: obj,
phase: CloneCell::new(ScreencastPhase::Init),

4
src/rect.rs
View file

@ -128,13 +128,13 @@ impl Rect {
if self.raw.x1 > x {
dx = self.raw.x1 - x;
} else if self.raw.x2 < x {
dx = x - self.raw.x1;
dx = x - self.raw.x2;
}
let mut dy = 0;
if self.raw.y1 > y {
dy = self.raw.y1 - y;
} else if self.raw.y2 < y {
dy = y - self.raw.y1;
dy = y - self.raw.y2;
}
dx * dx + dy * dy
}

20
src/wl_usr.rs
View file

@ -6,7 +6,7 @@ use {
async_engine::{AsyncEngine, SpawnedFuture},
client::{EventFormatter, RequestParser, MIN_SERVER_ID},
io_uring::{IoUring, IoUringError},
object::{ObjectId, WL_DISPLAY_ID},
object::{Interface, ObjectId, Version, WL_DISPLAY_ID},
utils::{
asyncevent::AsyncEvent,
bitfield::Bitfield,
@ -29,12 +29,13 @@ use {
usr_wl_callback::UsrWlCallback, usr_wl_display::UsrWlDisplay,
usr_wl_registry::UsrWlRegistry,
},
usr_object::{UsrObject, UsrObjectError},
usr_object::UsrObject,
},
},
std::{
cell::{Cell, RefCell},
collections::VecDeque,
error::Error,
mem,
rc::Rc,
},
@ -60,10 +61,17 @@ pub enum UsrConError {
Read(#[source] BufFdError),
#[error("Could not write to the compositor")]
Write(#[source] BufFdError),
#[error(transparent)]
UsrObjectError(#[from] UsrObjectError),
#[error("Server sent an event for object {0} that does not exist")]
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 {
@ -133,6 +141,7 @@ impl UsrCon {
Some(Rc::new(UsrWlDisplay {
id: WL_DISPLAY_ID,
con: slf.clone(),
version: Version(1),
})),
);
slf.incoming.set(Some(
@ -198,6 +207,7 @@ impl UsrCon {
id: self.id(),
con: self.clone(),
owner: Default::default(),
version: Version(1),
});
self.request(wl_display::GetRegistry {
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) = obj {
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 {
return Err(UsrConError::MissingObject(obj_id));

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

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

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

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

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

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

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

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

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

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

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

@ -1,29 +1,28 @@
use {
crate::{
utils::{
buffd::{MsgParser, MsgParserError},
clonecell::CloneCell,
},
object::Version,
utils::clonecell::CloneCell,
wire::{jay_select_toplevel::*, JaySelectToplevelId},
wl_usr::{usr_ifs::usr_jay_toplevel::UsrJayToplevel, usr_object::UsrObject, UsrCon},
},
std::rc::Rc,
thiserror::Error,
std::{convert::Infallible, rc::Rc},
};
pub struct UsrJaySelectToplevel {
pub id: JaySelectToplevelId,
pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrJaySelectToplevelOwner>>>,
pub version: Version,
}
pub trait UsrJaySelectToplevelOwner {
fn done(&self, toplevel: Option<Rc<UsrJayToplevel>>);
}
impl UsrJaySelectToplevel {
fn done(&self, parser: MsgParser<'_, '_>) -> Result<(), UsrJaySelectToplevelError> {
let ev: Done = self.con.parse(self, parser)?;
impl JaySelectToplevelEventHandler for UsrJaySelectToplevel {
type Error = Infallible;
fn done(&self, ev: Done, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let tl = if ev.id.is_none() {
None
} else {
@ -31,6 +30,7 @@ impl UsrJaySelectToplevel {
id: ev.id,
con: self.con.clone(),
owner: Default::default(),
version: self.version,
});
self.con.add_object(tl.clone());
Some(tl)
@ -49,9 +49,8 @@ impl UsrJaySelectToplevel {
}
usr_object_base! {
UsrJaySelectToplevel, JaySelectToplevel;
DONE => done,
self = UsrJaySelectToplevel = JaySelectToplevel;
version = self.version;
}
impl UsrObject for UsrJaySelectToplevel {
@ -63,9 +62,3 @@ impl UsrObject for UsrJaySelectToplevel {
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 {
crate::{
utils::{
buffd::{MsgParser, MsgParserError},
clonecell::CloneCell,
},
object::Version,
utils::clonecell::CloneCell,
wire::{jay_select_workspace::*, JaySelectWorkspaceId},
wl_usr::{usr_ifs::usr_jay_workspace::UsrJayWorkspace, usr_object::UsrObject, UsrCon},
},
std::rc::Rc,
thiserror::Error,
std::{convert::Infallible, rc::Rc},
};
pub struct UsrJaySelectWorkspace {
pub id: JaySelectWorkspaceId,
pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrJaySelectWorkspaceOwner>>>,
pub version: Version,
}
pub trait UsrJaySelectWorkspaceOwner {
fn done(&self, output: u32, ws: Option<Rc<UsrJayWorkspace>>);
}
impl UsrJaySelectWorkspace {
fn cancelled(&self, parser: MsgParser<'_, '_>) -> Result<(), UsrJaySelectWorkspaceError> {
let _ev: Cancelled = self.con.parse(self, parser)?;
impl JaySelectWorkspaceEventHandler for UsrJaySelectWorkspace {
type Error = Infallible;
fn cancelled(&self, _ev: Cancelled, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(owner) = self.owner.get() {
owner.done(0, None);
}
@ -31,12 +30,12 @@ impl UsrJaySelectWorkspace {
Ok(())
}
fn selected(&self, parser: MsgParser<'_, '_>) -> Result<(), UsrJaySelectWorkspaceError> {
let ev: Selected = self.con.parse(self, parser)?;
fn selected(&self, ev: Selected, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let tl = Rc::new(UsrJayWorkspace {
id: ev.id,
con: self.con.clone(),
owner: Default::default(),
version: self.version,
});
self.con.add_object(tl.clone());
match self.owner.get() {
@ -49,10 +48,8 @@ impl UsrJaySelectWorkspace {
}
usr_object_base! {
UsrJaySelectWorkspace, JaySelectWorkspace;
CANCELLED => cancelled,
SELECTED => selected,
self = UsrJaySelectWorkspace = JaySelectWorkspace;
version = self.version;
}
impl UsrObject for UsrJaySelectWorkspace {
@ -64,9 +61,3 @@ impl UsrObject for UsrJaySelectWorkspace {
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 {
crate::{
utils::{
buffd::{MsgParser, MsgParserError},
clonecell::CloneCell,
},
object::Version,
utils::clonecell::CloneCell,
wire::{jay_toplevel::*, JayToplevelId},
wl_usr::{usr_object::UsrObject, UsrCon},
},
std::rc::Rc,
std::{convert::Infallible, rc::Rc},
};
pub struct UsrJayToplevel {
pub id: JayToplevelId,
pub con: Rc<UsrCon>,
pub owner: CloneCell<Option<Rc<dyn UsrJayToplevelOwner>>>,
pub version: Version,
}
pub trait UsrJayToplevelOwner {
fn destroyed(&self) {}
}
impl UsrJayToplevel {
fn destroyed(&self, parser: MsgParser<'_, '_>) -> Result<(), MsgParserError> {
let _ev: Destroyed = self.con.parse(self, parser)?;
impl JayToplevelEventHandler for UsrJayToplevel {
type Error = Infallible;
fn destroyed(&self, _ev: Destroyed, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if let Some(owner) = self.owner.get() {
owner.destroyed();
}
@ -31,9 +31,8 @@ impl UsrJayToplevel {
}
usr_object_base! {
UsrJayToplevel, JayToplevel;
DESTROYED => destroyed,
self = UsrJayToplevel = JayToplevel;
version = self.version;
}
impl UsrObject for UsrJayToplevel {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

28
src/wl_usr/usr_object.rs
View file

@ -1,40 +1,22 @@
use {
crate::{
object::{Interface, ObjectId},
object::{Interface, ObjectId, Version},
utils::buffd::MsgParser,
wl_usr::{UsrCon, UsrConError},
},
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 {
fn id(&self) -> ObjectId;
fn handle_event(
self: Rc<Self>,
con: &UsrCon,
event: u32,
parser: MsgParser<'_, '_>,
) -> Result<(), UsrObjectError>;
) -> Result<(), UsrConError>;
fn interface(&self) -> Interface;
fn version(&self) -> Version;
}
pub trait UsrObject: UsrObjectBase + 'static {

4
wire/wl_data_offer.txt
View file

@ -27,10 +27,10 @@ event offer {
mime_type: str,
}
event source_actions {
event source_actions (since = 3) {
source_actions: u32,
}
event action {
event action (since = 3) {
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,
}

2
wire/wl_keyboard.txt
View file

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

8
wire/wl_output.txt
View file

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

12
wire/wl_pointer.txt
View file

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

2
wire/wl_seat.txt
View file

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

4
wire/wl_surface.txt
View file

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

4
wire/wl_touch.txt
View file

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

2
wire/xdg_popup.txt
View file

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

4
wire/xdg_toplevel.txt
View file

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

2
wire/zwp_linux_dmabuf_v1.txt
View file

@ -21,7 +21,7 @@ event format {
format: u32,
}
event modifier {
event modifier (since = 3) {
format: u32,
modifier_hi: 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,
time: u32,
surface: id(wl_surface),
fingers: u32,
}
event end {
event end (since = 3) {
serial: u32,
time: u32,
cancelled: i32,

4
wire/zxdg_output_v1.txt
View file

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