More work on pointer.

Author: Narsil

.github/workflows/rust.yml

@@ -30,7 +30,7 @@ jobs:
 
           build: cargo build --verbose --no-default-features --features wayland
           # Keyboard not implemented in wayland
-          test: WAYLAND_DISPLAY=wl-test-env cargo test --verbose --no-default-features --features=serialize,wayland -- --skip test_keyboard_state
+          test: WAYLAND_DISPLAY=wl-test-env cargo test --verbose --no-default-features --features=serialize,wayland -- --skip test_keyboard_state --skip test_listen_and_simulate --skip test_grab
         - variant: macos-latest
           os: macos-latest
           build: cargo build --verbose

Cargo.toml

@@ -18,7 +18,7 @@ serde = {version = "1.0", features = ["derive"], optional=true}
 lazy_static = "1.4"
 
 [features]
-default = ["x11"]
+default = []
 serialize = ["serde"]
 unstable_grab = ["evdev-rs", "epoll", "inotify"]
 wayland = ["input", "input-linux"]

src/linux/wayland/grab.rs

@@ -367,7 +367,7 @@ where
                     add_device_to_epoll_from_inotify_event(epoll_fd, event, &mut devices)?;
                 }
             } else {
-                // Input device recieved event
+                // Input device received event
                 let device_idx = event.data as usize;
                 let device = devices.get(device_idx).unwrap();
                 while device.has_event_pending() {

src/linux/wayland/listen.rs

@@ -1,8 +1,10 @@
 extern crate libc;
 use super::keycodes::key_from_code;
 use crate::rdev::{Event, ListenError};
-use crate::EventType;
+use crate::{Button, EventType};
 use input::event::keyboard::{KeyState, KeyboardEventTrait};
+use input::event::pointer::{Axis, ButtonState};
+use input::event::PointerEvent;
 use input::{Event as LibEvent, Libinput, LibinputInterface};
 use libc::{O_RDONLY, O_RDWR, O_WRONLY};
 use std::fs::{File, OpenOptions};
@@ -22,7 +24,40 @@ fn convert_type(libevent: LibEvent) -> Option<EventType> {
                 KeyState::Released => Some(EventType::KeyRelease(k)),
             }
         }
-        _ => None,
+        LibEvent::Pointer(PointerEvent::Button(btn)) => {
+            let rdev_btn = match btn.button() {
+                272 => Some(Button::Left),
+                273 => Some(Button::Right),
+                274 => Some(Button::Middle),
+                _ => None,
+            };
+            if let Some(rdev_btn) = rdev_btn {
+                let state: ButtonState = btn.button_state();
+                match state {
+                    ButtonState::Pressed => Some(EventType::ButtonPress(rdev_btn)),
+                    ButtonState::Released => Some(EventType::ButtonRelease(rdev_btn)),
+                }
+            } else {
+                None
+            }
+        }
+        LibEvent::Pointer(PointerEvent::Motion(btn)) => Some(EventType::MouseMove {
+            // TODO Convert to absolute X, Y
+            x: btn.dx(),
+            y: btn.dy(),
+        }),
+        LibEvent::Pointer(PointerEvent::MotionAbsolute(btn)) => Some(EventType::MouseMove {
+            x: btn.absolute_x(),
+            y: btn.absolute_y(),
+        }),
+        LibEvent::Pointer(PointerEvent::ScrollWheel(btn)) => Some(EventType::Wheel {
+            delta_x: -(btn.scroll_value_v120(Axis::Horizontal) / 120.0) as i64,
+            delta_y: -(btn.scroll_value_v120(Axis::Vertical) / 120.0) as i64,
+        }),
+        lib => {
+            dbg!(format!("Received unhandlded event {lib:?}"));
+            None
+        }
     }
 }
 fn convert(libevent: LibEvent) -> Option<Event> {

src/linux/wayland/simulate.rs

@@ -30,11 +30,16 @@ impl Handle {
             uinput.set_relbit(RelativeAxis::X).unwrap();
             uinput.set_relbit(RelativeAxis::Y).unwrap();
             uinput.set_relbit(RelativeAxis::Wheel).unwrap();
+            uinput.set_relbit(RelativeAxis::WheelHiRes).unwrap();
 
             // Enable all keys
             for key in UKey::iter() {
                 uinput.set_keybit(key).unwrap();
             }
+            // Enable all keys
+            for rel in RelativeAxis::iter() {
+                uinput.set_relbit(rel).unwrap();
+            }
 
             let input_id = InputId {
                 bustype: input_linux::sys::BUS_VIRTUAL,
@@ -116,21 +121,30 @@ impl Handle {
                 }
                 EventType::MouseMove { x, y } => {
                     let time = Self::get_current_time();
+                    let reset_x = RelativeEvent::new(time, RelativeAxis::X, i32::MIN);
+                    let reset_x: input_event = InputEvent::from(reset_x).into();
+                    let reset_y = RelativeEvent::new(time, RelativeAxis::Y, i32::MIN);
+                    let reset_y: input_event = InputEvent::from(reset_y).into();
+                    let rsync = SynchronizeEvent::new(time, SynchronizeKind::Report, 0);
+                    let rsync: input_event = InputEvent::from(rsync).into();
+
                     let event_x = RelativeEvent::new(time, RelativeAxis::X, *x as i32);
                     let event_x: input_event = InputEvent::from(event_x).into();
                     let event_y = RelativeEvent::new(time, RelativeAxis::Y, *y as i32);
                     let event_y: input_event = InputEvent::from(event_y).into();
                     let sync = SynchronizeEvent::new(time, SynchronizeKind::Report, 0);
                     let sync: input_event = InputEvent::from(sync).into();
                     handle
-                        .write(&[event_x, event_y, sync])
+                        .write(&[reset_x, reset_y, rsync, event_x, event_y, sync])
                         .map_err(|_| SimulateError)?;
                 }
                 EventType::Wheel { delta_x, delta_y } => {
                     let time = Self::get_current_time();
-                    let event_x = RelativeEvent::new(time, RelativeAxis::Wheel, *delta_x as i32);
+                    let event_x =
+                        RelativeEvent::new(time, RelativeAxis::WheelHiRes, (*delta_x * 120) as i32);
                     let event_x: input_event = InputEvent::from(event_x).into();
-                    let event_y = RelativeEvent::new(time, RelativeAxis::Wheel, *delta_y as i32);
+                    let event_y =
+                        RelativeEvent::new(time, RelativeAxis::WheelHiRes, (*delta_y * 120) as i32);
                     let event_y: input_event = InputEvent::from(event_y).into();
                     let sync = SynchronizeEvent::new(time, SynchronizeKind::Report, 0);
                     let sync: input_event = InputEvent::from(sync).into();

src/linux/x11/grab.rs

@@ -367,7 +367,7 @@ where
                     add_device_to_epoll_from_inotify_event(epoll_fd, event, &mut devices)?;
                 }
             } else {
-                // Input device recieved event
+                // Input device received event
                 let device_idx = event.data as usize;
                 let device = devices.get(device_idx).unwrap();
                 while device.has_event_pending() {

tests/listen_and_simulate.rs

@@ -35,8 +35,10 @@ fn sim_then_listen(events: &mut dyn Iterator<Item = EventType>) -> Result<(), Bo
     let recv = EVENT_CHANNEL.1.lock()?;
     for event in events {
         simulate(&event)?;
-        let recieved_event = recv.recv_timeout(second).expect("No events to recieve");
-        assert_eq!(recieved_event.event_type, event);
+        let received_event = recv
+            .recv_timeout(second)
+            .expect(&format!("No events to receive {event:?}"));
+        assert_eq!(received_event.event_type, event);
     }
     Ok(())
 }
@@ -47,10 +49,15 @@ fn test_listen_and_simulate() -> Result<(), Box<dyn Error>> {
     // wait for user input from keyboard to stop
     // (i.e. the return/enter keypress to run test command)
     thread::sleep(Duration::from_millis(50));
+    // On wayland we need to open libuinput and the hooks take
+    // some time to install, this forces the handle to get installed
+    simulate(&EventType::MouseMove { x: 0.0, y: 0.0 })?;
+    thread::sleep(Duration::from_millis(50));
 
     let events = vec![
         //TODO: fix sending shift keypress events on linux
-        //EventType::KeyPress(Key::ShiftLeft),
+        EventType::KeyPress(Key::ShiftLeft),
+        EventType::KeyRelease(Key::ShiftLeft),
         EventType::KeyPress(Key::KeyS),
         EventType::KeyRelease(Key::KeyS),
         EventType::ButtonPress(Button::Right),