autocommit 2022-02-04 16:52:11 CET

src/ifs/mod.rs

@@ -1,3 +1,5 @@
+pub mod org_kde_kwin_server_decoration;
+pub mod org_kde_kwin_server_decoration_manager;
 pub mod wl_buffer;
 pub mod wl_callback;
 pub mod wl_compositor;

src/ifs/org_kde_kwin_server_decoration/mod.rs

@@ -0,0 +1,93 @@
+use crate::client::{Client, DynEventFormatter};
+use crate::object::{Interface, Object, ObjectId};
+use crate::utils::buffd::MsgParser;
+use std::cell::Cell;
+use std::rc::Rc;
+pub use types::*;
+
+mod types;
+
+const RELEASE: u32 = 0;
+const REQUEST_MODE: u32 = 1;
+
+const MODE: u32 = 0;
+
+#[allow(dead_code)]
+const NONE: u32 = 0;
+#[allow(dead_code)]
+const CLIENT: u32 = 1;
+const SERVER: u32 = 2;
+
+id!(OrgKdeKwinServerDecorationId);
+
+pub struct OrgKdeKwinServerDecoration {
+    id: OrgKdeKwinServerDecorationId,
+    client: Rc<Client>,
+    requested: Cell<bool>,
+}
+
+impl OrgKdeKwinServerDecoration {
+    pub fn new(id: OrgKdeKwinServerDecorationId, client: &Rc<Client>) -> Self {
+        Self {
+            id,
+            client: client.clone(),
+            requested: Cell::new(false),
+        }
+    }
+
+    pub fn mode(self: &Rc<Self>, mode: u32) -> DynEventFormatter {
+        Box::new(Mode {
+            obj: self.clone(),
+            mode,
+        })
+    }
+
+    fn release(&self, parser: MsgParser<'_, '_>) -> Result<(), ReleaseError> {
+        let _req: Release = self.client.parse(self, parser)?;
+        self.client.remove_obj(self)?;
+        Ok(())
+    }
+
+    fn request_mode(self: &Rc<Self>, parser: MsgParser<'_, '_>) -> Result<(), RequestModeError> {
+        let req: RequestMode = self.client.parse(&**self, parser)?;
+        if req.mode > SERVER {
+            return Err(RequestModeError::InvalidMode(req.mode));
+        }
+        let mode = if self.requested.replace(true) {
+            req.mode
+        } else {
+            SERVER
+        };
+        self.client.event(self.mode(mode));
+        Ok(())
+    }
+
+    fn handle_request_(
+        self: &Rc<Self>,
+        request: u32,
+        parser: MsgParser<'_, '_>,
+    ) -> Result<(), OrgKdeKwinServerDecorationError> {
+        match request {
+            RELEASE => self.release(parser)?,
+            REQUEST_MODE => self.request_mode(parser)?,
+            _ => unreachable!(),
+        }
+        Ok(())
+    }
+}
+
+handle_request!(OrgKdeKwinServerDecoration);
+
+impl Object for OrgKdeKwinServerDecoration {
+    fn id(&self) -> ObjectId {
+        self.id.into()
+    }
+
+    fn interface(&self) -> Interface {
+        Interface::OrgKdeKwinServerDecoration
+    }
+
+    fn num_requests(&self) -> u32 {
+        REQUEST_MODE + 1
+    }
+}

src/ifs/org_kde_kwin_server_decoration/types.rs

