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/web/web_sys/canvas.rs

@@ -12,7 +12,7 @@ use web_sys::{
 };
 
 use super::super::cursor::CursorHandler;
-use super::super::event::{DeviceId, FingerId};
+use super::super::event::DeviceId;
 use super::super::main_thread::MainThreadMarker;
 use super::super::WindowId;
 use super::animation_frame::AnimationFrameHandler;
@@ -20,10 +20,12 @@ use super::event_handle::EventListenerHandle;
 use super::intersection_handle::IntersectionObserverHandle;
 use super::media_query_handle::MediaQueryListHandle;
 use super::pointer::PointerHandler;
-use super::{event, fullscreen, ButtonsState, ResizeScaleHandle};
+use super::{event, fullscreen, ResizeScaleHandle};
 use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
 use crate::error::RequestError;
-use crate::event::{Force, MouseButton, MouseScrollDelta, SurfaceSizeWriter};
+use crate::event::{
+    ButtonSource, ElementState, MouseScrollDelta, PointerKind, PointerSource, SurfaceSizeWriter,
+};
 use crate::keyboard::{Key, KeyLocation, ModifiersState, PhysicalKey};
 use crate::platform_impl::Fullscreen;
 use crate::window::{WindowAttributes, WindowId as RootWindowId};
@@ -328,83 +330,62 @@ impl Canvas {
             }));
     }
 
-    pub fn on_cursor_leave<F>(&self, handler: F)
+    pub fn on_pointer_leave<F>(&self, handler: F)
     where
-        F: 'static + FnMut(ModifiersState, Option<Option<DeviceId>>),
+        F: 'static + FnMut(ModifiersState, Option<DeviceId>, PhysicalPosition<f64>, PointerKind),
     {
-        self.handlers.borrow_mut().pointer_handler.on_cursor_leave(&self.common, handler)
+        self.handlers.borrow_mut().pointer_handler.on_pointer_leave(&self.common, handler)
     }
 
-    pub fn on_cursor_enter<F>(&self, handler: F)
+    pub fn on_pointer_enter<F>(&self, handler: F)
     where
-        F: 'static + FnMut(ModifiersState, Option<Option<DeviceId>>),
+        F: 'static + FnMut(ModifiersState, Option<DeviceId>, PhysicalPosition<f64>, PointerKind),
     {
-        self.handlers.borrow_mut().pointer_handler.on_cursor_enter(&self.common, handler)
+        self.handlers.borrow_mut().pointer_handler.on_pointer_enter(&self.common, handler)
     }
 
-    pub fn on_mouse_release<M, T>(&self, mouse_handler: M, touch_handler: T)
+    pub fn on_pointer_release<C>(&self, handler: C)
     where
-        M: 'static + FnMut(ModifiersState, Option<DeviceId>, PhysicalPosition<f64>, MouseButton),
-        T: 'static
-            + FnMut(ModifiersState, Option<DeviceId>, FingerId, PhysicalPosition<f64>, Force),
+        C: 'static + FnMut(ModifiersState, Option<DeviceId>, PhysicalPosition<f64>, ButtonSource),
     {
-        self.handlers.borrow_mut().pointer_handler.on_mouse_release(
+        self.handlers.borrow_mut().pointer_handler.on_pointer_release(&self.common, handler)
+    }
+
+    pub fn on_pointer_press<C>(&self, handler: C)
+    where
+        C: 'static + FnMut(ModifiersState, Option<DeviceId>, PhysicalPosition<f64>, ButtonSource),
+    {
+        self.handlers.borrow_mut().pointer_handler.on_pointer_press(
             &self.common,
-            mouse_handler,
-            touch_handler,
-        )
-    }
-
-    pub fn on_mouse_press<M, T>(&self, mouse_handler: M, touch_handler: T)
-    where
-        M: 'static + FnMut(ModifiersState, Option<DeviceId>, PhysicalPosition<f64>, MouseButton),
-        T: 'static
-            + FnMut(ModifiersState, Option<DeviceId>, FingerId, PhysicalPosition<f64>, Force),
-    {
-        self.handlers.borrow_mut().pointer_handler.on_mouse_press(
-            &self.common,
-            mouse_handler,
-            touch_handler,
+            handler,
             Rc::clone(&self.prevent_default),
         )
     }
 
-    pub fn on_cursor_move<M, T, B>(&self, mouse_handler: M, touch_handler: T, button_handler: B)
+    pub fn on_pointer_move<C, B>(&self, cursor_handler: C, button_handler: B)
     where
-        M: 'static
-            + FnMut(ModifiersState, Option<DeviceId>, &mut dyn Iterator<Item = PhysicalPosition<f64>>),
-        T: 'static
+        C: 'static
             + FnMut(
-                ModifiersState,
                 Option<DeviceId>,
-                FingerId,
-                &mut dyn Iterator<Item = (PhysicalPosition<f64>, Force)>,
+                &mut dyn Iterator<Item = (ModifiersState, PhysicalPosition<f64>, PointerSource)>,
             ),
         B: 'static
             + FnMut(
                 ModifiersState,
                 Option<DeviceId>,
                 PhysicalPosition<f64>,
-                ButtonsState,
-                MouseButton,
+                ElementState,
+                ButtonSource,
             ),
     {
-        self.handlers.borrow_mut().pointer_handler.on_cursor_move(
+        self.handlers.borrow_mut().pointer_handler.on_pointer_move(
             &self.common,
-            mouse_handler,
-            touch_handler,
+            cursor_handler,
             button_handler,
             Rc::clone(&self.prevent_default),
         )
     }
 
-    pub fn on_touch_cancel<F>(&self, handler: F)
-    where
-        F: 'static + FnMut(Option<DeviceId>, FingerId, PhysicalPosition<f64>, Force),
-    {
-        self.handlers.borrow_mut().pointer_handler.on_touch_cancel(&self.common, handler)
-    }
-
     pub fn on_mouse_wheel<F>(&self, mut handler: F)
     where
         F: 'static + FnMut(MouseScrollDelta, ModifiersState),