autocommit 2022-01-30 22:41:40 CET

src/ifs/wl_seat/handling.rs

@@ -0,0 +1,384 @@
+use std::ops::Deref;
+use std::rc::Rc;
+use crate::backend::{KeyState, OutputId, ScrollAxis, SeatEvent, SeatId};
+use crate::client::{ClientId, DynEventFormatter};
+use crate::fixed::Fixed;
+use crate::ifs::wl_seat::{wl_pointer, WlSeatGlobal, WlSeatObj};
+use crate::ifs::wl_seat::wl_keyboard::WlKeyboard;
+use crate::ifs::wl_seat::wl_pointer::{POINTER_FRAME_SINCE_VERSION, WlPointer};
+use crate::ifs::wl_surface::WlSurface;
+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;
+use crate::tree::{FloatNode, FoundNode, Node};
+use crate::utils::smallmap::SmallMap;
+use crate::xkbcommon::ModifierState;
+
+#[derive(Default)]
+pub struct NodeSeatState {
+    pointer_foci: SmallMap<SeatId, Rc<WlSeatGlobal>, 1>,
+    kb_foci: SmallMap<SeatId, Rc<WlSeatGlobal>, 1>,
+}
+
+impl NodeSeatState {
+    fn enter(&self, seat: &Rc<WlSeatGlobal>) {
+        self.pointer_foci.insert(seat.seat.id(), seat.clone());
+    }
+
+    fn leave(&self, seat: &WlSeatGlobal) {
+        self.pointer_foci.remove(&seat.seat.id());
+    }
+
+    fn focus(&self, seat: &Rc<WlSeatGlobal>) {
+        self.kb_foci.insert(seat.seat.id(), seat.clone());
+    }
+
+    fn unfocus(&self, seat: &WlSeatGlobal) {
+        self.kb_foci.remove(&seat.seat.id());
+    }
+
+    pub fn destroy_node(&self, node: &dyn Node) {
+        let node_id = node.id();
+        while let Some((_, seat)) = self.pointer_foci.pop() {
+            let mut ps = seat.pointer_stack.borrow_mut();
+            while let Some(last) = ps.pop() {
+                if last.id() == node_id {
+                    break;
+                }
+            }
+            seat.state.tree_changed();
+        }
+        while let Some((_, seat)) = self.kb_foci.pop() {
+            seat.keyboard_node.set(seat.state.root.clone());
+            if let Some(tl) = seat.toplevel_focus_history.last() {
+                seat.focus_xdg_surface(&tl.xdg);
+            }
+        }
+    }
+}
+
+impl WlSeatGlobal {
+    pub fn event(self: &Rc<Self>, event: SeatEvent) {
+        match event {
+            SeatEvent::OutputPosition(o, x, y) => self.output_position_event(o, x, y),
+            SeatEvent::Motion(dx, dy) => self.motion_event(dx, dy),
+            SeatEvent::Button(b, s) => self.button_event(b, s),
+            SeatEvent::Scroll(d, a) => self.scroll_event(d, a),
+            SeatEvent::Key(k, s) => self.key_event(k, s),
+        }
+    }
+
+    fn output_position_event(self: &Rc<Self>, output: OutputId, mut x: Fixed, mut y: Fixed) {
+        let output = match self.state.outputs.get(&output) {
+            Some(o) => o,
+            _ => return,
+        };
+        x += Fixed::from_int(output.x.get());
+        y += Fixed::from_int(output.y.get());
+        self.set_new_position(x, y);
+    }
+
+    fn motion_event(self: &Rc<Self>, dx: Fixed, dy: Fixed) {
+        let (x, y) = self.pos.get();
+        self.set_new_position(x + dx, y + dy);
+    }
+
+    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);
+        }
+    }
+
+    fn scroll_event(&self, delta: i32, axis: ScrollAxis) {
+        if let Some(node) = self.pointer_node() {
+            node.scroll(self, delta, axis);
+        }
+    }
+
+    fn key_event(&self, _key: u32, _state: KeyState) {
+        // let (state, xkb_dir) = {
+        //     let mut pk = self.pressed_keys.borrow_mut();
+        //     match state {
+        //         KeyState::Released => {
+        //             if !pk.remove(&key) {
+        //                 return;
+        //             }
+        //             (wl_keyboard::RELEASED, XKB_KEY_UP)
+        //         }
+        //         KeyState::Pressed => {
+        //             if !pk.insert(key) {
+        //                 return;
+        //             }
+        //             (wl_keyboard::PRESSED, XKB_KEY_DOWN)
+        //         }
+        //     }
+        // };
+        // let mods = self.kb_state.borrow_mut().update(key, xkb_dir);
+        // let node = self.keyboard_node.get().into_kind();
+        // if let NodeKind::Toplevel(node) = node {
+        //     self.tl_kb_event(&node, |k| k.key(0, 0, key, state)).await;
+        //     if let Some(mods) = mods {
+        //         self.tl_kb_event(&node, |k| {
+        //             k.modifiers(
+        //                 0,
+        //                 mods.mods_depressed,
+        //                 mods.mods_latched,
+        //                 mods.mods_locked,
+        //                 mods.group,
+        //             )
+        //         })
+        //         .await;
+        //     }
+        // }
+    }
+}
+
+impl WlSeatGlobal {
+    fn pointer_node(&self) -> Option<Rc<dyn Node>> {
+        self.pointer_stack.borrow().last().cloned()
+    }
+
+    pub fn last_tiled_keyboard_toplevel(&self) -> Option<Rc<XdgToplevel>> {
+        for tl in self.toplevel_focus_history.rev_iter() {
+            if !tl.parent_is_float() {
+                return Some(tl.deref().clone());
+            }
+        }
+        None
+    }
+
+    pub fn move_(&self, node: &Rc<FloatNode>) {
+        self.move_.set(true);
+        self.move_start_pos.set(self.pos.get());
+        let ex = node.position.get();
+        self.extents_start_pos.set((ex.x1(), ex.y1()));
+    }
+
+    fn focus_xdg_surface(self: &Rc<Self>, xdg: &Rc<XdgSurface>) {
+        self.focus_surface(&xdg.focus_surface(self));
+    }
+
+    fn focus_surface(self: &Rc<Self>, surface: &Rc<WlSurface>) {
+        let old = self.keyboard_node.get();
+        if old.id() == surface.node_id {
+            return;
+        }
+        old.unfocus(self);
+        old.seat_state().unfocus(self);
+
+        surface.seat_state().focus(self);
+        surface.clone().focus(self);
+        self.keyboard_node.set(surface.clone());
+
+        let pressed_keys: Vec<_> = self.pressed_keys.borrow().iter().copied().collect();
+        log::info!("enter");
+        self.surface_kb_event(0, &surface, |k| {
+            k.enter(0, surface.id, pressed_keys.clone())
+        });
+        let ModifierState {
+            mods_depressed,
+            mods_latched,
+            mods_locked,
+            group,
+        } = self.kb_state.borrow().mods();
+        self.surface_kb_event(0, &surface, |k| {
+            k.modifiers(0, mods_depressed, mods_latched, mods_locked, group)
+        });
+    }
+
+    fn for_each_seat<C>(&self, ver: u32, client: ClientId, mut f: C)
+        where
+            C: FnMut(&Rc<WlSeatObj>),
+    {
+        let bindings = self.bindings.borrow();
+        if let Some(hm) = bindings.get(&client) {
+            for seat in hm.values() {
+                if seat.version >= ver {
+                    f(seat);
+                }
+            }
+        }
+    }
+
+    fn for_each_pointer<C>(&self, ver: u32, client: ClientId, mut f: C)
+        where
+            C: FnMut(&Rc<WlPointer>),
+    {
+        self.for_each_seat(ver, client, |seat| {
+            let pointers = seat.pointers.lock();
+            for pointer in pointers.values() {
+                f(pointer);
+            }
+        })
+    }
+
+    fn for_each_kb<C>(&self, ver: u32, client: ClientId, mut f: C)
+        where
+            C: FnMut(&Rc<WlKeyboard>),
+    {
+        self.for_each_seat(ver, client, |seat| {
+            let keyboards = seat.keyboards.lock();
+            for keyboard in keyboards.values() {
+                f(keyboard);
+            }
+        })
+    }
+
+    fn surface_pointer_frame(&self, surface: &WlSurface) {
+        self.surface_pointer_event(POINTER_FRAME_SINCE_VERSION, surface, |p| p.frame());
+    }
+
+    fn surface_pointer_event<F>(&self, ver: u32, surface: &WlSurface, mut f: F)
+        where
+            F: FnMut(&Rc<WlPointer>) -> DynEventFormatter,
+    {
+        let client = &surface.client;
+        self.for_each_pointer(ver, client.id, |p| {
+            client.event(f(p));
+        });
+        client.flush();
+    }
+
+    fn surface_kb_event<F>(&self, ver: u32, surface: &WlSurface, mut f: F)
+        where
+            F: FnMut(&Rc<WlKeyboard>) -> DynEventFormatter,
+    {
+        let client = &surface.client;
+        self.for_each_kb(ver, client.id, |p| {
+            client.event(f(p));
+        });
+        client.flush();
+    }
+
+    fn set_new_position(self: &Rc<Self>, x: Fixed, y: Fixed) {
+        self.pos.set((x, y));
+        self.handle_new_position(true);
+    }
+
+    pub fn tree_changed(self: &Rc<Self>) {
+        self.handle_new_position(false);
+    }
+
+    fn handle_new_position(self: &Rc<Self>, changed: bool) {
+        let (x, y) = self.pos.get();
+        let mut found_tree = self.found_tree.borrow_mut();
+        let mut stack = self.pointer_stack.borrow_mut();
+        // if self.move_.get() {
+        //     for node in stack.iter().rev() {
+        //         if let NodeKind::Toplevel(tn) = node.clone().into_kind() {
+        //             let (move_start_x, move_start_y) = self.move_start_pos.get();
+        //             let (move_start_ex, move_start_ey) = self.extents_start_pos.get();
+        //             let mut ex = tn.common.extents.get();
+        //             ex.x = (x - move_start_x).round_down() + move_start_ex;
+        //             ex.y = (y - move_start_y).round_down() + move_start_ey;
+        //             tn.common.extents.set(ex);
+        //         }
+        //     }
+        //     return;
+        // }
+        let x_int = x.round_down();
+        let y_int = y.round_down();
+        found_tree.push(FoundNode {
+            node: self.state.root.clone(),
+            x: x_int,
+            y: y_int,
+        });
+        self.state.root.find_tree_at(x_int, y_int, &mut found_tree);
+        let mut divergence = found_tree.len().min(stack.len());
+        for (i, (found, stack)) in found_tree.iter().zip(stack.iter()).enumerate() {
+            if found.node.id() != stack.id() {
+                divergence = i;
+                break;
+            }
+        }
+        if (stack.len(), found_tree.len()) == (divergence, divergence) {
+            if changed {
+                if let Some(node) = found_tree.last() {
+                    node.node.motion(self, x.apply_fract(node.x), y.apply_fract(node.y));
+                }
+            }
+        } else {
+            for old in stack.drain(divergence..).rev() {
+                old.leave(self);
+                old.seat_state().leave(self);
+            }
+            for new in found_tree.drain(divergence..) {
+                new.node.seat_state().enter(self);
+                new.node.clone().enter(self, x.apply_fract(new.x), y.apply_fract(new.y));
+                stack.push(new.node);
+            }
+        }
+        found_tree.clear();
+    }
+}
+
+// Button callbacks
+impl WlSeatGlobal {
+    pub fn button_surface(self: &Rc<Self>, surface: &Rc<WlSurface>, button: u32, state: KeyState) {
+        let (state, pressed) = match state {
+            KeyState::Released => (wl_pointer::RELEASED, false),
+            KeyState::Pressed => (wl_pointer::PRESSED, true),
+        };
+        self.surface_pointer_event(0, surface, |p| p.button(0, 0, button, state));
+        self.surface_pointer_frame(surface);
+        if pressed {
+            self.focus_surface(surface);
+        }
+    }
+}
+
+// Scroll callbacks
+impl WlSeatGlobal {
+    pub fn scroll_surface(&self, surface: &WlSurface, delta: i32, axis: ScrollAxis) {
+        let axis = match axis {
+            ScrollAxis::Horizontal => wl_pointer::HORIZONTAL_SCROLL,
+            ScrollAxis::Vertical => wl_pointer::VERTICAL_SCROLL,
+        };
+        self.surface_pointer_event(0, surface, |p| p.axis(0, axis, Fixed::from_int(delta)));
+        self.surface_pointer_frame(surface);
+    }
+}
+
+// Motion callbacks
+impl WlSeatGlobal {
+    pub fn motion_surface(&self, n: &WlSurface, x: Fixed, y: Fixed) {
+        self.surface_pointer_event(0, n, |p| p.motion(0, x, y));
+        self.surface_pointer_frame(n);
+    }
+}
+
+// Enter callbacks
+impl WlSeatGlobal {
+    pub fn enter_toplevel(self: &Rc<Self>, n: &Rc<XdgToplevel>) {
+        let node = self.toplevel_focus_history.add_last(n.clone());
+        n.toplevel_history.insert(self.id(), node);
+        self.focus_xdg_surface(&n.xdg);
+    }
+
+    pub fn enter_popup(self: &Rc<Self>, n: &Rc<XdgPopup>) {
+        self.focus_xdg_surface(&n.xdg);
+    }
+
+    pub fn enter_surface(&self, n: &WlSurface, x: Fixed, y: Fixed) {
+        self.surface_pointer_event(0, n, |p| p.enter(0, n.id, x, y));
+        self.surface_pointer_frame(n);
+    }
+}
+
+// Leave callbacks
+impl WlSeatGlobal {
+    pub fn leave_surface(&self, n: &WlSurface) {
+        self.surface_pointer_event(0, n, |p| p.leave(0, n.id));
+        self.surface_pointer_frame(n);
+    }
+}
+
+// Unfocus callbacks
+impl WlSeatGlobal {
+    pub fn unfocus_surface(&self, surface: &WlSurface) {
+        self.surface_kb_event(0, surface, |k| k.leave(0, surface.id))
+    }
+}