@@ -0,0 +1,86 @@
+use crate::client::{ClientError, EventFormatter, RequestParser};
+use crate::ifs::org_kde_kwin_server_decoration::{OrgKdeKwinServerDecoration, MODE};
+use crate::object::Object;
+use crate::utils::buffd::{MsgFormatter, MsgParser, MsgParserError};
+use std::fmt::{Debug, Formatter};
+use std::rc::Rc;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum OrgKdeKwinServerDecorationError {
+    #[error("Could not process a `release` request")]
+    ReleaseError(#[from] ReleaseError),
+    #[error("Could not process a `request_mode` request")]
+    RequestModeError(#[from] RequestModeError),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(OrgKdeKwinServerDecorationError, ClientError);
+
+#[derive(Debug, Error)]
+pub enum ReleaseError {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+    #[error("Parsing failed")]
+    ParseError(#[source] Box<MsgParserError>),
+}
+efrom!(ReleaseError, ClientError);
+efrom!(ReleaseError, ParseError, MsgParserError);
+
+#[derive(Debug, Error)]
+pub enum RequestModeError {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+    #[error("Parsing failed")]
+    ParseError(#[source] Box<MsgParserError>),
+    #[error("Mode {0} does not exist")]
+    InvalidMode(u32),
+}
+efrom!(RequestModeError, ClientError);
+efrom!(RequestModeError, ParseError, MsgParserError);
+
+pub(super) struct Release;
+impl RequestParser<'_> for Release {
+    fn parse(_parser: &mut MsgParser<'_, '_>) -> Result<Self, MsgParserError> {
+        Ok(Self)
+    }
+}
+impl Debug for Release {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "release()")
+    }
+}
+
+pub(super) struct RequestMode {
+    pub mode: u32,
+}
+impl RequestParser<'_> for RequestMode {
+    fn parse(parser: &mut MsgParser<'_, '_>) -> Result<Self, MsgParserError> {
+        Ok(Self {
+            mode: parser.uint()?,
+        })
+    }
+}
+impl Debug for RequestMode {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "request_mode(mode: {})", self.mode)
+    }
+}
+
+pub(super) struct Mode {
+    pub obj: Rc<OrgKdeKwinServerDecoration>,
+    pub mode: u32,
+}
+impl EventFormatter for Mode {
+    fn format(self: Box<Self>, fmt: &mut MsgFormatter<'_>) {
+        fmt.header(self.obj.id, MODE).uint(self.mode);
+    }
+    fn obj(&self) -> &dyn Object {
+        &*self.obj
+    }
+}
+impl Debug for Mode {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "mode(mode: {})", self.mode)
+    }
+}

src/ifs/org_kde_kwin_server_decoration_manager/mod.rs

