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

autocommit 2022-01-02 16:30:30 CET

Browse source
This commit is contained in:
Julian Orth 2022-01-02 16:30:30 +01:00
parent d6172b273f
commit c21f231ce7
34 changed files with 874 additions and 844 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/ifs/wl_callback/mod.rs
View file

@ -1,8 +1,8 @@
mod types;
use crate::objects::{Interface, Object, ObjectError, ObjectId};
use crate::client::{ClientError, DynEventFormatter};
use crate::object::{Interface, Object, ObjectId};
use crate::utils::buffd::WlParser;
use crate::wl_client::DynEventFormatter;
use std::rc::Rc;
use types::*;
@ -25,7 +25,7 @@ impl WlCallback {
&self,
_request: u32,
_parser: WlParser<'_, '_>,
) -> Result<(), ObjectError> {
) -> Result<(), ClientError> {
unreachable!();
}
}

4
src/ifs/wl_callback/types.rs
View file

@ -1,7 +1,7 @@
use crate::client::EventFormatter;
use crate::ifs::wl_callback::{WlCallback, DONE};
use crate::objects::Object;
use crate::object::Object;
use crate::utils::buffd::WlFormatter;
use crate::wl_client::EventFormatter;
use std::fmt::{Debug, Formatter};
use std::rc::Rc;

16
src/ifs/wl_compositor/mod.rs
View file