src/ifs/wl_seat/mod.rs

@@ -2,34 +2,32 @@ mod types;
 pub mod wl_keyboard;
 pub mod wl_pointer;
 pub mod wl_touch;
+mod handling;
 
-use crate::backend::{KeyState, OutputId, ScrollAxis, Seat, SeatEvent};
+use crate::backend::{Seat, SeatId};
 use crate::client::{Client, ClientId, DynEventFormatter};
 use crate::fixed::Fixed;
 use crate::globals::{Global, GlobalName};
 use crate::ifs::wl_seat::wl_keyboard::{WlKeyboard, WlKeyboardId, REPEAT_INFO_SINCE};
-use crate::ifs::wl_seat::wl_pointer::{WlPointer, WlPointerId, POINTER_FRAME_SINCE_VERSION};
+use crate::ifs::wl_seat::wl_pointer::{WlPointer, WlPointerId};
 use crate::ifs::wl_seat::wl_touch::WlTouch;
-use crate::ifs::wl_surface::xdg_surface::xdg_toplevel::{XdgToplevel, XdgToplevelId};
-use crate::ifs::wl_surface::WlSurface;
+use crate::ifs::wl_surface::xdg_surface::xdg_toplevel::{XdgToplevel};
 use crate::object::{Interface, Object, ObjectId};