@@ -0,0 +1,119 @@
+use crate::client::{Client, DynEventFormatter};
+use crate::globals::{Global, GlobalName};
+use crate::ifs::org_kde_kwin_server_decoration::OrgKdeKwinServerDecoration;
+use crate::object::{Interface, Object, ObjectId};
+use crate::utils::buffd::MsgParser;
+use std::rc::Rc;
+pub use types::*;
+
+mod types;
+
+const CREATE: u32 = 0;
+
+const DEFAULT_MODE: u32 = 0;
+
+#[allow(dead_code)]
+const NONE: u32 = 0;
+#[allow(dead_code)]
+const CLIENT: u32 = 1;
+const SERVER: u32 = 2;
+
+id!(OrgKdeKwinServerDecorationManagerGlobalId);
+
+pub struct OrgKdeKwinServerDecorationManagerGlobal {
+    name: GlobalName,
+}
+impl OrgKdeKwinServerDecorationManagerGlobal {
+    pub fn new(name: GlobalName) -> Self {
+        Self { name }
+    }
+
+    fn bind_(
+        self: Rc<Self>,
+        id: OrgKdeKwinServerDecorationManagerGlobalId,
+        client: &Rc<Client>,
+        version: u32,
+    ) -> Result<(), OrgKdeKwinServerDecorationManagerError> {
+        let obj = Rc::new(OrgKdeKwinServerDecorationManagerObj {
+            id,
+            client: client.clone(),
+            _version: version,
+        });
+        client.add_client_obj(&obj)?;
+        client.event(obj.default_mode(SERVER));
+        Ok(())
+    }
+}
+
+bind!(OrgKdeKwinServerDecorationManagerGlobal);
+
+impl Global for OrgKdeKwinServerDecorationManagerGlobal {
+    fn name(&self) -> GlobalName {
+        self.name
+    }
+
+    fn singleton(&self) -> bool {
+        true
+    }
+
+    fn interface(&self) -> Interface {
+        Interface::OrgKdeKwinServerDecorationManager
+    }
+
+    fn version(&self) -> u32 {
+        1
+    }
+}
+
+pub struct OrgKdeKwinServerDecorationManagerObj {
+    id: OrgKdeKwinServerDecorationManagerGlobalId,
+    client: Rc<Client>,
+    _version: u32,
+}
+
+impl OrgKdeKwinServerDecorationManagerObj {
+    fn default_mode(self: &Rc<Self>, mode: u32) -> DynEventFormatter {
+        Box::new(DefaultMode {
+            obj: self.clone(),
+            mode,
+        })
+    }
+
+    fn create(&self, parser: MsgParser<'_, '_>) -> Result<(), CreateError> {
+        let req: Create = self.client.parse(self, parser)?;
+        let _ = self.client.get_surface(req.surface)?;
+        let obj = Rc::new(OrgKdeKwinServerDecoration::new(req.id, &self.client));
+        self.client.add_client_obj(&obj)?;
+        self.client.event(obj.mode(SERVER));
+        log::info!("ayo");
+        Ok(())
+    }
+
+    fn handle_request_(
+        self: &Rc<Self>,
+        request: u32,
+        parser: MsgParser<'_, '_>,
+    ) -> Result<(), OrgKdeKwinServerDecorationManagerError> {
+        match request {
+            CREATE => self.create(parser)?,
+            _ => unreachable!(),
+        }
+        Ok(())
+    }
+}
+
+handle_request!(OrgKdeKwinServerDecorationManagerObj);
+
+impl Object for OrgKdeKwinServerDecorationManagerObj {
+    fn id(&self) -> ObjectId {
+        self.id.into()
+    }
+
+    fn interface(&self) -> Interface {
+        Interface::OrgKdeKwinServerDecorationManager
+    }
+
+    fn num_requests(&self) -> u32 {
+        CREATE + 1
+    }
+}

src/ifs/org_kde_kwin_server_decoration_manager/types.rs

@@ -0,0 +1,70 @@
+use crate::client::{ClientError, EventFormatter, RequestParser};
+use crate::ifs::org_kde_kwin_server_decoration::OrgKdeKwinServerDecorationId;
+use crate::ifs::org_kde_kwin_server_decoration_manager::{
+    OrgKdeKwinServerDecorationManagerObj, DEFAULT_MODE,
+};
+use crate::ifs::wl_surface::WlSurfaceId;
+use crate::object::Object;
+use crate::utils::buffd::{MsgFormatter, MsgParser, MsgParserError};
+use std::fmt::{Debug, Formatter};
+use std::rc::Rc;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum OrgKdeKwinServerDecorationManagerError {
+    #[error("Could not process a `create` request")]
+    CreateError(#[from] CreateError),
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(
+    OrgKdeKwinServerDecorationManagerError,
+    ClientError,
+    ClientError
+);
+
+#[derive(Debug, Error)]
+pub enum CreateError {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+    #[error("Parsing failed")]
+    ParseError(#[source] Box<MsgParserError>),
+}
+efrom!(CreateError, ClientError);
+efrom!(CreateError, ParseError, MsgParserError);
+
+pub(super) struct Create {
+    pub id: OrgKdeKwinServerDecorationId,
+    pub surface: WlSurfaceId,
+}
+impl RequestParser<'_> for Create {
+    fn parse(parser: &mut MsgParser<'_, '_>) -> Result<Self, MsgParserError> {
+        Ok(Self {
+            id: parser.object()?,
+            surface: parser.object()?,
+        })
+    }
+}
+impl Debug for Create {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "create(id: {}, surface: {})", self.id, self.surface)
+    }
+}
+
+pub(super) struct DefaultMode {
+    pub obj: Rc<OrgKdeKwinServerDecorationManagerObj>,
+    pub mode: u32,
+}
+impl EventFormatter for DefaultMode {
+    fn format(self: Box<Self>, fmt: &mut MsgFormatter<'_>) {
+        fmt.header(self.obj.id, DEFAULT_MODE).uint(self.mode);
+    }
+    fn obj(&self) -> &dyn Object {
+        &*self.obj
+    }
+}
+impl Debug for DefaultMode {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "default_mode(mode: {})", self.mode)
+    }
+}