@ -1,13 +1,13 @@
mod types;
use crate::client::{AddObj, Client};
use crate::globals::{Global, GlobalName};
use crate::ifs::wl_region::WlRegion;
use crate::ifs::wl_surface::WlSurface;
use crate::objects::{Interface, Object, ObjectId};
use crate::object::{Interface, Object, ObjectId};
use crate::utils::buffd::WlParser;
use crate::wl_client::WlClientData;
use std::rc::Rc;
pub use types::*;
use crate::ifs::wl_region::WlRegion;
const CREATE_SURFACE: u32 = 0;
const CREATE_REGION: u32 = 1;
@ -19,7 +19,7 @@ pub struct WlCompositorGlobal {
pub struct WlCompositorObj {
global: Rc<WlCompositorGlobal>,
id: ObjectId,
client: Rc<WlClientData>,
client: Rc<Client>,
version: u32,
}
@ -31,7 +31,7 @@ impl WlCompositorGlobal {
async fn bind_(
self: Rc<Self>,
id: ObjectId,
client: &Rc<WlClientData>,
client: &Rc<Client>,
version: u32,
) -> Result<(), WlCompositorError> {
let obj = Rc::new(WlCompositorObj {
@ -40,7 +40,7 @@ impl WlCompositorGlobal {
client: client.clone(),
version,
});
client.attach_client_object(obj)?;
client.add_client_obj(&obj)?;
Ok(())
}
}
@ -49,14 +49,14 @@ impl WlCompositorObj {
async fn create_surface(&self, parser: WlParser<'_, '_>) -> Result<(), CreateSurfaceError> {
let surface: CreateSurface = self.client.parse(self, parser)?;
let surface = Rc::new(WlSurface::new(surface.id, &self.client));
self.client.attach_client_object(surface)?;
self.client.add_client_obj(&surface)?;
Ok(())
}
async fn create_region(&self, parser: WlParser<'_, '_>) -> Result<(), CreateRegionError> {
let region: CreateRegion = self.client.parse(self, parser)?;
let region = Rc::new(WlRegion::new(region.id, &self.client));
self.client.attach_client_object(region)?;
self.client.add_client_obj(&region)?;
Ok(())
}

19
src/ifs/wl_compositor/types.rs
View file

@ -1,23 +1,20 @@
use crate::objects::{ObjectError, ObjectId};
use crate::client::{ClientError, RequestParser};
use crate::object::ObjectId;
use crate::utils::buffd::{WlParser, WlParserError};
use crate::wl_client::{RequestParser, WlClientError};
use std::fmt::{Debug, Formatter};
use thiserror::Error;
#[derive(Debug, Error)]
pub enum WlCompositorError {
#[error(transparent)]
ObjectError(Box<ObjectError>),
#[error(transparent)]
ClientError(Box<WlClientError>),
ClientError(Box<ClientError>),
#[error("Could not process `create_surface` request")]
CreateSurfaceError(#[source] Box<CreateSurfaceError>),
#[error("Could not process `create_region` request")]
CreateRegionError(#[source] Box<CreateRegionError>),
}
efrom!(WlCompositorError, ObjectError, ObjectError);
efrom!(WlCompositorError, ClientError, WlClientError);
efrom!(WlCompositorError, ClientError, ClientError);
efrom!(WlCompositorError, CreateSurfaceError, CreateSurfaceError);
efrom!(WlCompositorError, CreateRegionError, CreateRegionError);
@ -26,22 +23,22 @@ pub enum CreateSurfaceError {
#[error("Parsing failed")]
ParseFailed(#[source] Box<WlParserError>),
#[error(transparent)]
ClientError(Box<WlClientError>),
ClientError(Box<ClientError>),
}
efrom!(CreateSurfaceError, ParseFailed, WlParserError);
efrom!(CreateSurfaceError, ClientError, WlClientError);
efrom!(CreateSurfaceError, ClientError, ClientError);
#[derive(Debug, Error)]
pub enum CreateRegionError {
#[error("Parsing failed")]
ParseFailed(#[source] Box<WlParserError>),
#[error(transparent)]
ClientError(Box<WlClientError>),
ClientError(Box<ClientError>),
}
efrom!(CreateRegionError, ParseFailed, WlParserError);
efrom!(CreateRegionError, ClientError, WlClientError);
efrom!(CreateRegionError, ClientError, ClientError);
pub(super) struct CreateSurface {
pub id: ObjectId,

19
src/ifs/wl_display/mod.rs
View file

@ -1,10 +1,10 @@
mod types;
use crate::client::{AddObj, Client, ClientError, DynEventFormatter};
use crate::ifs::wl_callback::WlCallback;
use crate::ifs::wl_registry::WlRegistry;
use crate::objects::{Interface, Object, ObjectError, ObjectId, WL_DISPLAY_ID};
use crate::object::{Interface, Object, ObjectId, WL_DISPLAY_ID};
use crate::utils::buffd::WlParser;
use crate::wl_client::{DynEventFormatter, WlClientData};
use std::rc::Rc;
pub use types::*;
@ -20,11 +20,11 @@ const NO_MEMORY: u32 = 2;
const IMPLEMENTATION: u32 = 3;
pub struct WlDisplay {
client: Rc<WlClientData>,
client: Rc<Client>,
}
impl WlDisplay {
pub fn new(client: &Rc<WlClientData>) -> Self {
pub fn new(client: &Rc<Client>) -> Self {
Self {
client: client.clone(),
}
@ -46,19 +46,16 @@ impl WlDisplay {
async fn sync(&self, parser: WlParser<'_, '_>) -> Result<(), SyncError> {
let sync: Sync = self.client.parse(self, parser)?;
let cb = Rc::new(WlCallback::new(sync.callback));
self.client.attach_client_object(cb.clone())?;
self.client.add_client_obj(&cb)?;
self.client.event(cb.done()).await?;
self.client
.objects
.remove_obj(&self.client, cb.id())
.await?;
self.client.remove_obj(&*cb).await?;
Ok(())
}
async fn get_registry(&self, parser: WlParser<'_, '_>) -> Result<(), GetRegistryError> {
let gr: GetRegistry = self.client.parse(self, parser)?;
let registry = Rc::new(WlRegistry::new(gr.registry, &self.client));
self.client.attach_client_object(registry.clone())?;
self.client.add_client_obj(&registry)?;
self.client
.state
.globals
@ -124,7 +121,7 @@ impl Object for WlDisplay {
GET_REGISTRY + 1
}
fn into_display(self: Rc<Self>) -> Result<Rc<WlDisplay>, ObjectError> {
fn into_display(self: Rc<Self>) -> Result<Rc<WlDisplay>, ClientError> {
Ok(self)
}
}

22
src/ifs/wl_display/types.rs
View file

@ -1,8 +1,8 @@
use crate::client::{ClientError, EventFormatter, RequestParser};
use crate::globals::GlobalError;
use crate::ifs::wl_display::{WlDisplay, DELETE_ID, ERROR};
use crate::objects::{Object, ObjectError, ObjectId, WL_DISPLAY_ID};
use crate::object::{Object, ObjectId, WL_DISPLAY_ID};
use crate::utils::buffd::{WlFormatter, WlParser, WlParserError};
use crate::wl_client::{EventFormatter, RequestParser, WlClientError};
use std::fmt::{Debug, Formatter};
use std::rc::Rc;
use thiserror::Error;
@ -22,32 +22,26 @@ efrom!(WlDisplayError, SyncError, SyncError);
pub enum GetRegistryError {
#[error("Parsing failed")]
ParseFailed(#[source] Box<WlParserError>),
#[error("An object error occurred")]
ObjectError(#[source] Box<ObjectError>),
#[error("An object error occurred")]
ClientError(#[source] Box<WlClientError>),
#[error(transparent)]
ClientError(Box<ClientError>),
#[error("An error occurred while processing globals")]
GlobalError(#[source] Box<GlobalError>),
}
efrom!(GetRegistryError, ParseFailed, WlParserError);
efrom!(GetRegistryError, ObjectError, ObjectError);
efrom!(GetRegistryError, GlobalError, GlobalError);
efrom!(GetRegistryError, ClientError, WlClientError);
efrom!(GetRegistryError, ClientError, ClientError);
#[derive(Debug, Error)]
pub enum SyncError {
#[error("Parsing failed")]
ParseFailed(#[source] Box<WlParserError>),
#[error("An object error occurred")]
ObjectError(#[source] Box<ObjectError>),
#[error("A client error occurred")]
ClientError(#[source] Box<WlClientError>),
#[error(transparent)]
ClientError(Box<ClientError>),
}
efrom!(SyncError, ParseFailed, WlParserError);
efrom!(SyncError, ObjectError, ObjectError);
efrom!(SyncError, ClientError, WlClientError);
efrom!(SyncError, ClientError, ClientError);
pub(super) struct GetRegistry {
pub registry: ObjectId,

22
src/ifs/wl_region/mod.rs
View file

@ -1,13 +1,12 @@
mod types;
use crate::objects::{Interface, Object, ObjectError, ObjectId};
use crate::client::{AddObj, Client};
use crate::object::{Interface, Object, ObjectId};
use crate::pixman::Region;
use crate::utils::buffd::{WlParser, WlParserError};
use crate::wl_client::{RequestParser, WlClientData};
use crate::utils::buffd::WlParser;
use std::cell::RefCell;
use std::rc::Rc;
pub use types::*;
use crate::ifs::wl_display::WlDisplay;
const DESTROY: u32 = 0;
const ADD: u32 = 1;
@ -15,12 +14,12 @@ const SUBTRACT: u32 = 2;
pub struct WlRegion {
id: ObjectId,
client: Rc<WlClientData>,
client: Rc<Client>,
rect: RefCell<Region>,
}
impl WlRegion {
pub fn new(id: ObjectId, client: &Rc<WlClientData>) -> Self {
pub fn new(id: ObjectId, client: &Rc<Client>) -> Self {
Self {
id,
client: client.clone(),
@ -34,7 +33,7 @@ impl WlRegion {
async fn destroy(&self, parser: WlParser<'_, '_>) -> Result<(), DestroyError> {
let _destroy: Destroy = self.client.parse(self, parser)?;
self.client.objects.remove_obj(&self.client, self.id).await?;
self.client.remove_obj(self).await?;
Ok(())
}
@ -92,13 +91,4 @@ impl Object for WlRegion {
fn num_requests(&self) -> u32 {
SUBTRACT + 1
}
fn post_attach(self: Rc<Self>) {
self.client.objects.regions.set(self.id, self.clone());
}
fn pre_release(&self) -> Result<(), ObjectError> {
self.client.objects.regions.remove(&self.id);
Ok(())
}
}

7
src/ifs/wl_region/types.rs
View file

@ -1,6 +1,5 @@
use crate::objects::{ObjectError, ObjectId};
use crate::client::{ClientError, RequestParser};
use crate::utils::buffd::{WlParser, WlParserError};
use crate::wl_client::RequestParser;
use std::fmt::{Debug, Formatter};
use thiserror::Error;
@ -19,10 +18,10 @@ pub enum DestroyError {
#[error("Parsing failed")]
ParseFailed(#[source] Box<WlParserError>),
#[error(transparent)]
ObjectError(Box<ObjectError>),
ClientError(Box<ClientError>),
}
efrom!(DestroyError, ParseFailed, WlParserError);
efrom!(DestroyError, ObjectError, ObjectError);
efrom!(DestroyError, ClientError, ClientError);
#[derive(Debug, Error)]
pub enum AddError {

8
src/ifs/wl_registry/mod.rs
View file

@ -1,9 +1,9 @@
mod types;
use crate::client::{Client, DynEventFormatter};
use crate::globals::{Global, GlobalName};
use crate::objects::{Interface, Object, ObjectId};
use crate::object::{Interface, Object, ObjectId};
use crate::utils::buffd::WlParser;
use crate::wl_client::{DynEventFormatter, WlClientData};
use std::rc::Rc;
pub use types::*;
@ -14,11 +14,11 @@ const GLOBAL_REMOVE: u32 = 1;
pub struct WlRegistry {
id: ObjectId,
client: Rc<WlClientData>,
client: Rc<Client>,
}
impl WlRegistry {
pub fn new(id: ObjectId, client: &Rc<WlClientData>) -> Self {
pub fn new(id: ObjectId, client: &Rc<Client>) -> Self {
Self {
id,
client: client.clone(),

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

@ -1,8 +1,8 @@
use crate::client::{EventFormatter, RequestParser};
use crate::globals::{Global, GlobalError, GlobalName};
use crate::ifs::wl_registry::{WlRegistry, GLOBAL, GLOBAL_REMOVE};
use crate::objects::{Interface, Object, ObjectId};
use crate::object::{Interface, Object, ObjectId};
use crate::utils::buffd::{WlFormatter, WlParser, WlParserError};
use crate::wl_client::{EventFormatter, RequestParser};
use std::fmt::{Debug, Formatter};
use std::rc::Rc;
use thiserror::Error;

12
src/ifs/wl_shm/mod.rs
View file

@ -1,10 +1,10 @@
mod types;
use crate::client::{AddObj, Client};
use crate::globals::{Global, GlobalName};
use crate::ifs::wl_shm_pool::WlShmPool;
use crate::objects::{Interface, Object, ObjectId};
use crate::object::{Interface, Object, ObjectId};
use crate::utils::buffd::WlParser;
use crate::wl_client::WlClientData;
use std::rc::Rc;
pub use types::*;
@ -19,7 +19,7 @@ pub struct WlShmGlobal {
pub struct WlShmObj {
global: Rc<WlShmGlobal>,
id: ObjectId,
client: Rc<WlClientData>,
client: Rc<Client>,
}
impl WlShmGlobal {
@ -30,7 +30,7 @@ impl WlShmGlobal {
async fn bind_(
self: Rc<Self>,
id: ObjectId,
client: &Rc<WlClientData>,
client: &Rc<Client>,
_version: u32,
) -> Result<(), WlShmError> {
let obj = Rc::new(WlShmObj {
@ -38,7 +38,7 @@ impl WlShmGlobal {
id,
client: client.clone(),
});
client.attach_client_object(obj.clone())?;
client.add_client_obj(&obj)?;
for &format in Format::formats() {
client
.event(Box::new(FormatE {
@ -63,7 +63,7 @@ impl WlShmObj {
create.fd,
create.size as usize,
)?);
self.client.attach_client_object(pool)?;
self.client.add_client_obj(&pool)?;
Ok(())
}

15
src/ifs/wl_shm/types.rs
View file

@ -1,8 +1,8 @@
use crate::client::{ClientError, EventFormatter, RequestParser};
use crate::ifs::wl_shm::{Format, WlShmObj, FORMAT};
use crate::ifs::wl_shm_pool::WlShmPoolError;
use crate::objects::{Object, ObjectError, ObjectId};
use crate::object::{Object, ObjectId};
use crate::utils::buffd::{WlFormatter, WlParser, WlParserError};
use crate::wl_client::{EventFormatter, RequestParser, WlClientError};
use std::fmt::{Debug, Formatter};
use std::rc::Rc;
use thiserror::Error;
@ -11,14 +11,11 @@ use uapi::OwnedFd;
#[derive(Debug, Error)]
pub enum WlShmError {
#[error(transparent)]
ObjectError(Box<ObjectError>),
#[error(transparent)]
ClientError(Box<WlClientError>),
ClientError(Box<ClientError>),
#[error("Could not process a `create_pool` request")]
CreatePoolError(#[from] CreatePoolError),
}
efrom!(WlShmError, ObjectError, ObjectError);
efrom!(WlShmError, ClientError, WlClientError);
efrom!(WlShmError, ClientError, ClientError);
#[derive(Debug, Error)]
pub enum CreatePoolError {
@ -29,11 +26,11 @@ pub enum CreatePoolError {
#[error(transparent)]
WlShmPoolError(Box<WlShmPoolError>),
#[error(transparent)]
ClientError(Box<WlClientError>),
ClientError(Box<ClientError>),
}
efrom!(CreatePoolError, ParseError, WlParserError);
efrom!(CreatePoolError, WlShmPoolError, WlShmPoolError);
efrom!(CreatePoolError, ClientError, WlClientError);
efrom!(CreatePoolError, ClientError, ClientError);
pub(super) struct CreatePool {
pub id: ObjectId,

13
src/ifs/wl_shm_pool/mod.rs
View file

@ -1,9 +1,9 @@
mod types;
use crate::client::{AddObj, Client};
use crate::clientmem::ClientMem;
use crate::objects::{Interface, Object, ObjectId};
use crate::object::{Interface, Object, ObjectId};
use crate::utils::buffd::WlParser;
use crate::wl_client::WlClientData;
use std::cell::RefCell;
use std::rc::Rc;
pub use types::*;
@ -15,7 +15,7 @@ const RESIZE: u32 = 2;
pub struct WlShmPool {
id: ObjectId,
client: Rc<WlClientData>,
client: Rc<Client>,
fd: OwnedFd,
mem: RefCell<Rc<ClientMem>>,
}
@ -23,7 +23,7 @@ pub struct WlShmPool {
impl WlShmPool {
pub fn new(
id: ObjectId,
client: &Rc<WlClientData>,
client: &Rc<Client>,
fd: OwnedFd,
len: usize,
) -> Result<Self, WlShmPoolError> {
@ -42,10 +42,7 @@ impl WlShmPool {
async fn destroy(&self, parser: WlParser<'_, '_>) -> Result<(), DestroyError> {
let _destroy: Destroy = self.client.parse(self, parser)?;
self.client
.objects
.remove_obj(&self.client, self.id)
.await?;
self.client.remove_obj(self).await?;
Ok(())
}

19
src/ifs/wl_shm_pool/types.rs
View file

@ -1,16 +1,14 @@
use crate::client::{ClientError, RequestParser};
use crate::clientmem::ClientMemError;
use crate::objects::{ObjectError, ObjectId};
use crate::object::ObjectId;
use crate::utils::buffd::{WlParser, WlParserError};
use crate::wl_client::{RequestParser, WlClientError};
use std::fmt::{Debug, Formatter};
use thiserror::Error;
#[derive(Debug, Error)]
pub enum WlShmPoolError {
#[error(transparent)]
ObjectError(Box<ObjectError>),
#[error(transparent)]
ClientError(Box<WlClientError>),
ClientError(Box<ClientError>),
#[error("Could not process a `create_buffer` request")]
CreateBufferError(#[from] CreateBufferError),
#[error("Could not process a `destroy` request")]
@ -20,8 +18,7 @@ pub enum WlShmPoolError {
#[error(transparent)]
ClientMemError(Box<ClientMemError>),
}
efrom!(WlShmPoolError, ObjectError, ObjectError);
efrom!(WlShmPoolError, ClientError, WlClientError);
efrom!(WlShmPoolError, ClientError, ClientError);
efrom!(WlShmPoolError, ClientMemError, ClientMemError);
#[derive(Debug, Error)]
@ -29,20 +26,20 @@ pub enum CreateBufferError {
#[error("Parsing failed")]
ParseError(#[source] Box<WlParserError>),
#[error(transparent)]
ObjectError(Box<ObjectError>),
ClientError(Box<ClientError>),
}
efrom!(CreateBufferError, ParseError, WlParserError);
efrom!(CreateBufferError, ObjectError, ObjectError);
efrom!(CreateBufferError, ClientError, ClientError);
#[derive(Debug, Error)]
pub enum DestroyError {
#[error("Parsing failed")]
ParseError(#[source] Box<WlParserError>),
#[error(transparent)]
ObjectError(Box<ObjectError>),
ClientError(Box<ClientError>),
}
efrom!(DestroyError, ParseError, WlParserError);
efrom!(DestroyError, ObjectError, ObjectError);
efrom!(DestroyError, ClientError, ClientError);
#[derive(Debug, Error)]
pub enum ResizeError {

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

@ -1,9 +1,9 @@
mod types;
use crate::client::{AddObj, Client, ClientError};
use crate::globals::{Global, GlobalName};
use crate::objects::{Interface, Object, ObjectError, ObjectId};
use crate::object::{Interface, Object, ObjectId};
use crate::utils::buffd::WlParser;
use crate::wl_client::WlClientData;
use std::rc::Rc;
pub use types::*;
@ -24,11 +24,11 @@ impl WlSubcompositorGlobal {
async fn bind_(
self: Rc<Self>,
id: ObjectId,
client: &WlClientData,
client: &Client,
_version: u32,
) -> Result<(), WlSubcompositorError> {
let obj = Rc::new(WlSubcompositorObj { global: self, id });
client.attach_client_object(obj)?;
client.add_client_obj(&obj)?;
Ok(())
}
}
@ -38,7 +38,7 @@ impl WlSubcompositorObj {
&self,
request: u32,
parser: WlParser<'_, '_>,
) -> Result<(), ObjectError> {
) -> Result<(), ClientError> {
unreachable!();
}
}

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

@ -1,14 +1,10 @@
use crate::objects::ObjectError;
use crate::wl_client::WlClientError;
use crate::client::ClientError;
use thiserror::Error;
#[derive(Debug, Error)]
pub enum WlSubcompositorError {
#[error(transparent)]
ObjectError(Box<ObjectError>),
#[error(transparent)]
ClientError(Box<WlClientError>),
ClientError(Box<ClientError>),
}
efrom!(WlSubcompositorError, ObjectError, ObjectError);
efrom!(WlSubcompositorError, ClientError, WlClientError);
efrom!(WlSubcompositorError, ClientError, ClientError);

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

@ -1,12 +1,12 @@
mod types;
use std::cell::Cell;
use crate::objects::{Interface, Object, ObjectError, ObjectId};
use crate::client::{Client, RequestParser};
use crate::object::{Interface, Object, ObjectId};
use crate::pixman::Region;
use crate::utils::buffd::{WlParser, WlParserError};
use crate::wl_client::{RequestParser, WlClientData};
use std::cell::Cell;
use std::rc::Rc;
pub use types::*;
use crate::pixman::Region;
const DESTROY: u32 = 0;
const ATTACH: u32 = 1;
@ -28,7 +28,7 @@ const INVALID_SIZE: u32 = 2;
pub struct WlSurface {
id: ObjectId,
client: Rc<WlClientData>,
client: Rc<Client>,
pending: PendingState,
}
@ -39,7 +39,7 @@ struct PendingState {
}
impl WlSurface {
pub fn new(id: ObjectId, client: &Rc<WlClientData>) -> Self {
pub fn new(id: ObjectId, client: &Rc<Client>) -> Self {
Self {
id,
client: client.clone(),
@ -150,13 +150,4 @@ impl Object for WlSurface {
fn num_requests(&self) -> u32 {
DAMAGE_BUFFER + 1
}
fn pre_release(&self) -> Result<(), ObjectError> {
self.client.objects.surfaces.remove(&self.id);
Ok(())
}
fn post_attach(self: Rc<Self>) {
self.client.objects.surfaces.set(self.id, self.clone());
}
}

12
src/ifs/wl_surface/types.rs
View file

@ -1,6 +1,6 @@
use crate::objects::ObjectId;
use crate::client::{ClientError, RequestParser};
use crate::object::ObjectId;
use crate::utils::buffd::{WlParser, WlParserError};
use crate::wl_client::{RequestParser, WlClientError};
use std::fmt::{Debug, Formatter};
use thiserror::Error;
@ -75,20 +75,20 @@ pub enum SetOpaqueRegionError {
#[error("Parsing failed")]
ParseFailed(#[source] Box<WlParserError>),
#[error(transparent)]
ClientError(Box<WlClientError>),
ClientError(Box<ClientError>),
}
efrom!(SetOpaqueRegionError, ParseFailed, WlParserError);
efrom!(SetOpaqueRegionError, ClientError, WlClientError);
efrom!(SetOpaqueRegionError, ClientError, ClientError);
#[derive(Debug, Error)]
pub enum SetInputRegionError {
#[error("Parsing failed")]
ParseFailed(#[source] Box<WlParserError>),
#[error(transparent)]
ClientError(Box<WlClientError>),
ClientError(Box<ClientError>),
}
efrom!(SetInputRegionError, ParseFailed, WlParserError);
efrom!(SetInputRegionError, ClientError, WlClientError);
efrom!(SetInputRegionError, ClientError, ClientError);
#[derive(Debug, Error)]
pub enum CommitError {

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

@ -1,9 +1,9 @@
mod types;
use crate::client::{AddObj, Client, ClientError};
use crate::globals::{Global, GlobalName};
use crate::objects::{Interface, Object, ObjectError, ObjectId};
use crate::object::{Interface, Object, ObjectId};
use crate::utils::buffd::WlParser;
use crate::wl_client::WlClientData;
use std::rc::Rc;
pub use types::*;
@ -25,7 +25,7 @@ impl XdgWmBaseGlobal {
async fn bind_(
self: Rc<Self>,
id: ObjectId,
client: &WlClientData,
client: &Client,
version: u32,
) -> Result<(), XdgWmBaseError> {
let obj = Rc::new(XdgWmBaseObj {
@ -33,7 +33,7 @@ impl XdgWmBaseGlobal {
id,
version,
});
client.attach_client_object(obj)?;
client.add_client_obj(&obj)?;
Ok(())
}
}
@ -43,7 +43,7 @@ impl XdgWmBaseObj {
&self,
request: u32,
parser: WlParser<'_, '_>,
) -> Result<(), ObjectError> {
) -> Result<(), ClientError> {
unreachable!();
}
}

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

@ -1,14 +1,10 @@
use crate::objects::ObjectError;
use crate::wl_client::WlClientError;
use crate::client::ClientError;
use thiserror::Error;
#[derive(Debug, Error)]
pub enum XdgWmBaseError {
#[error(transparent)]
ObjectError(Box<ObjectError>),
#[error(transparent)]
ClientError(Box<WlClientError>),
ClientError(Box<ClientError>),
}
efrom!(XdgWmBaseError, ObjectError, ObjectError);
efrom!(XdgWmBaseError, ClientError, WlClientError);
efrom!(XdgWmBaseError, ClientError, ClientError);