-use crate::tree::{FloatNode, Node};
+use crate::tree::{FloatNode, FoundNode, Node};
 use crate::utils::buffd::MsgParser;
 use crate::utils::clonecell::CloneCell;
 use crate::utils::copyhashmap::CopyHashMap;
-use crate::utils::linkedlist::{LinkedList, LinkedNode};
-use crate::xkbcommon::{ModifierState, XkbContext, XkbState};
+use crate::utils::linkedlist::{LinkedList};
+use crate::xkbcommon::{XkbContext, XkbState};
 use crate::State;
 use ahash::{AHashMap, AHashSet};
 use bstr::ByteSlice;
 use std::cell::{Cell, RefCell};
 use std::io::Write;
-use std::ops::Deref;
 use std::rc::Rc;
 pub use types::*;
 use uapi::{c, OwnedFd};
-use crate::ifs::wl_surface::xdg_surface::xdg_popup::XdgPopup;
-use crate::ifs::wl_surface::xdg_surface::XdgSurface;
+pub use handling::NodeSeatState;
 
 id!(WlSeatId);
 
@@ -55,14 +53,14 @@ const BTN_LEFT: u32 = 0x110;
 pub struct WlSeatGlobal {
     name: GlobalName,
     state: Rc<State>,
-    _seat: Rc<dyn Seat>,
+    seat: Rc<dyn Seat>,
     move_: Cell<bool>,
     move_start_pos: Cell<(Fixed, Fixed)>,
     extents_start_pos: Cell<(i32, i32)>,
     pos: Cell<(Fixed, Fixed)>,
     pointer_stack: RefCell<Vec<Rc<dyn Node>>>,
+    found_tree: RefCell<Vec<FoundNode>>,
     toplevel_focus_history: LinkedList<Rc<XdgToplevel>>,
-    toplevel_focus_stash: RefCell<AHashMap<XdgToplevelId, LinkedNode<Rc<XdgToplevel>>>>,
     keyboard_node: CloneCell<Rc<dyn Node>>,
     pressed_keys: RefCell<AHashSet<u32>>,
     bindings: RefCell<AHashMap<ClientId, AHashMap<WlSeatId, Rc<WlSeatObj>>>>,
@@ -87,20 +85,20 @@ impl WlSeatGlobal {
                 memfd.raw(),
                 c::F_SEAL_SEAL | c::F_SEAL_GROW | c::F_SEAL_SHRINK | c::F_SEAL_WRITE,
             )
-            .unwrap();
+                .unwrap();
             (state, Rc::new(memfd), (string.len() + 1) as _)
         };
         Self {
             name,
             state: state.clone(),
-            _seat: seat.clone(),
+            seat: seat.clone(),
             move_: Cell::new(false),
             move_start_pos: Cell::new((Fixed(0), Fixed(0))),
             extents_start_pos: Cell::new((0, 0)),
             pos: Cell::new((Fixed(0), Fixed(0))),
             pointer_stack: RefCell::new(vec![]),
+            found_tree: RefCell::new(vec![]),
             toplevel_focus_history: Default::default(),
-            toplevel_focus_stash: RefCell::new(Default::default()),
             keyboard_node: CloneCell::new(state.root.clone()),
             pressed_keys: RefCell::new(Default::default()),
             bindings: Default::default(),
@@ -110,321 +108,8 @@ impl WlSeatGlobal {
         }
     }
 