src/ifs/wl_seat/handling.rs

@@ -5,7 +5,9 @@ use crate::ifs::wl_data_device::WlDataDevice;
 use crate::ifs::wl_data_offer::WlDataOfferId;
 use crate::ifs::wl_seat::wl_keyboard::WlKeyboard;
 use crate::ifs::wl_seat::wl_pointer::{WlPointer, POINTER_FRAME_SINCE_VERSION};
-use crate::ifs::wl_seat::{wl_keyboard, wl_pointer, WlSeatGlobal, WlSeatObj};
+use crate::ifs::wl_seat::{
+    wl_keyboard, wl_pointer, PointerGrab, PointerGrabber, WlSeatGlobal, WlSeatObj,
+};
 use crate::ifs::wl_surface::xdg_surface::xdg_popup::XdgPopup;
 use crate::ifs::wl_surface::xdg_surface::xdg_toplevel::XdgToplevel;
 use crate::ifs::wl_surface::xdg_surface::XdgSurface;
@@ -13,13 +15,14 @@ use crate::ifs::wl_surface::WlSurface;
 use crate::tree::{FloatNode, FoundNode, Node};
 use crate::utils::smallmap::SmallMap;
 use crate::xkbcommon::{ModifierState, XKB_KEY_DOWN, XKB_KEY_UP};
