api: overhaul pointer API

- Rename `CursorMoved` to `PointerMoved`.
- Rename `CursorEntered` to `PointerEntered`.
- Rename `CursorLeft` to `PointerLeft`.
- Rename `MouseInput` to `PointerButton`.
- Add `position` to every `PointerEvent`.
- Remove `Touch`, which is folded into the `Pointer*` events.
- New `PointerType` added to `PointerEntered` and `PointerLeft`,
  signifying which pointer type is the source of this event.
- New `PointerSource` added to `PointerMoved`, similar to `PointerType`
  but holding additional data.
- New `ButtonSource` added to `PointerButton`, similar to `PointerType`
  but holding pointer type specific buttons. Use
  `ButtonSource::mouse_button()` to easily normalize any pointer button
  type to a generic mouse button.
- In the same spirit rename `DeviceEvent::MouseMotion` to `PointerMotion`.
- Remove `Force::Calibrated::altitude_angle`.

Fixes #3833.
Fixes #883.
Fixes #336.

Co-authored-by: Kirill Chibisov <contact@kchibisov.com>

src/platform_impl/linux/wayland/seat/pointer/mod.rs

@@ -27,7 +27,7 @@ use sctk::seat::pointer::{
 use sctk::seat::SeatState;
 
 use crate::dpi::{LogicalPosition, PhysicalPosition};
-use crate::event::{ElementState, MouseButton, MouseScrollDelta, TouchPhase, WindowEvent};
+use crate::event::{ElementState, MouseButton, MouseScrollDelta, PointerSource, PointerKind, TouchPhase, WindowEvent};
 
 use crate::platform_impl::wayland::state::WinitState;
 use crate::platform_impl::wayland::{self, WindowId};
@@ -123,7 +123,11 @@ impl PointerHandler for WinitState {
                 // Regular events on the main surface.
                 PointerEventKind::Enter { .. } => {
                     self.events_sink.push_window_event(
-                        WindowEvent::CursorEntered { device_id: None },
+                        WindowEvent::PointerEntered {
+                            device_id: None,
+                            position,
+                            kind: PointerKind::Mouse,
+                        },
                         window_id,
                     );
 
@@ -131,11 +135,6 @@ impl PointerHandler for WinitState {
 
                     // Set the currently focused surface.
                     pointer.winit_data().inner.lock().unwrap().surface = Some(window_id);
-
-                    self.events_sink.push_window_event(
-                        WindowEvent::CursorMoved { device_id: None, position },
-                        window_id,
-                    );
                 },
                 PointerEventKind::Leave { .. } => {
                     window.pointer_left(Arc::downgrade(themed_pointer));
@@ -143,12 +142,22 @@ impl PointerHandler for WinitState {
                     // Remove the active surface.
                     pointer.winit_data().inner.lock().unwrap().surface = None;
 
-                    self.events_sink
-                        .push_window_event(WindowEvent::CursorLeft { device_id: None }, window_id);
+                    self.events_sink.push_window_event(
+                        WindowEvent::PointerLeft {
+                            device_id: None,
+                            position: Some(position),
+                            kind: PointerKind::Mouse,
+                        },
+                        window_id,
+                    );
                 },
                 PointerEventKind::Motion { .. } => {
                     self.events_sink.push_window_event(
-                        WindowEvent::CursorMoved { device_id: None, position },
+                        WindowEvent::PointerMoved {
+                            device_id: None,
+                            position,
+                            source: PointerSource::Mouse,
+                        },
                         window_id,
                     );
                 },
@@ -164,7 +173,12 @@ impl PointerHandler for WinitState {
                         ElementState::Released
                     };
                     self.events_sink.push_window_event(
-                        WindowEvent::MouseInput { device_id: None, state, button },
+                        WindowEvent::PointerButton {
+                            device_id: None,
+                            state,
+                            position,
+                            button: button.into(),
+                        },
                         window_id,
                     );
                 },

src/platform_impl/linux/wayland/seat/pointer/relative_pointer.rs

@@ -68,7 +68,7 @@ impl Dispatch<ZwpRelativePointerV1, GlobalData, WinitState> for RelativePointerS
         };
         state
             .events_sink
-            .push_device_event(DeviceEvent::MouseMotion { delta: (dx_unaccel, dy_unaccel) });
+            .push_device_event(DeviceEvent::PointerMotion { delta: (dx_unaccel, dy_unaccel) });
     }
 }
 

