autocommit 2022-01-03 18:56:52 CET

src/ifs/wl_surface/xdg_surface/xdg_toplevel/mod.rs

@@ -0,0 +1,178 @@
+mod types;
+
+use crate::ifs::wl_surface::xdg_surface::XdgSurface;
+use crate::object::{Interface, Object, ObjectId};
+use crate::utils::buffd::MsgParser;
+use num_derive::FromPrimitive;
+use std::rc::Rc;
+pub use types::*;
+
+const DESTROY: u32 = 0;
+const SET_PARENT: u32 = 1;
+const SET_TITLE: u32 = 2;
+const SET_APP_ID: u32 = 3;
+const SHOW_WINDOW_MENU: u32 = 4;
+const MOVE: u32 = 5;
+const RESIZE: u32 = 6;
+const SET_MAX_SIZE: u32 = 7;
+const SET_MIN_SIZE: u32 = 8;
+const SET_MAXIMIZED: u32 = 9;
+const UNSET_MAXIMIZED: u32 = 10;
+const SET_FULLSCREEN: u32 = 11;
+const UNSET_FULLSCREEN: u32 = 12;
+const SET_MINIMIZED: u32 = 13;
+
+const CONFIGURE: u32 = 0;
+const CLOSE: u32 = 1;
+
+#[derive(Copy, Clone, Debug, FromPrimitive)]
+pub enum ResizeEdge {
+    None = 0,
+    Top = 1,
+    Bottom = 2,
+    Left = 4,
+    TopLeft = 5,
+    BottomLeft = 6,
+    Right = 8,
+    TopRight = 9,
+    BottomRight = 10,
+}
+
+const STATE_MAXIMIZED: u32 = 1;
+const STATE_FULLSCREEN: u32 = 2;
+const STATE_RESIZING: u32 = 3;
+const STATE_ACTIVATED: u32 = 4;
+const STATE_TILED_LEFT: u32 = 5;
+const STATE_TILED_RIGHT: u32 = 6;
+const STATE_TILED_TOP: u32 = 7;
+const STATE_TILED_BOTTOM: u32 = 8;
+
+pub struct XdgToplevel {
+    id: ObjectId,
+    surface: Rc<XdgSurface>,
+    version: u32,
+}
+
+impl XdgToplevel {
+    pub fn new(id: ObjectId, surface: &Rc<XdgSurface>, version: u32) -> Self {
+        Self {
+            id,
+            surface: surface.clone(),
+            version,
+        }
+    }
+
+    async fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), DestroyError> {
+        let _req: Destroy = self.surface.surface.client.parse(self, parser)?;
+        Ok(())
+    }
+
+    async fn set_parent(&self, parser: MsgParser<'_, '_>) -> Result<(), SetParentError> {
+        let _req: SetParent = self.surface.surface.client.parse(self, parser)?;
+        Ok(())
+    }
+
+    async fn set_title(&self, parser: MsgParser<'_, '_>) -> Result<(), SetTitleError> {
+        let _req: SetTitle = self.surface.surface.client.parse(self, parser)?;
+        Ok(())
+    }
+
+    async fn set_app_id(&self, parser: MsgParser<'_, '_>) -> Result<(), SetAppIdError> {
+        let _req: SetAppId = self.surface.surface.client.parse(self, parser)?;
+        Ok(())
+    }
+
+    async fn show_window_menu(&self, parser: MsgParser<'_, '_>) -> Result<(), ShowWindowMenuError> {
+        let _req: ShowWindowMenu = self.surface.surface.client.parse(self, parser)?;
+        Ok(())
+    }
+
+    async fn move_(&self, parser: MsgParser<'_, '_>) -> Result<(), MoveError> {
+        let _req: Move = self.surface.surface.client.parse(self, parser)?;
+        Ok(())
+    }
+
+    async fn resize(&self, parser: MsgParser<'_, '_>) -> Result<(), ResizeError> {
+        let _req: Resize = self.surface.surface.client.parse(self, parser)?;
+        Ok(())
+    }
+
+    async fn set_max_size(&self, parser: MsgParser<'_, '_>) -> Result<(), SetMaxSizeError> {
+        let _req: SetMaxSize = self.surface.surface.client.parse(self, parser)?;
+        Ok(())
+    }
+
+    async fn set_min_size(&self, parser: MsgParser<'_, '_>) -> Result<(), SetMinSizeError> {
+        let _req: SetMinSize = self.surface.surface.client.parse(self, parser)?;
+        Ok(())
+    }
+
+    async fn set_maximized(&self, parser: MsgParser<'_, '_>) -> Result<(), SetMaximizedError> {
+        let _req: SetMaximized = self.surface.surface.client.parse(self, parser)?;
+        Ok(())
+    }
+
+    async fn unset_maximized(&self, parser: MsgParser<'_, '_>) -> Result<(), UnsetMaximizedError> {
+        let _req: UnsetMaximized = self.surface.surface.client.parse(self, parser)?;
+        Ok(())
+    }
+
+    async fn set_fullscreen(&self, parser: MsgParser<'_, '_>) -> Result<(), SetFullscreenError> {
+        let _req: SetFullscreen = self.surface.surface.client.parse(self, parser)?;
+        Ok(())
+    }
+
+    async fn unset_fullscreen(
+        &self,
+        parser: MsgParser<'_, '_>,
+    ) -> Result<(), UnsetFullscreenError> {
+        let _req: UnsetFullscreen = self.surface.surface.client.parse(self, parser)?;
+        Ok(())
+    }
+
+    async fn set_minimized(&self, parser: MsgParser<'_, '_>) -> Result<(), SetMinimizedError> {
+        let _req: SetMinimized = self.surface.surface.client.parse(self, parser)?;
+        Ok(())
+    }
+
+    async fn handle_request_(
+        &self,
+        request: u32,
+        parser: MsgParser<'_, '_>,
+    ) -> Result<(), XdgToplevelError> {
+        match request {
+            DESTROY => self.destroy(parser).await?,
+            SET_PARENT => self.set_parent(parser).await?,
+            SET_TITLE => self.set_title(parser).await?,
+            SET_APP_ID => self.set_app_id(parser).await?,
+            SHOW_WINDOW_MENU => self.show_window_menu(parser).await?,
+            MOVE => self.move_(parser).await?,
+            RESIZE => self.resize(parser).await?,
+            SET_MAX_SIZE => self.set_max_size(parser).await?,
+            SET_MIN_SIZE => self.set_min_size(parser).await?,
+            SET_MAXIMIZED => self.set_maximized(parser).await?,
+            UNSET_MAXIMIZED => self.unset_maximized(parser).await?,
+            SET_FULLSCREEN => self.set_fullscreen(parser).await?,
+            UNSET_FULLSCREEN => self.unset_fullscreen(parser).await?,
+            SET_MINIMIZED => self.set_minimized(parser).await?,
+            _ => unreachable!(),
+        }
+        Ok(())
+    }
+}
+
+handle_request!(XdgToplevel);
+
+impl Object for XdgToplevel {
+    fn id(&self) -> ObjectId {
+        self.id
+    }
+
+    fn interface(&self) -> Interface {
+        Interface::XdgToplevel
+    }
+
+    fn num_requests(&self) -> u32 {
+        SET_MINIMIZED + 1
+    }
+}