-use std::ops::Deref;
+use std::ops::{Deref, DerefMut};
 use std::rc::Rc;
 
 #[derive(Default)]
 pub struct NodeSeatState {
     pointer_foci: SmallMap<SeatId, Rc<WlSeatGlobal>, 1>,
     kb_foci: SmallMap<SeatId, Rc<WlSeatGlobal>, 1>,
+    grabs: SmallMap<SeatId, PointerGrab, 1>,
 }
 
 impl NodeSeatState {
@@ -41,11 +44,25 @@ impl NodeSeatState {
         self.kb_foci.len() == 0
     }
 
+    fn add_pointer_grab(&self, seat: &Rc<WlSeatGlobal>) {
+        self.grabs
+            .insert(seat.id(), PointerGrab { seat: seat.clone() });
+    }
+
+    fn remove_pointer_grab(&self, seat: &WlSeatGlobal) {
+        self.grabs.remove(&seat.id());
+    }
+
+    // pub fn remove_pointer_grabs(&self) {
+    //     self.grabs.clear();
+    // }
+
     pub fn is_active(&self) -> bool {
         self.kb_foci.len() > 0
     }
 
     pub fn destroy_node(&self, node: &dyn Node) {
+        self.grabs.clear();
         let node_id = node.id();
         while let Some((_, seat)) = self.pointer_foci.pop() {
             let mut ps = seat.pointer_stack.borrow_mut();
@@ -92,18 +109,49 @@ impl WlSeatGlobal {
     }
 
     fn button_event(self: &Rc<Self>, button: u32, state: KeyState) {
-        if state == KeyState::Released {
-            self.move_.set(false);
-        }
-        if let Some(node) = self.pointer_node() {
-            node.button(self, button, state);
+        let mut release_grab = false;
+        let mut grabber = self.grabber.borrow_mut();
+        let node = if let Some(pg) = grabber.deref_mut() {
+            if state == KeyState::Released {
+                pg.buttons.remove(&button);
+                if pg.buttons.is_empty() {
+                    release_grab = true;
+                }
+            } else {
+                pg.buttons.insert(button, ());
+            }
+            pg.node.clone()
+        } else if state == KeyState::Pressed {
+            match self.pointer_node() {
+                Some(n) => {
+                    *grabber = Some(PointerGrabber {
+                        node: n.clone(),
+                        buttons: SmallMap::new_with(button, ()),
+                    });
+                    n.seat_state().add_pointer_grab(self);
+                    n
+                }
+                _ => return,
+            }
+        } else {
+            return;
+        };
+        drop(grabber);
+        if release_grab {
+            node.seat_state().remove_pointer_grab(self);
         }
+        node.button(self, button, state);
     }
 
     fn scroll_event(&self, delta: i32, axis: ScrollAxis) {
-        if let Some(node) = self.pointer_node() {
-            node.scroll(self, delta, axis);
-        }
+        let node = match self.grabber.borrow_mut().as_ref().map(|g| g.node.clone()) {
+            Some(n) => n,
+            _ => match self.pointer_node() {
+                Some(n) => n,
+                _ => return,
+            },
+        };
+        node.scroll(self, delta, axis);
     }
 
     fn key_event(&self, key: u32, state: KeyState) {

src/ifs/wl_seat/mod.rs

@@ -16,10 +16,12 @@ use crate::ifs::wl_seat::wl_touch::WlTouch;
 use crate::ifs::wl_surface::xdg_surface::xdg_toplevel::XdgToplevel;
 use crate::object::{Interface, Object, ObjectId};
 use crate::tree::{FloatNode, FoundNode, Node};
+use crate::utils::asyncevent::AsyncEvent;
 use crate::utils::buffd::MsgParser;
 use crate::utils::clonecell::CloneCell;
 use crate::utils::copyhashmap::CopyHashMap;
 use crate::utils::linkedlist::LinkedList;
+use crate::utils::smallmap::SmallMap;
 use crate::xkbcommon::{XkbContext, XkbState};
 use crate::{NumCell, State};
 use ahash::{AHashMap, AHashSet};
@@ -54,18 +56,19 @@ pub const BTN_LEFT: u32 = 0x110;
 
 pub const SEAT_NAME_SINCE: u32 = 2;
 
-pub struct PointerGrab {
+struct PointerGrab {
     seat: Rc<WlSeatGlobal>,
 }
 
-pub struct PointerGrabber {
+struct PointerGrabber {
     node: Rc<dyn Node>,
+    buttons: SmallMap<u32, (), 1>,
 }
 
 impl Drop for PointerGrab {
     fn drop(&mut self) {
         *self.seat.grabber.borrow_mut() = None;
-        self.seat.tree_changed();
+        self.seat.tree_changed.trigger();
     }
 }
 
@@ -91,10 +94,16 @@ pub struct WlSeatGlobal {
     cursor: CloneCell<Option<Rc<dyn Cursor>>>,
     serial: NumCell<u32>,
     grabber: RefCell<Option<PointerGrabber>>,
+    tree_changed: Rc<AsyncEvent>,
 }
 
 impl WlSeatGlobal {
-    pub fn new(name: GlobalName, state: &Rc<State>, seat: &Rc<dyn Seat>) -> Self {
+    pub fn new(
+        name: GlobalName,
+        state: &Rc<State>,
+        seat: &Rc<dyn Seat>,
+        tree_changed: &Rc<AsyncEvent>,
+    ) -> Self {
         let (kb_state, layout, layout_size) = {
             let ctx = XkbContext::new().unwrap();
             let keymap = ctx.default_keymap().unwrap();
@@ -134,17 +143,21 @@ impl WlSeatGlobal {
             cursor: Default::default(),
             serial: Default::default(),
             grabber: RefCell::new(None),
+            tree_changed: tree_changed.clone(),
         }
     }
 
-    pub fn grab_pointer(self: &Rc<Self>, node: Rc<dyn Node>) -> Option<PointerGrab> {
-        let mut grabber = self.grabber.borrow_mut();
-        if grabber.is_some() {
-            return None;
-        }
-        *grabber = Some(PointerGrabber { node });
-        Some(PointerGrab { seat: self.clone() })
-    }
+    // pub fn grab_pointer(self: &Rc<Self>, node: Rc<dyn Node>) -> Option<PointerGrab> {
+    //     let mut grabber = self.grabber.borrow_mut();
+    //     if grabber.is_some() {
+    //         return None;
+    //     }
+    //     *grabber = Some(PointerGrabber {
+    //         node,
+    //         buttons: Default::default(),
+    //     });
+    //     Some(PointerGrab { seat: self.clone() })
+    // }
 
     pub fn set_known_cursor(&self, cursor: KnownCursor) {
         let cursors = match self.state.cursors.get() {

src/ifs/wl_surface/mod.rs

@@ -84,8 +84,8 @@ pub struct WlSurface {
     input_region: Cell<Option<Region>>,
     opaque_region: Cell<Option<Region>>,
     pub extents: Cell<Rect>,
+    pub buffer_abs_pos: Cell<Rect>,
     pub need_extents_update: Cell<bool>,
-    pub effective_extents: Cell<Rect>,
     pub buffer: CloneCell<Option<Rc<WlBuffer>>>,
     pub buf_x: NumCell<i32>,
     pub buf_y: NumCell<i32>,
@@ -179,8 +179,8 @@ impl WlSurface {
             input_region: Cell::new(None),
             opaque_region: Cell::new(None),
             extents: Default::default(),
+            buffer_abs_pos: Cell::new(Default::default()),
             need_extents_update: Cell::new(false),
-            effective_extents: Default::default(),
             buffer: CloneCell::new(None),
             buf_x: Default::default(),
             buf_y: Default::default(),
@@ -193,6 +193,18 @@ impl WlSurface {
         }
     }
 
+    fn set_absolute_position(&self, x1: i32, y1: i32) {
+        self.buffer_abs_pos
+            .set(self.buffer_abs_pos.get().at_point(x1, y1));
+        if let Some(children) = self.children.borrow_mut().deref_mut() {
+            for ss in children.subsurfaces.values() {
+                let pos = ss.position.get();
+                ss.surface
+                    .set_absolute_position(x1 + pos.x1(), y1 + pos.y1());
+            }
+        }
+    }
+
     pub fn is_cursor(&self) -> bool {
         self.role.get() == SurfaceRole::Cursor
     }
@@ -405,6 +417,12 @@ impl WlSurface {
             if let Some((dx, dy, buffer)) = buffer_change {
                 let _ = buffer.update_texture();
                 new_size = Some(buffer.rect);
+                self.buffer_abs_pos.set(
+                    self.buffer_abs_pos
+                        .get()
+                        .with_size(buffer.rect.width(), buffer.rect.height())
+                        .unwrap(),
+                );
                 self.buffer.set(Some(buffer));
                 self.buf_x.fetch_add(dx);
                 self.buf_y.fetch_add(dy);
@@ -596,6 +614,10 @@ impl Node for WlSurface {
         self.seat_state.destroy_node(self);
     }
 
+    fn absolute_position(&self) -> Rect {
+        self.buffer_abs_pos.get()
+    }
+
     fn active_changed(&self, active: bool) {
         if let Some(xdg) = self.xdg.get() {
             xdg.surface_active_changed(active);

src/ifs/wl_surface/xdg_surface/mod.rs

@@ -122,6 +122,19 @@ impl XdgSurface {
         }
     }
 
+    fn set_absolute_desired_extents(&self, ext: &Rect) {
+        let prev = self.absolute_desired_extents.replace(*ext);
+        if ext.x1() != prev.x1() || ext.y1() != prev.y1() {
+            let (mut x1, mut y1) = (ext.x1(), ext.y1());
+            if let Some(geo) = self.geometry.get() {
+                x1 -= geo.x1();
+                y1 -= geo.y1();
+            }
+            self.surface.set_absolute_position(x1, y1);
+            self.update_popup_positions();
+        }
+    }
+
     pub fn surface_active_changed(&self, active: bool) {
         if let Some(ext) = self.ext.get() {
             ext.surface_active_changed(active);
@@ -331,7 +344,6 @@ impl XdgSurface {
         let popups = self.popups.lock();
         for popup in popups.values() {
             popup.update_absolute_position();
-            popup.xdg.update_popup_positions();
         }
     }
 }

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

@@ -173,7 +173,7 @@ impl XdgPopup {
             }
         }
         self.relative_position.set(rel_pos);
-        self.xdg.absolute_desired_extents.set(abs_pos);
+        self.xdg.set_absolute_desired_extents(&abs_pos);
         Ok(())
     }
 
@@ -182,8 +182,7 @@ impl XdgPopup {
             let rel = self.relative_position.get();
             let parent = parent.absolute_desired_extents.get();
             self.xdg
-                .absolute_desired_extents
-                .set(rel.move_(parent.x1(), parent.y1()));
+                .set_absolute_desired_extents(&rel.move_(parent.x1(), parent.y1()));
         }
     }
 

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

@@ -197,7 +197,12 @@ impl XdgToplevel {
     }
 
     fn set_parent(&self, parser: MsgParser<'_, '_>) -> Result<(), SetParentError> {
-        let _req: SetParent = self.xdg.surface.client.parse(self, parser)?;
+        let req: SetParent = self.xdg.surface.client.parse(self, parser)?;
+        let mut parent = None;
+        if req.parent.is_some() {
+            parent = Some(self.xdg.surface.client.get_xdg_toplevel(req.parent)?);
+        }
+        self.parent.set(parent);
         Ok(())
     }
 
@@ -329,6 +334,7 @@ impl XdgToplevel {
         self.xdg.set_workspace(&workspace);
         let output = workspace.output.get();
         let output_rect = output.position.get();
+        log::info!("or = {:?}", output_rect);
         let position = {
             let extents = self.xdg.extents.get().to_origin();
             let width = extents.width();
@@ -343,6 +349,7 @@ impl XdgToplevel {
             }
             Rect::new_sized(x1, y1, width, height).unwrap()
         };
+        log::info!("pos = {:?}", position);
         let state = &self.xdg.surface.client.state;
         let floater = Rc::new(FloatNode {
             id: state.node_ids.next(),
@@ -365,6 +372,7 @@ impl XdgToplevel {
     }
 
     fn map_tiled(self: &Rc<Self>) {
+        log::info!("map tiled");
         let state = &self.xdg.surface.client.state;
         let seat = state.seat_queue.last();
         if let Some(seat) = seat {
@@ -472,7 +480,7 @@ impl Node for XdgToplevel {
     fn change_extents(self: Rc<Self>, rect: &Rect) {
         let nw = rect.width();
         let nh = rect.height();
-        let de = self.xdg.absolute_desired_extents.replace(*rect);
+        let de = self.xdg.absolute_desired_extents.get();
         if de.width() != nw || de.height() != nh {
             self.xdg
                 .surface
@@ -481,9 +489,7 @@ impl Node for XdgToplevel {
             self.xdg.send_configure();
             self.xdg.surface.client.flush();
         }
-        if de.x1() != rect.x1() || de.y1() != rect.y1() {
-            self.xdg.update_popup_positions();
-        }
+        self.xdg.set_absolute_desired_extents(rect);
     }
 
     fn set_workspace(self: Rc<Self>, ws: &Rc<WorkspaceNode>) {