src/platform_impl/linux/wayland/seat/touch/mod.rs

@@ -8,7 +8,7 @@ use sctk::seat::touch::{TouchData, TouchHandler};
 use tracing::warn;
 
 use crate::dpi::LogicalPosition;
-use crate::event::{Touch, TouchPhase, WindowEvent};
+use crate::event::{ButtonSource, ElementState, PointerKind, PointerSource, WindowEvent};
 use crate::platform_impl::wayland::state::WinitState;
 use crate::platform_impl::wayland::{self, FingerId};
 
@@ -42,16 +42,25 @@ impl TouchHandler for WinitState {
         let location = LogicalPosition::<f64>::from(position);
         seat_state.touch_map.insert(id, TouchPoint { surface, location });
 
+        let position = location.to_physical(scale_factor);
+        let finger_id =
+            crate::event::FingerId(crate::platform_impl::FingerId::Wayland(FingerId(id)));
+
         self.events_sink.push_window_event(
-            WindowEvent::Touch(Touch {
+            WindowEvent::PointerEntered {
                 device_id: None,
-                phase: TouchPhase::Started,
-                location: location.to_physical(scale_factor),
-                force: None,
-                finger_id: crate::event::FingerId(crate::platform_impl::FingerId::Wayland(
-                    FingerId(id),
-                )),
-            }),
+                position,
+                kind: PointerKind::Touch(finger_id),
+            },
+            window_id,
+        );
+        self.events_sink.push_window_event(
+            WindowEvent::PointerButton {
+                device_id: None,
+                state: ElementState::Pressed,
+                position,
+                button: ButtonSource::Touch { finger_id, force: None },
+            },
             window_id,
         );
     }
@@ -85,16 +94,25 @@ impl TouchHandler for WinitState {
             None => return,
         };
 
+        let position = touch_point.location.to_physical(scale_factor);
+        let finger_id =
+            crate::event::FingerId(crate::platform_impl::FingerId::Wayland(FingerId(id)));
+
         self.events_sink.push_window_event(
-            WindowEvent::Touch(Touch {
+            WindowEvent::PointerButton {
                 device_id: None,
-                phase: TouchPhase::Ended,
-                location: touch_point.location.to_physical(scale_factor),
-                force: None,
-                finger_id: crate::event::FingerId(crate::platform_impl::FingerId::Wayland(
-                    FingerId(id),
-                )),
-            }),
+                state: ElementState::Released,
+                position,
+                button: ButtonSource::Touch { finger_id, force: None },
+            },
+            window_id,
+        );
+        self.events_sink.push_window_event(
+            WindowEvent::PointerLeft {
+                device_id: None,
+                position: Some(position),
+                kind: PointerKind::Touch(finger_id),
+            },
             window_id,
         );
     }
@@ -131,15 +149,16 @@ impl TouchHandler for WinitState {
         touch_point.location = LogicalPosition::<f64>::from(position);
 
         self.events_sink.push_window_event(
-            WindowEvent::Touch(Touch {
+            WindowEvent::PointerMoved {
                 device_id: None,
-                phase: TouchPhase::Moved,
-                location: touch_point.location.to_physical(scale_factor),
-                force: None,
-                finger_id: crate::event::FingerId(crate::platform_impl::FingerId::Wayland(
-                    FingerId(id),
-                )),
-            }),
+                position: touch_point.location.to_physical(scale_factor),
+                source: PointerSource::Touch {
+                    finger_id: crate::event::FingerId(crate::platform_impl::FingerId::Wayland(
+                        FingerId(id),
+                    )),
+                    force: None,
+                },
+            },
             window_id,
         );
     }
@@ -160,18 +179,16 @@ impl TouchHandler for WinitState {
                 None => return,
             };
 
-            let location = touch_point.location.to_physical(scale_factor);
+            let position = touch_point.location.to_physical(scale_factor);
 
             self.events_sink.push_window_event(
-                WindowEvent::Touch(Touch {
+                WindowEvent::PointerLeft {
                     device_id: None,
-                    phase: TouchPhase::Cancelled,
-                    location,
-                    force: None,
-                    finger_id: crate::event::FingerId(crate::platform_impl::FingerId::Wayland(
-                        FingerId(id),
+                    position: Some(position),
+                    kind: PointerKind::Touch(crate::event::FingerId(
+                        crate::platform_impl::FingerId::Wayland(FingerId(id)),
                     )),
-                }),
+                },
                 window_id,
             );
         }