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

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() {