Add relative motion pointer events.

Author: xorgy

ui-events-winit/src/lib.rs

@@ -38,21 +38,22 @@ pub use web_time::Instant;
 use ui_events::{
     keyboard::KeyboardEvent,
     pointer::{
-        PointerButtonEvent, PointerEvent, PointerId, PointerInfo, PointerScrollEvent, PointerState,
-        PointerType, PointerUpdate,
+        PointerButtonEvent, PointerEvent, PointerId, PointerInfo, PointerRelativeFrame,
+        PointerRelativeMotion, PointerScrollEvent, PointerState, PointerType, PointerUpdate,
     },
     ScrollDelta,
 };
 use winit::{
-    event::{ElementState, Force, MouseScrollDelta, Touch, TouchPhase, WindowEvent},
+    dpi::PhysicalPosition,
+    event::{DeviceEvent, ElementState, Force, MouseScrollDelta, Touch, TouchPhase, WindowEvent},
     keyboard::ModifiersState,
 };
 
 /// Manages stateful transformations of winit [`WindowEvent`].
 ///
 /// Store a single instance of this per window, then call [`WindowEventReducer::reduce`]
 /// on each [`WindowEvent`] for that window.
-/// Use the [`WindowEventTranslation`] value to receive [`PointerEvent`]s and [`KeyboardEvent`]s.
+/// Use the [`EventTranslation`] value to receive [`PointerEvent`]s and [`KeyboardEvent`]s.
 ///
 /// This handles:
 ///  - [`ModifiersChanged`][`WindowEvent::ModifiersChanged`]
