cli: add seat-test

src/ifs/jay_compositor.rs

@@ -3,7 +3,10 @@ use {
         cli::CliLogLevel,
         client::{Client, ClientError},
         globals::{Global, GlobalName},
-        ifs::{jay_idle::JayIdle, jay_log_file::JayLogFile, jay_screenshot::JayScreenshot},
+        ifs::{
+            jay_idle::JayIdle, jay_log_file::JayLogFile, jay_screenshot::JayScreenshot,
+            jay_seat_events::JaySeatEvents,
+        },
         leaks::Tracker,
         object::Object,
         screenshoter::take_screenshot,
@@ -193,6 +196,35 @@ impl JayCompositor {
         self.client.symmetric_delete.set(true);
         Ok(())
     }
+
+    fn get_seats(&self, parser: MsgParser<'_, '_>) -> Result<(), JayCompositorError> {
+        let _req: GetSeats = self.client.parse(self, parser)?;
+        for seat in self.client.state.globals.seats.lock().values() {
+            self.client.event(Seat {
+                self_id: self.id,
+                id: seat.id().raw(),
+                name: seat.seat_name(),
+            })
+        }
+        Ok(())
+    }
+
+    fn seat_events(&self, parser: MsgParser<'_, '_>) -> Result<(), JayCompositorError> {
+        let req: SeatEvents = self.client.parse(self, parser)?;
+        let se = Rc::new(JaySeatEvents {
+            id: req.id,
+            client: self.client.clone(),
+            tracker: Default::default(),
+        });
+        track!(self.client, se);
+        self.client.add_client_obj(&se)?;
+        self.client
+            .state
+            .testers
+            .borrow_mut()
+            .insert((self.client.id, req.id), se);
+        Ok(())
+    }
 }
 
 object_base! {
@@ -207,11 +239,13 @@ object_base! {
     GET_CLIENT_ID => get_client_id,
     ENABLE_SYMMETRIC_DELETE => enable_symmetric_delete,
     UNLOCK => unlock,
+    GET_SEATS => get_seats,
+    SEAT_EVENTS => seat_events,
 }
 
 impl Object for JayCompositor {
     fn num_requests(&self) -> u32 {
-        UNLOCK + 1
+        SEAT_EVENTS + 1
     }
 }
 

src/ifs/jay_seat_events.rs

@@ -0,0 +1,152 @@
+use {
+    crate::{
+        backend::{self, KeyState},
+        client::Client,
+        fixed::Fixed,
+        ifs::wl_seat::{wl_pointer::PendingScroll, SeatId},
+        leaks::Tracker,
+        object::Object,
+        state::DeviceHandlerData,
+        wire::{jay_seat_events::*, JaySeatEventsId},
+        xkbcommon::ModifierState,
+    },
+    std::rc::Rc,
+};
+
+pub struct JaySeatEvents {
+    pub id: JaySeatEventsId,
+    pub client: Rc<Client>,
+    pub tracker: Tracker<Self>,
+}
+
+impl JaySeatEvents {
+    pub fn send_modifiers(&self, seat: SeatId, mods: &ModifierState) {
+        self.client.event(Modifiers {
+            self_id: self.id,
+            seat: seat.raw(),
+            modifiers: mods.mods_effective,
+            group: mods.group,
+        });
+    }
+
+    pub fn send_key(&self, seat: SeatId, time_usec: u64, key: u32, state: KeyState) {
+        self.client.event(Key {
+            self_id: self.id,
+            seat: seat.raw(),
+            time_usec,
+            key,
+            state: state as u32,
+        });
+    }
+
+    pub fn send_pointer_abs(&self, seat: SeatId, time_usec: u64, x: Fixed, y: Fixed) {
+        self.client.event(PointerAbs {
+            self_id: self.id,
+            seat: seat.raw(),
+            time_usec,
+            x,
+            y,
+        });
+    }
+
+    pub fn send_pointer_rel(
+        &self,
+        seat: SeatId,
+        time_usec: u64,
+        x: Fixed,
+        y: Fixed,
+        dx: Fixed,
+        dy: Fixed,
+        dx_unaccelerated: Fixed,
+        dy_unaccelerated: Fixed,
+    ) {
+        self.client.event(PointerRel {
+            self_id: self.id,
+            seat: seat.raw(),
+            time_usec,
+            x,
+            y,
+            dx,
+            dy,
+            dx_unaccelerated,
+            dy_unaccelerated,
+        });
+    }
+
+    pub fn send_button(&self, seat: SeatId, time_usec: u64, button: u32, state: KeyState) {
+        self.client.event(Button {
+            self_id: self.id,
+            seat: seat.raw(),
+            time_usec,
+            button,
+            state: state as u32,
+        });
+    }
+
+    pub fn send_axis(
+        &self,
+        seat: SeatId,
+        time_usec: u64,
+        dev: &DeviceHandlerData,
+        ps: &PendingScroll,
+    ) {
+        if let Some(source) = ps.source.get() {
+            self.client.event(AxisSource {
+                self_id: self.id,
+                source,
+            });
+        }
+        for axis in 0..1 {
+            if let Some(dist) = ps.v120[axis].get() {
+                self.client.event(Axis120 {
+                    self_id: self.id,
+                    dist,
+                    axis: axis as _,
+                });
+                let px = (dist as f64 / backend::AXIS_120 as f64) * dev.px_per_scroll_wheel.get();
+                self.client.event(AxisPx {
+                    self_id: self.id,
+                    dist: Fixed::from_f64(px),
+                    axis: axis as _,
+                });
+            } else if let Some(dist) = ps.px[axis].get() {
+                self.client.event(AxisPx {
+                    self_id: self.id,
+                    dist,
+                    axis: axis as _,
+                });
+            }
+            if ps.stop[axis].get() {
+                self.client.event(AxisStop {
+                    self_id: self.id,
+                    axis: axis as _,
+                });
+            }
+        }
+        self.client.event(AxisFrame {
+            self_id: self.id,
+            seat: seat.raw(),
+            time_usec,
+        });
+    }
+}
+
+object_base! {
+    JaySeatEvents;
+}
+
+impl Object for JaySeatEvents {
+    fn num_requests(&self) -> u32 {
+        0
+    }
+
+    fn break_loops(&self) {
+        self.client
+            .state
+            .testers
+            .borrow_mut()
+            .remove(&(self.client.id, self.id));
+    }
+}
+
+simple_add_obj!(JaySeatEvents);

src/ifs/wl_seat/event_handling.rs

@@ -191,7 +191,7 @@ impl WlSeatGlobal {
                 time_usec,
                 button,
                 state,
-            } => self.pointer_owner.button(self, time_usec, button, state),
+            } => self.button_event(time_usec, button, state),
 
             InputEvent::AxisSource { source } => self.pointer_owner.axis_source(source),
             InputEvent::Axis120 { dist, axis } => self.pointer_owner.axis_120(dist, axis),
