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

wire: generate trait for request handling

Browse source
This commit is contained in:
Julian Orth 2024-04-08 17:37:35 +02:00
parent e3a1a0b30f
commit acb391335b
102 changed files with 1632 additions and 2086 deletions
Download patch file Download diff file Expand all files Collapse all files

29
src/ifs/wl_surface/xdg_surface/xdg_popup.rs
View file

@ -16,11 +16,7 @@ use {
rect::Rect,
renderer::Renderer,
tree::{FindTreeResult, FoundNode, Node, NodeId, NodeVisitor, StackedNode, WorkspaceNode},
utils::{
buffd::{MsgParser, MsgParserError},
clonecell::CloneCell,
linkedlist::LinkedNode,
},
utils::{clonecell::CloneCell, linkedlist::LinkedNode},
wire::{xdg_popup::*, XdgPopupId},
},
std::{
@ -205,9 +201,12 @@ impl XdgPopup {
.set_absolute_desired_extents(&rel.move_(parent.x1(), parent.y1()));
}
}
}
fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), XdgPopupError> {
let _req: Destroy = self.xdg.surface.client.parse(self, parser)?;
impl XdgPopupRequestHandler for XdgPopup {
type Error = XdgPopupError;
fn destroy(&self, _req: Destroy, _slf: &Rc<Self>) -> Result<(), Self::Error> {
self.destroy_node();
{
if let Some(parent) = self.parent.take() {
@ -221,13 +220,11 @@ impl XdgPopup {
Ok(())
}
fn grab(&self, parser: MsgParser<'_, '_>) -> Result<(), XdgPopupError> {
let _req: Grab = self.xdg.surface.client.parse(self, parser)?;
fn grab(&self, _req: Grab, _slf: &Rc<Self>) -> Result<(), Self::Error> {
Ok(())
}
fn reposition(self: &Rc<Self>, parser: MsgParser<'_, '_>) -> Result<(), XdgPopupError> {
let req: Reposition = self.xdg.surface.client.parse(&**self, parser)?;
fn reposition(&self, req: Reposition, _slf: &Rc<Self>) -> Result<(), Self::Error> {
*self.pos.borrow_mut() = self.xdg.surface.client.lookup(req.positioner)?.value();
if let Some(parent) = self.parent.get() {
self.update_position(&parent)?;
@ -238,7 +235,9 @@ impl XdgPopup {
}
Ok(())
}
}
impl XdgPopup {
fn get_parent_workspace(&self) -> Option<Rc<WorkspaceNode>> {
self.parent.get()?.workspace.get()
}
@ -276,10 +275,7 @@ impl XdgPopup {
object_base! {
self = XdgPopup;
DESTROY => destroy,
GRAB => grab,
REPOSITION => reposition if self.xdg.base.version >= 3,
version = self.xdg.base.version;
}
impl Object for XdgPopup {
@ -419,10 +415,7 @@ impl XdgSurfaceExt for XdgPopup {
pub enum XdgPopupError {
#[error("The `xdg_positioner` is incomplete")]
Incomplete,
#[error("Parsing failed")]
MsgParserError(#[source] Box<MsgParserError>),
#[error(transparent)]
ClientError(Box<ClientError>),
}
efrom!(XdgPopupError, MsgParserError);
efrom!(XdgPopupError, ClientError);

82
src/ifs/wl_surface/xdg_surface/xdg_toplevel.rs
View file

@ -23,10 +23,7 @@ use {
Direction, FindTreeResult, FoundNode, Node, NodeId, NodeVisitor, OutputNode,
ToplevelData, ToplevelNode, ToplevelNodeBase, ToplevelNodeId, WorkspaceNode,
},
utils::{
buffd::{MsgParser, MsgParserError},
clonecell::CloneCell,
},
utils::clonecell::CloneCell,
wire::{xdg_toplevel::*, XdgToplevelId},
},
ahash::{AHashMap, AHashSet},
@ -35,7 +32,6 @@ use {
cell::{Cell, RefCell},
fmt::{Debug, Formatter},
mem,
ops::Deref,
rc::Rc,
},
thiserror::Error,
@ -199,9 +195,12 @@ impl XdgToplevel {
capabilities: &[CAP_FULLSCREEN],
})
}
}
fn destroy(self: &Rc<Self>, parser: MsgParser<'_, '_>) -> Result<(), XdgToplevelError> {
let _req: Destroy = self.xdg.surface.client.parse(self.deref(), parser)?;
impl XdgToplevelRequestHandler for XdgToplevel {
type Error = XdgToplevelError;
fn destroy(&self, _req: Destroy, _slf: &Rc<Self>) -> Result<(), Self::Error> {
self.tl_destroy();
self.xdg.ext.set(None);
{
@ -223,13 +222,12 @@ impl XdgToplevel {
parent.children.borrow_mut().remove(&self.id);
}
}
self.xdg.surface.client.remove_obj(self.deref())?;
self.xdg.surface.client.remove_obj(self)?;
self.xdg.surface.set_toplevel(None);
Ok(())
}
fn set_parent(&self, parser: MsgParser<'_, '_>) -> Result<(), XdgToplevelError> {
let req: SetParent = self.xdg.surface.client.parse(self, parser)?;
fn set_parent(&self, req: SetParent, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let mut parent = None;
if req.parent.is_some() {
parent = Some(self.xdg.surface.client.lookup(req.parent)?);
@ -238,27 +236,23 @@ impl XdgToplevel {
Ok(())
}
fn set_title(&self, parser: MsgParser<'_, '_>) -> Result<(), XdgToplevelError> {
let req: SetTitle = self.xdg.surface.client.parse(self, parser)?;
fn set_title(&self, req: SetTitle, _slf: &Rc<Self>) -> Result<(), Self::Error> {
self.toplevel_data.set_title(req.title);
self.tl_title_changed();
Ok(())
}
fn set_app_id(&self, parser: MsgParser<'_, '_>) -> Result<(), XdgToplevelError> {
let req: SetAppId = self.xdg.surface.client.parse(self, parser)?;
fn set_app_id(&self, req: SetAppId, _slf: &Rc<Self>) -> Result<(), Self::Error> {
self.toplevel_data.set_app_id(req.app_id);
self.bugs.set(bugs::get(req.app_id));
Ok(())
}
fn show_window_menu(&self, parser: MsgParser<'_, '_>) -> Result<(), XdgToplevelError> {
let _req: ShowWindowMenu = self.xdg.surface.client.parse(self, parser)?;
fn show_window_menu(&self, _req: ShowWindowMenu, _slf: &Rc<Self>) -> Result<(), Self::Error> {
Ok(())
}
fn move_(&self, parser: MsgParser<'_, '_>) -> Result<(), XdgToplevelError> {
let req: Move = self.xdg.surface.client.parse(self, parser)?;
fn move_(&self, req: Move, _slf: &Rc<Self>) -> Result<(), Self::Error> {
let seat = self.xdg.surface.client.lookup(req.seat)?;
if let Some(parent) = self.toplevel_data.parent.get() {
if let Some(float) = parent.node_into_float() {
@ -268,13 +262,11 @@ impl XdgToplevel {
Ok(())
}
fn resize(&self, parser: MsgParser<'_, '_>) -> Result<(), XdgToplevelError> {
let _req: Resize = self.xdg.surface.client.parse(self, parser)?;
fn resize(&self, _req: Resize, _slf: &Rc<Self>) -> Result<(), Self::Error> {
Ok(())
}
fn set_max_size(&self, parser: MsgParser<'_, '_>) -> Result<(), XdgToplevelError> {
let req: SetMaxSize = self.xdg.surface.client.parse(self, parser)?;
fn set_max_size(&self, req: SetMaxSize, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if req.height < 0 || req.width < 0 {
return Err(XdgToplevelError::NonNegative);
}
@ -291,8 +283,7 @@ impl XdgToplevel {
Ok(())
}
fn set_min_size(&self, parser: MsgParser<'_, '_>) -> Result<(), XdgToplevelError> {
let req: SetMinSize = self.xdg.surface.client.parse(self, parser)?;
fn set_min_size(&self, req: SetMinSize, _slf: &Rc<Self>) -> Result<(), Self::Error> {
if req.height < 0 || req.width < 0 {
return Err(XdgToplevelError::NonNegative);
}
@ -309,19 +300,16 @@ impl XdgToplevel {
Ok(())
}
fn set_maximized(&self, parser: MsgParser<'_, '_>) -> Result<(), XdgToplevelError> {
let _req: SetMaximized = self.xdg.surface.client.parse(self, parser)?;
fn set_maximized(&self, _req: SetMaximized, _slf: &Rc<Self>) -> Result<(), Self::Error> {
Ok(())
}
fn unset_maximized(&self, parser: MsgParser<'_, '_>) -> Result<(), XdgToplevelError> {
let _req: UnsetMaximized = self.xdg.surface.client.parse(self, parser)?;
fn unset_maximized(&self, _req: UnsetMaximized, _slf: &Rc<Self>) -> Result<(), Self::Error> {
Ok(())
}
fn set_fullscreen(self: &Rc<Self>, parser: MsgParser<'_, '_>) -> Result<(), XdgToplevelError> {
fn set_fullscreen(&self, req: SetFullscreen, slf: &Rc<Self>) -> Result<(), Self::Error> {
let client = &self.xdg.surface.client;
let req: SetFullscreen = client.parse(self.deref(), parser)?;
self.states.borrow_mut().insert(STATE_FULLSCREEN);
'set_fullscreen: {
let output = if req.output.is_some() {
@ -338,29 +326,26 @@ impl XdgToplevel {
break 'set_fullscreen;
};
self.toplevel_data
.set_fullscreen(&client.state, self.clone(), &output);
.set_fullscreen(&client.state, slf.clone(), &output);
}
self.send_current_configure();
Ok(())
}
fn unset_fullscreen(
self: &Rc<Self>,
parser: MsgParser<'_, '_>,
) -> Result<(), XdgToplevelError> {
let _req: UnsetFullscreen = self.xdg.surface.client.parse(self.deref(), parser)?;
fn unset_fullscreen(&self, _req: UnsetFullscreen, slf: &Rc<Self>) -> Result<(), Self::Error> {
self.states.borrow_mut().remove(&STATE_FULLSCREEN);
self.toplevel_data
.unset_fullscreen(&self.state, self.clone());
.unset_fullscreen(&self.state, slf.clone());
self.send_current_configure();
Ok(())
}
fn set_minimized(&self, parser: MsgParser<'_, '_>) -> Result<(), XdgToplevelError> {
let _req: SetMinimized = self.xdg.surface.client.parse(self, parser)?;
fn set_minimized(&self, _req: SetMinimized, _slf: &Rc<Self>) -> Result<(), Self::Error> {
Ok(())
}
}
impl XdgToplevel {
fn map_floating(self: &Rc<Self>, workspace: &Rc<WorkspaceNode>, abs_pos: Option<(i32, i32)>) {
let (width, height) = self.toplevel_data.float_size(workspace);
self.state
@ -461,21 +446,7 @@ impl XdgToplevel {
object_base! {
self = XdgToplevel;
DESTROY => destroy,
SET_PARENT => set_parent,
SET_TITLE => set_title,
SET_APP_ID => set_app_id,
SHOW_WINDOW_MENU => show_window_menu,
MOVE => move_,
RESIZE => resize,
SET_MAX_SIZE => set_max_size,
SET_MIN_SIZE => set_min_size,
SET_MAXIMIZED => set_maximized,
UNSET_MAXIMIZED => unset_maximized,
SET_FULLSCREEN => set_fullscreen,
UNSET_FULLSCREEN => unset_fullscreen,
SET_MINIMIZED => set_minimized,
version = self.xdg.base.version;
}
impl Object for XdgToplevel {
@ -673,12 +644,9 @@ impl XdgSurfaceExt for XdgToplevel {
#[derive(Debug, Error)]
pub enum XdgToplevelError {
#[error("Parsing failed")]
MsgParserError(#[source] Box<MsgParserError>),
#[error(transparent)]
ClientError(Box<ClientError>),
#[error("width/height must be non-negative")]
NonNegative,
}
efrom!(XdgToplevelError, MsgParserError);
efrom!(XdgToplevelError, ClientError);