-    pub fn last_tiled_keyboard_toplevel(&self) -> Option<Rc<XdgToplevel>> {
-        for tl in self.toplevel_focus_history.rev_iter() {
-            if !tl.parent_is_float() {
-                return Some(tl.deref().clone());
-            }
-        }
-        None
-    }
-
-    pub fn move_(&self, node: &Rc<FloatNode>) {
-        self.move_.set(true);
-        self.move_start_pos.set(self.pos.get());
-        let ex = node.position.get();
-        self.extents_start_pos.set((ex.x1(), ex.y1()));
-    }
-
-    pub fn event(&self, event: SeatEvent) {
-        match event {
-            SeatEvent::OutputPosition(o, x, y) => self.output_position_event(o, x, y),
-            SeatEvent::Motion(dx, dy) => self.motion_event(dx, dy),
-            SeatEvent::Button(b, s) => self.button_event(b, s),
-            SeatEvent::Scroll(d, a) => self.scroll_event(d, a),
-            SeatEvent::Key(k, s) => self.key_event(k, s),
-        }
-    }
-
-    pub fn button_surface(&self, surface: &Rc<WlSurface>, button: u32, state: KeyState) {
-        let state = match state {
-            KeyState::Released => wl_pointer::RELEASED,
-            KeyState::Pressed => wl_pointer::PRESSED,
-        };
-        self.surface_pointer_event(0, surface, |p| p.button(0, 0, button, state));
-    }
-
-    pub fn focus_surface(&self, surface: &Rc<WlSurface>) {
-        let pressed_keys: Vec<_> = self.pressed_keys.borrow().iter().copied().collect();
-        self.surface_kb_event(0, &surface, |k| {
-            k.enter(0, surface.id, pressed_keys.clone())
-        });
-        let ModifierState {
-            mods_depressed,
-            mods_latched,
-            mods_locked,
-            group,
-        } = self.kb_state.borrow().mods();
-        self.surface_kb_event(0, surface, |k| {
-            k.modifiers(0, mods_depressed, mods_latched, mods_locked, group)
-        });
-    }
-
-    pub fn unfocus_surface(&self, surface: &Rc<WlSurface>) {
-        self.surface_kb_event(0, surface, |k| k.leave(0, surface.id))
-    }
-
-    fn focus_toplevel(&self, toplevel: &Rc<XdgToplevel>) {
-        let node = self.toplevel_focus_history.add_last(toplevel.clone());
-        self.toplevel_focus_stash
-            .borrow_mut()
-            .insert(toplevel.id, node);
-        self.focus_xdg_surface(&toplevel.xdg);
-    }
-
-    fn focus_xdg_surface(&self, xdg: &Rc<XdgSurface>) {
-        self.keyboard_node.get().unfocus(self);
-        let focus_surface;
-        if let Some(ss) = xdg.focus_subsurface.get() {
-            focus_surface = ss.surface.clone();
-            self.keyboard_node.set(ss);
-        } else {
-            focus_surface = xdg.surface.clone();
-            self.keyboard_node.set(focus_surface.clone());
-        }
-        self.focus_surface(&focus_surface);
-    }
-
-    fn output_position_event(&self, output: OutputId, mut x: Fixed, mut y: Fixed) {
-        let output = match self.state.outputs.get(&output) {
-            Some(o) => o,
-            _ => return,
-        };
-        x += Fixed::from_int(output.x.get());
-        y += Fixed::from_int(output.y.get());
-        self.set_new_position(x, y);
-    }
-
-    fn for_each_seat<C>(&self, ver: u32, client: ClientId, mut f: C)
-    where
-        C: FnMut(&Rc<WlSeatObj>),
-    {
-        let bindings = self.bindings.borrow();
-        if let Some(hm) = bindings.get(&client) {
-            for seat in hm.values() {
-                if seat.version >= ver {
-                    f(seat);
-                }
-            }
-        }
-    }
-
-    fn for_each_pointer<C>(&self, ver: u32, client: ClientId, mut f: C)
-    where
-        C: FnMut(&Rc<WlPointer>),
-    {
-        self.for_each_seat(ver, client, |seat| {
-            let pointers = seat.pointers.lock();
-            for pointer in pointers.values() {
-                f(pointer);
-            }
-        })
-    }
-
-    fn for_each_kb<C>(&self, ver: u32, client: ClientId, mut f: C)
-    where
-        C: FnMut(&Rc<WlKeyboard>),
-    {
-        self.for_each_seat(ver, client, |seat| {
-            let keyboards = seat.keyboards.lock();
-            for keyboard in keyboards.values() {
-                f(keyboard);
-            }
-        })
-    }
-
-    fn surface_pointer_event<F>(&self, ver: u32, surface: &WlSurface, mut f: F)
-    where
-        F: FnMut(&Rc<WlPointer>) -> DynEventFormatter,
-    {
-        let client = &surface.client;
-        self.for_each_pointer(ver, client.id, |p| {
-            client.event(f(p));
-        });
-        client.flush();
-    }
-
-    fn surface_kb_event<F>(&self, ver: u32, surface: &WlSurface, mut f: F)
-    where
-        F: FnMut(&Rc<WlKeyboard>) -> DynEventFormatter,
-    {
-        let client = &surface.client;
-        self.for_each_kb(ver, client.id, |p| {
-            client.event(f(p));
-        });
-        client.flush();
-    }
-
-    fn set_new_position(&self, x: Fixed, y: Fixed) {
-        self.pos.set((x, y));
-        self.handle_new_position(true);
-    }
-
-    pub fn tree_changed(&self) {
-        log::info!("tree changed");
-        self.handle_new_position(false);
-    }
-
-    pub fn handle_new_position(&self, changed: bool) {
-        let (x, y) = self.pos.get();
-        let mut stack = self.pointer_stack.borrow_mut();
-        // if self.move_.get() {
-        //     for node in stack.iter().rev() {
-        //         if let NodeKind::Toplevel(tn) = node.clone().into_kind() {
-        //             let (move_start_x, move_start_y) = self.move_start_pos.get();
-        //             let (move_start_ex, move_start_ey) = self.extents_start_pos.get();
-        //             let mut ex = tn.common.extents.get();
-        //             ex.x = (x - move_start_x).round_down() + move_start_ex;
-        //             ex.y = (y - move_start_y).round_down() + move_start_ey;
-        //             tn.common.extents.set(ex);
-        //         }
-        //     }
-        //     return;
-        // }
-        let mut x_int = x.round_down();
-        let mut y_int = y.round_down();
-        let mut node = Some(self.state.root.clone() as Rc<dyn Node>);
-        let divergence = 'outer: loop {
-            for i in 0..stack.len() {
-                match node.take() {
-                    None => break 'outer i,
-                    Some(n) if n.id() != stack[i].id() => {
-                        node = Some(n);
-                        break 'outer i;
-                    }
-                    Some(n) => {
-                        if let Some(found) = n.find_child_at(x_int.into(), y_int.into()) {
-                            node = Some(found.node);
-                            x_int = found.x.into();
-                            y_int = found.y.into();
-                        }
-                    }
-                }
-            }
-            break stack.len();
-        };
-        if divergence == stack.len() && node.is_none() {
-            if changed {
-                if let Some(node) = stack.last() {
-                    node.motion(self, x.apply_fract(x_int), y.apply_fract(y_int));
-                }
-            }
-        } else {
-            for node in stack.drain(divergence..).rev() {
-                node.leave(self);
-            }
-            while let Some(n) = node.take() {
-                n.clone()
-                    .enter(self, x.apply_fract(x_int), y.apply_fract(y_int));
-                if let Some(found) = n.find_child_at(x_int.into(), y_int.into()) {
-                    node = Some(found.node);
-                    x_int = found.x.into();
-                    y_int = found.y.into();
-                }
-                stack.push(n);
-            }
-        }
-    }
-
-    pub fn leave_surface(&self, n: &WlSurface) {
-        self.surface_pointer_event(0, n, |p| p.leave(0, n.id));
-    }
-
-    pub fn enter_toplevel(&self, n: &Rc<XdgToplevel>) {
-        self.focus_toplevel(n);
-    }
-
-    pub fn enter_popup(&self, n: &Rc<XdgPopup>) {
-        self.focus_xdg_surface(&n.xdg);
-    }
-
-    pub fn enter_surface(&self, n: &WlSurface, x: Fixed, y: Fixed) {
-        self.surface_pointer_event(0, n, |p| p.enter(0, n.id, x, y));
-    }
-
-    pub fn motion_surface(&self, n: &WlSurface, x: Fixed, y: Fixed) {
-        self.surface_pointer_event(0, n, |p| p.motion(0, x, y));
-        self.surface_pointer_event(POINTER_FRAME_SINCE_VERSION, n, |p| p.frame());
-    }
-
-    fn motion_event(&self, dx: Fixed, dy: Fixed) {
-        let (x, y) = self.pos.get();
-        self.set_new_position(x + dx, y + dy);
-    }
-
-    fn button_event(&self, button: u32, state: KeyState) {
-        if state == KeyState::Released {
-            self.move_.set(false);
-        }
-        let node = match self.pointer_stack.borrow().last().cloned() {
-            Some(v) => v,
-            _ => return,
-        };
-        let mut enter = false;
-        {
-            let kb_node = self.keyboard_node.get();
-            if kb_node.id() != node.id() {
-                enter = true;
-                kb_node.unfocus(self);
-                self.keyboard_node.set(node.clone());
-            }
-        }
-        node.clone().button(self, button, state);
-        if enter {
-            node.focus(self);
-        }
-    }
-
-    pub fn scroll_surface(&self, surface: &WlSurface, delta: i32, axis: ScrollAxis) {
-        let axis = match axis {
-            ScrollAxis::Horizontal => wl_pointer::HORIZONTAL_SCROLL,
-            ScrollAxis::Vertical => wl_pointer::VERTICAL_SCROLL,
-        };
-        self.surface_pointer_event(0, surface, |p| p.axis(0, axis, Fixed::from_int(delta)));
-        self.surface_pointer_event(POINTER_FRAME_SINCE_VERSION, surface, |p| p.frame());
-    }
-
-    fn scroll_event(&self, delta: i32, axis: ScrollAxis) {
-        if let Some(node) = self.pointer_stack.borrow().last().cloned() {
-            node.scroll(self, delta, axis);
-        }
-    }
-
-    fn key_event(&self, _key: u32, _state: KeyState) {
-        // let (state, xkb_dir) = {
-        //     let mut pk = self.pressed_keys.borrow_mut();
-        //     match state {
-        //         KeyState::Released => {
-        //             if !pk.remove(&key) {
-        //                 return;
-        //             }
-        //             (wl_keyboard::RELEASED, XKB_KEY_UP)
-        //         }
-        //         KeyState::Pressed => {
-        //             if !pk.insert(key) {
-        //                 return;
-        //             }
-        //             (wl_keyboard::PRESSED, XKB_KEY_DOWN)
-        //         }
-        //     }
-        // };
-        // let mods = self.kb_state.borrow_mut().update(key, xkb_dir);
-        // let node = self.keyboard_node.get().into_kind();
-        // if let NodeKind::Toplevel(node) = node {
-        //     self.tl_kb_event(&node, |k| k.key(0, 0, key, state)).await;
-        //     if let Some(mods) = mods {
-        //         self.tl_kb_event(&node, |k| {
-        //             k.modifiers(
-        //                 0,
-        //                 mods.mods_depressed,
-        //                 mods.mods_latched,
-        //                 mods.mods_locked,
-        //                 mods.group,
-        //             )
-        //         })
-        //         .await;
-        //     }
-        // }
+    pub fn id(&self) -> SeatId {
+        self.seat.id()
     }
 
     fn bind_(