@@ -216,6 +216,9 @@ impl WlSeatGlobal {
         let pos = output.node.global.pos.get();
         x += Fixed::from_int(pos.x1());
         y += Fixed::from_int(pos.y1());
+        self.state.for_each_seat_tester(|t| {
+            t.send_pointer_abs(self.id, time_usec, x, y);
+        });
         self.set_new_position(time_usec, x, y);
     }
 
@@ -238,6 +241,18 @@ impl WlSeatGlobal {
         let (mut x, mut y) = self.pos.get();
         x += dx;
         y += dy;
+        self.state.for_each_seat_tester(|t| {
+            t.send_pointer_rel(
+                self.id,
+                time_usec,
+                x,
+                y,
+                dx,
+                dy,
+                dx_unaccelerated,
+                dy_unaccelerated,
+            );
+        });
         let output = self.output.get();
         let pos = output.global.pos.get();
         let mut x_int = x.round_down();
@@ -268,10 +283,17 @@ impl WlSeatGlobal {
         self.set_new_position(time_usec, x, y);
     }
 
-    fn key_event(&self, time_usec: u64, key: u32, state: KeyState) {
+    fn button_event(self: &Rc<Self>, time_usec: u64, button: u32, state: KeyState) {
+        self.state.for_each_seat_tester(|t| {
+            t.send_button(self.id, time_usec, button, state);
+        });
+        self.pointer_owner.button(self, time_usec, button, state);
+    }
+
+    fn key_event(&self, time_usec: u64, key: u32, key_state: KeyState) {
         let (state, xkb_dir) = {
             let mut pk = self.pressed_keys.borrow_mut();
-            match state {
+            match key_state {
                 KeyState::Released => {
                     if !pk.remove(&key) {
                         return;
@@ -304,6 +326,9 @@ impl WlSeatGlobal {
             }
             new_mods = kb_state.update(key, xkb_dir);
         }
+        self.state.for_each_seat_tester(|t| {
+            t.send_key(self.id, time_usec, key, key_state);
+        });
         let node = self.keyboard_node.get();
         if shortcuts.is_empty() {
             node.node_on_key(self, time_usec, key, state);
@@ -313,6 +338,9 @@ impl WlSeatGlobal {
             }
         }
         if let Some(mods) = new_mods {
+            self.state.for_each_seat_tester(|t| {
+                t.send_modifiers(self.id, &mods);
+            });
             node.node_on_mods(self, mods);
         }
     }

src/ifs/wl_seat/pointer_owner.rs

@@ -55,6 +55,9 @@ impl PointerOwnerHolder {
     pub fn frame(&self, dev: &DeviceHandlerData, seat: &Rc<WlSeatGlobal>, time_usec: u64) {
         self.pending_scroll.time_usec.set(time_usec);
         let pending = self.pending_scroll.take();
+        seat.state.for_each_seat_tester(|t| {
+            t.send_axis(seat.id, time_usec, dev, &pending);
+        });
         if let Some(node) = self.owner.get().axis_node(seat) {
             node.node_on_axis_event(dev, seat, &pending);
         }