src/ifs/wl_surface/xdg_surface/xdg_toplevel/types.rs

@@ -0,0 +1,433 @@
+use super::CONFIGURE;
+use crate::client::{ClientError, EventFormatter, RequestParser};
+use crate::ifs::wl_surface::xdg_surface::xdg_toplevel::{XdgToplevel, CLOSE};
+use crate::object::{Object, ObjectId};
+use crate::utils::buffd::{MsgFormatter, MsgParser, MsgParserError};
+use std::fmt::{Debug, Formatter};
+use std::rc::Rc;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum XdgToplevelError {
+    #[error("Could not process `destroy` request")]
+    DestroyError(#[from] DestroyError),
+    #[error("Could not process `set_parent` request")]
+    SetParentError(#[from] SetParentError),
+    #[error("Could not process `set_title` request")]
+    SetTitleError(#[from] SetTitleError),
+    #[error("Could not process `set_app_id` request")]
+    SetAppIdError(#[from] SetAppIdError),
+    #[error("Could not process `show_window_menu` request")]
+    ShowWindowMenuError(#[from] ShowWindowMenuError),
+    #[error("Could not process `move` request")]
+    MoveError(#[from] MoveError),
+    #[error("Could not process `resize` request")]
+    ResizeError(#[from] ResizeError),
+    #[error("Could not process `set_max_size` request")]
+    SetMaxSizeError(#[from] SetMaxSizeError),
+    #[error("Could not process `set_min_size` request")]
+    SetMinSizeError(#[from] SetMinSizeError),
+    #[error("Could not process `set_maximized` request")]
+    SetMaximizedError(#[from] SetMaximizedError),
+    #[error("Could not process `unset_maximized` request")]
+    UnsetMaximizedError(#[from] UnsetMaximizedError),
+    #[error("Could not process `set_fullscreen` request")]
+    SetFullscreenError(#[from] SetFullscreenError),
+    #[error("Could not process `unset_fullscreen` request")]
+    UnsetFullscreenError(#[from] UnsetFullscreenError),
+    #[error("Could not process `set_minimized` request")]
+    SetMinimizedError(#[from] SetMinimizedError),
+}
+
+#[derive(Debug, Error)]
+pub enum DestroyError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(DestroyError, ParseFailed, MsgParserError);
+efrom!(DestroyError, ClientError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum SetParentError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(SetParentError, ParseFailed, MsgParserError);
+efrom!(SetParentError, ClientError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum SetTitleError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(SetTitleError, ParseFailed, MsgParserError);
+efrom!(SetTitleError, ClientError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum SetAppIdError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(SetAppIdError, ParseFailed, MsgParserError);
+efrom!(SetAppIdError, ClientError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum ShowWindowMenuError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(ShowWindowMenuError, ParseFailed, MsgParserError);
+efrom!(ShowWindowMenuError, ClientError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum MoveError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(MoveError, ParseFailed, MsgParserError);
+efrom!(MoveError, ClientError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum ResizeError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(ResizeError, ParseFailed, MsgParserError);
+efrom!(ResizeError, ClientError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum SetMaxSizeError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(SetMaxSizeError, ParseFailed, MsgParserError);
+efrom!(SetMaxSizeError, ClientError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum SetMinSizeError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(SetMinSizeError, ParseFailed, MsgParserError);
+efrom!(SetMinSizeError, ClientError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum SetMaximizedError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(SetMaximizedError, ParseFailed, MsgParserError);
+efrom!(SetMaximizedError, ClientError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum UnsetMaximizedError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(UnsetMaximizedError, ParseFailed, MsgParserError);
+efrom!(UnsetMaximizedError, ClientError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum SetFullscreenError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(SetFullscreenError, ParseFailed, MsgParserError);
+efrom!(SetFullscreenError, ClientError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum UnsetFullscreenError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(UnsetFullscreenError, ParseFailed, MsgParserError);
+efrom!(UnsetFullscreenError, ClientError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum SetMinimizedError {
+    #[error("Parsing failed")]
+    ParseFailed(#[source] Box<MsgParserError>),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(SetMinimizedError, ParseFailed, MsgParserError);
+efrom!(SetMinimizedError, ClientError, ClientError);
+
+pub(super) struct Destroy;
+impl RequestParser<'_> for Destroy {
+    fn parse(_parser: &mut MsgParser<'_, '_>) -> Result<Self, MsgParserError> {
+        Ok(Self)
+    }
+}
+impl Debug for Destroy {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "destroy()")
+    }
+}
+
+pub(super) struct SetParent {
+    pub parent: ObjectId,
+}
+impl RequestParser<'_> for SetParent {
+    fn parse(parser: &mut MsgParser<'_, '_>) -> Result<Self, MsgParserError> {
+        Ok(Self { parent: parser.object()? })
+    }
+}
+impl Debug for SetParent {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "set_parent(parent: {})", self.parent)
+    }
+}
+
+pub(super) struct SetTitle<'a> {
+    pub title: &'a str,
+}
+impl<'a> RequestParser<'a> for SetTitle<'a> {
+    fn parse(parser: &mut MsgParser<'_, 'a>) -> Result<Self, MsgParserError> {
+        Ok(Self { title: parser.string()? })
+    }
+}
+impl<'a> Debug for SetTitle<'a> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "set_title(title: {:?})", self.title)
+    }
+}
+
+pub(super) struct SetAppId<'a> {
+    pub app_id: &'a str,
+}
+impl<'a> RequestParser<'a> for SetAppId<'a> {
+    fn parse(parser: &mut MsgParser<'_, 'a>) -> Result<Self, MsgParserError> {
+        Ok(Self { app_id: parser.string()? })
+    }
+}
+impl<'a> Debug for SetAppId<'a> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "set_app_id(app_id: {:?})", self.app_id)
+    }
+}
+
+pub(super) struct ShowWindowMenu {
+    pub seat: ObjectId,
+    pub serial: u32,
+    pub x: i32,
+    pub y: i32,
+}
+impl RequestParser<'_> for ShowWindowMenu {
+    fn parse(parser: &mut MsgParser<'_, '_>) -> Result<Self, MsgParserError> {
+        Ok(Self {
+            seat: parser.object()?,
+            serial: parser.uint()?,
+            x: parser.int()?,
+            y: parser.int()?,
+        })
+    }
+}
+impl Debug for ShowWindowMenu {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "show_window_menu(seat: {}, serial: {}, x: {}, y: {})", self.seat, self.serial, self.x, self.y)
+    }
+}
+
+pub(super) struct Move {
+    pub seat: ObjectId,
+    pub serial: u32,
+}
+impl RequestParser<'_> for Move {
+    fn parse(parser: &mut MsgParser<'_, '_>) -> Result<Self, MsgParserError> {
+        Ok(Self { seat: parser.object()?, serial: parser.uint()? })
+    }
+}
+impl Debug for Move {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "move(seat: {}, serial: {})", self.seat, self.serial)
+    }
+}
+
+pub(super) struct Resize {
+    pub seat: ObjectId,
+    pub serial: u32,
+    pub edges: u32,
+}
+impl RequestParser<'_> for Resize {
+    fn parse(parser: &mut MsgParser<'_, '_>) -> Result<Self, MsgParserError> {
+        Ok(Self {
+            seat: parser.object()?,
+            serial: parser.uint()?,
+            edges: parser.uint()?,
+        })
+    }
+}
+impl Debug for Resize {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "resize(seat: {}, serial: {}, edges: {})", self.seat, self.serial, self.edges)
+    }
+}
+
+pub(super) struct SetMaxSize {
+    pub width: i32,
+    pub height: i32,
+}
+impl RequestParser<'_> for SetMaxSize {
+    fn parse(parser: &mut MsgParser<'_, '_>) -> Result<Self, MsgParserError> {
+        Ok(Self { width: parser.int()?, height: parser.int()? })
+    }
+}
+impl Debug for SetMaxSize {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "set_max_size(width: {}, height: {})", self.width, self.height)
+    }
+}
+
+pub(super) struct SetMinSize {
+    pub width: i32,
+    pub height: i32,
+}
+impl RequestParser<'_> for SetMinSize {
+    fn parse(parser: &mut MsgParser<'_, '_>) -> Result<Self, MsgParserError> {
+        Ok(Self { width: parser.int()?, height: parser.int()? })
+    }
+}
+impl Debug for SetMinSize {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "set_min_size(width: {}, height: {})", self.width, self.height)
+    }
+}
+
+pub(super) struct SetMaximized;
+impl RequestParser<'_> for SetMaximized {
+    fn parse(_parser: &mut MsgParser<'_, '_>) -> Result<Self, MsgParserError> {
+        Ok(Self)
+    }
+}
+impl Debug for SetMaximized {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "set_maximized()")
+    }
+}
+
+pub(super) struct UnsetMaximized;
+impl RequestParser<'_> for UnsetMaximized {
+    fn parse(_parser: &mut MsgParser<'_, '_>) -> Result<Self, MsgParserError> {
+        Ok(Self)
+    }
+}
+impl Debug for UnsetMaximized {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "unset_maximized()")
+    }
+}
+
+pub(super) struct SetFullscreen {
+    pub output: ObjectId,
+}
+impl RequestParser<'_> for SetFullscreen {
+    fn parse(parser: &mut MsgParser<'_, '_>) -> Result<Self, MsgParserError> {
+        Ok(Self { output: parser.object()? })
+    }
+}
+impl Debug for SetFullscreen {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "set_fullscreen(output: {})", self.output)
+    }
+}
+
+pub(super) struct UnsetFullscreen;
+impl RequestParser<'_> for UnsetFullscreen {
+    fn parse(_parser: &mut MsgParser<'_, '_>) -> Result<Self, MsgParserError> {
+        Ok(Self)
+    }
+}
+impl Debug for UnsetFullscreen {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "unset_fullscreen()")
+    }
+}
+
+pub(super) struct SetMinimized;
+impl RequestParser<'_> for SetMinimized {
+    fn parse(_parser: &mut MsgParser<'_, '_>) -> Result<Self, MsgParserError> {
+        Ok(Self)
+    }
+}
+impl Debug for SetMinimized {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "set_minimized()")
+    }
+}
+
+pub(super) struct Configure {
+    pub obj: Rc<XdgToplevel>,
+    pub width: i32,
+    pub height: i32,
+    pub states: Vec<u32>,
+}
+impl EventFormatter for Configure {
+    fn format(self: Box<Self>, fmt: &mut MsgFormatter<'_>) {
+        fmt.header(self.obj.id, CONFIGURE)
+            .int(self.width)
+            .int(self.height)
+            .array(|fmt| {
+                for &state in &self.states {
+                    fmt.uint(state);
+                }
+            });
+    }
+
+    fn obj(&self) -> &dyn Object {
+        &*self.obj
+    }
+}
+impl Debug for Configure {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "configure(width: {}, height: {}, states: {:?})",
+            self.width, self.height, self.states
+        )
+    }
+}
+
+pub(super) struct Close {
+    pub obj: Rc<XdgToplevel>,
+}
+impl EventFormatter for Close {
+    fn format(self: Box<Self>, fmt: &mut MsgFormatter<'_>) {
+        fmt.header(self.obj.id, CLOSE);
+    }
+
+    fn obj(&self) -> &dyn Object {
+        &*self.obj
+    }
+}
+impl Debug for Close {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "close()")
+    }
+}