@@ -78,7 +79,7 @@ pub struct WindowEventReducer {
 #[allow(clippy::cast_possible_truncation)]
 impl WindowEventReducer {
     /// Process a [`WindowEvent`].
-    pub fn reduce(&mut self, we: &WindowEvent) -> Option<WindowEventTranslation> {
+    pub fn reduce(&mut self, we: &WindowEvent) -> Option<EventTranslation> {
         const PRIMARY_MOUSE: PointerInfo = PointerInfo {
             pointer_id: Some(PointerId::PRIMARY),
             // TODO: Maybe transmute device.
@@ -98,19 +99,19 @@ impl WindowEventReducer {
                 self.primary_state.modifiers = keyboard::from_winit_modifier_state(self.modifiers);
                 None
             }
-            WindowEvent::KeyboardInput { event, .. } => Some(WindowEventTranslation::Keyboard(
+            WindowEvent::KeyboardInput { event, .. } => Some(EventTranslation::Keyboard(
                 keyboard::from_winit_keyboard_event(event.clone(), self.modifiers),
             )),
-            WindowEvent::CursorEntered { .. } => Some(WindowEventTranslation::Pointer(
+            WindowEvent::CursorEntered { .. } => Some(EventTranslation::Pointer(
                 PointerEvent::Enter(PRIMARY_MOUSE),
             )),
-            WindowEvent::CursorLeft { .. } => Some(WindowEventTranslation::Pointer(
-                PointerEvent::Leave(PRIMARY_MOUSE),
-            )),
+            WindowEvent::CursorLeft { .. } => Some(EventTranslation::Pointer(PointerEvent::Leave(
+                PRIMARY_MOUSE,
+            ))),
             WindowEvent::CursorMoved { position, .. } => {
                 self.primary_state.position = *position;
 
-                Some(WindowEventTranslation::Pointer(self.counter.attach_count(
+                Some(EventTranslation::Pointer(self.counter.attach_count(
                     PointerEvent::Move(PointerUpdate {
                         pointer: PRIMARY_MOUSE,
                         current: self.primary_state.clone(),
@@ -129,7 +130,7 @@ impl WindowEventReducer {
                     self.primary_state.buttons.insert(button);
                 }
 
-                Some(WindowEventTranslation::Pointer(self.counter.attach_count(
+                Some(EventTranslation::Pointer(self.counter.attach_count(
                     PointerEvent::Down(PointerButtonEvent {
                         pointer: PRIMARY_MOUSE,
                         button,
@@ -147,15 +148,15 @@ impl WindowEventReducer {
                     self.primary_state.buttons.remove(button);
                 }
 
-                Some(WindowEventTranslation::Pointer(self.counter.attach_count(
+                Some(EventTranslation::Pointer(self.counter.attach_count(
                     PointerEvent::Up(PointerButtonEvent {
                         pointer: PRIMARY_MOUSE,
                         button,
                         state: self.primary_state.clone(),
                     }),
                 )))
             }
-            WindowEvent::MouseWheel { delta, .. } => Some(WindowEventTranslation::Pointer(
+            WindowEvent::MouseWheel { delta, .. } => Some(EventTranslation::Pointer(
                 PointerEvent::Scroll(PointerScrollEvent {
                     pointer: PRIMARY_MOUSE,
                     delta: match *delta {
@@ -196,7 +197,7 @@ impl WindowEventReducer {
                     ..Default::default()
                 };
 
-                Some(WindowEventTranslation::Pointer(self.counter.attach_count(
+                Some(EventTranslation::Pointer(self.counter.attach_count(
                     match phase {
                         Started => PointerEvent::Down(PointerButtonEvent {
                             pointer,
@@ -221,11 +222,48 @@ impl WindowEventReducer {
             _ => None,
         }
     }
+
+    /// Process a [`DeviceEvent`].
+    pub fn reduce_device_event(&mut self, de: &DeviceEvent) -> Option<EventTranslation> {
+        match de {
+            DeviceEvent::MouseMotion { delta: (x, y) } => {
+                const PRIMARY_MOUSE: PointerInfo = PointerInfo {
+                    pointer_id: Some(PointerId::PRIMARY),
+                    persistent_device_id: None,
+                    pointer_type: PointerType::Mouse,
+                };
+
+                let time = Instant::now()
+                    .duration_since(*self.first_instant.get_or_insert_with(Instant::now))
+                    .as_nanos() as u64;
+
+                self.primary_state.time = time;
+
+                let frame = PointerRelativeFrame {
+                    time,
+                    distance: PhysicalPosition { x: *x, y: *y },
+                    buttons: self.primary_state.buttons,
+                    modifiers: self.primary_state.modifiers,
+                    count: 0,
+                };
+
+                Some(EventTranslation::Pointer(PointerEvent::RelativeMotion(
+                    PointerRelativeMotion {
+                        pointer: PRIMARY_MOUSE,
+                        total: frame.clone(),
+                        frames: vec![frame],
+                        predicted: vec![],
+                    },
+                )))
+            }
+            _ => None,
+        }
+    }
 }
 
 /// Result of [`WindowEventReducer::reduce`].
 #[derive(Debug)]
-pub enum WindowEventTranslation {
+pub enum EventTranslation {
     /// Resulting [`KeyboardEvent`].
     Keyboard(KeyboardEvent),
     /// Resulting [`PointerEvent`].
@@ -345,6 +383,49 @@ impl TapCounter {
                     })
                 }
             }
+            PointerEvent::RelativeMotion(PointerRelativeMotion {
+                pointer,
+                mut total,
+                mut frames,
+                mut predicted,
+            }) => {
+                if let Some(TapState { count, .. }) = self
+                    .taps
+                    .iter()
+                    .find(
+                        |TapState {
+                             pointer_id,
+                             down_time,
+                             up_time,
+                             ..
+                         }| {
+                            *pointer_id == pointer.pointer_id && down_time == up_time
+                        },
+                    )
+                    .cloned()
+                {
+                    total.count = count;
+                    for event in frames.iter_mut() {
+                        event.count = count;
+                    }
+                    for event in predicted.iter_mut() {
+                        event.count = count;
+                    }
+                    PointerEvent::RelativeMotion(PointerRelativeMotion {
+                        pointer,
+                        total,
+                        frames,
+                        predicted,
+                    })
+                } else {
+                    PointerEvent::RelativeMotion(PointerRelativeMotion {
+                        pointer,
+                        total,
+                        frames,
+                        predicted,
+                    })
+                }
+            }
             PointerEvent::Cancel(p) => {
                 self.taps
                     .retain(|TapState { pointer_id, .. }| *pointer_id != p.pointer_id);

ui-events/src/pointer/mod.rs

@@ -185,6 +185,28 @@ impl Default for PointerState {
     }
 }
 
+/// A relative pointer motion frame.
+///
+/// This is generally only applicable to a mouse or similar device,
+/// so touch/pen specific fields are excluded.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct PointerRelativeFrame {
+    /// `u64` nanoseconds real time.
+    ///
+    /// The base time is not important, except by convention, and should
+    /// generally be the same at least for states originating from the
+    /// same device.
+    pub time: u64,
+    /// Distance traveled from the previous state.
+    pub distance: PhysicalPosition<f64>,
+    /// Pressed buttons.
+    pub buttons: PointerButtons,
+    /// Modifiers state.
+    pub modifiers: Modifiers,
+    /// Click or tap count associated with the pointer.
+    pub count: u8,
+}
+
 /// A pointer update, along with coalesced and predicted states.
 #[derive(Clone, Debug, PartialEq)]
 pub struct PointerUpdate {
@@ -214,6 +236,40 @@ impl PointerUpdate {
     }
 }
 
+/// A relative pointer motion update.
+#[derive(Clone, Debug, PartialEq)]
+pub struct PointerRelativeMotion {
+    /// Identifying information about pointer.
+    pub pointer: PointerInfo,
+    /// Cumulative motion over the frames.
+    ///
+    /// The timestamp is for the last integrated frame.
+    pub total: PointerRelativeFrame,
+    /// All integrated frames in this motion update.
+    ///
+    /// These primarily come from event coalescing.
+    /// Coalescing is application-specific.
+    /// On the web, the browser does its own coalescing, whereas
+    /// on other platforms you may do your own, or forego it
+    /// altogether, delivering every frame.
+    ///
+    /// This includes the most recent frame.
+    pub frames: Vec<PointerRelativeFrame>,
+    /// Predicted frames, ordered by `time`.
+    ///
+    /// Some platforms provide predicted frames directly,
+    /// and you may choose to add your own predictor.
+    pub predicted: Vec<PointerRelativeFrame>,
+}
+
+impl PointerRelativeMotion {
+    /// Returns `true` if this is the primary pointer.
+    #[inline(always)]
+    pub fn is_primary_pointer(&self) -> bool {
+        self.pointer.is_primary_pointer()
+    }
+}
+
 /// An event representing a [`PointerButton`] that was pressed or released.
 #[derive(Clone, Debug)]
 pub struct PointerButtonEvent {
@@ -250,6 +306,10 @@ pub enum PointerEvent {
     Up(PointerButtonEvent),
     /// Pointer moved.
     Move(PointerUpdate),
+    /// Pointer device moved but pointer position did not.
+    ///
+    /// This is usually during a locking or confining grab.
+    RelativeMotion(PointerRelativeMotion),
     /// Pointer motion was cancelled.
     ///
     /// Usually this is a touch which was taken over somewhere else.
@@ -273,6 +333,7 @@ impl PointerEvent {
             Self::Down(PointerButtonEvent { pointer, .. })
             | Self::Up(PointerButtonEvent { pointer, .. })
             | Self::Move(PointerUpdate { pointer, .. })
+            | Self::RelativeMotion(PointerRelativeMotion { pointer, .. })
             | Self::Cancel(pointer)
             | Self::Enter(pointer)
             | Self::Leave(pointer)