From fd477986dedd8836f7082cacaac0b6cd2af14b3c Mon Sep 17 00:00:00 2001 From: Joshua Pedrick Date: Sat, 27 Apr 2024 09:55:04 -0400 Subject: [PATCH] Add UIGestureRecognizerDelegate and PanGestureRecogniser (#3597) - Allow all gestures simultaneously recognized. - Add PanGestureRecogniser with min/max number of touches. - Fix sending delta values relative to Update instead to match macOS. - Fix rotation gesture units from iOS to be in degrees instead of radians. Co-authored-by: Mads Marquart --- examples/window.rs | 9 + src/changelog/unreleased.md | 3 +- src/event.rs | 26 ++- src/platform/ios.rs | 31 ++++ .../ios/uikit/gesture_recognizer.rs | 71 +++++++- src/platform_impl/ios/uikit/mod.rs | 5 +- src/platform_impl/ios/view.rs | 162 +++++++++++++++--- src/platform_impl/ios/window.rs | 13 ++ 8 files changed, 289 insertions(+), 31 deletions(-) diff --git a/examples/window.rs b/examples/window.rs index 83a31e1346..3a4bd61519 100644 --- a/examples/window.rs +++ b/examples/window.rs @@ -159,6 +159,7 @@ impl Application { window.recognize_doubletap_gesture(true); window.recognize_pinch_gesture(true); window.recognize_rotation_gesture(true); + window.recognize_pan_gesture(true, 2, 2); } let window_state = WindowState::new(self, window)?; @@ -428,6 +429,11 @@ impl ApplicationHandler for Application { info!("Rotated clockwise {delta:.5} (now: {rotated:.5})"); } }, + WindowEvent::PanGesture { delta, phase, .. } => { + window.panned.x += delta.x; + window.panned.y += delta.y; + info!("Panned ({delta:?})) (now: {:?}), {phase:?}", window.panned); + }, WindowEvent::DoubleTapGesture { .. } => { info!("Smart zoom"); }, @@ -502,6 +508,8 @@ struct WindowState { zoom: f64, /// The amount of rotation of the window. rotated: f32, + /// The amount of pan of the window. + panned: PhysicalPosition, #[cfg(macos_platform)] option_as_alt: OptionAsAlt, @@ -547,6 +555,7 @@ impl WindowState { modifiers: Default::default(), occluded: Default::default(), rotated: Default::default(), + panned: Default::default(), zoom: Default::default(), }; diff --git a/src/changelog/unreleased.md b/src/changelog/unreleased.md index 7607dfdcb8..c3b5b281b9 100644 --- a/src/changelog/unreleased.md +++ b/src/changelog/unreleased.md @@ -59,7 +59,8 @@ changelog entry. - Add `CustomCursor` which could be set via `Window::set_cursor`, implemented on Windows, macOS, X11, Wayland, and Web. - On Web, add to toggle calling `Event.preventDefault()` on `Window`. -- On iOS, add `PinchGesture`, `DoubleTapGesture`, and `RotationGesture` +- On iOS, add `PinchGesture`, `DoubleTapGesture`, `PanGesture` and `RotationGesture`. +- on iOS, use `UIGestureRecognizerDelegate` for fine grained control of gesture recognizers. - On macOS, add services menu. - On Windows, add `with_title_text_color`, and `with_corner_preference` on `WindowAttributesExtWindows`. diff --git a/src/event.rs b/src/event.rs index c8ce291003..5cd3877a26 100644 --- a/src/event.rs +++ b/src/event.rs @@ -293,6 +293,19 @@ pub enum WindowEvent { phase: TouchPhase, }, + /// N-finger pan gesture + /// + /// ## Platform-specific + /// + /// - Only available on **iOS**. + /// - On iOS, not recognized by default. It must be enabled when needed. + PanGesture { + device_id: DeviceId, + /// Change in pixels of pan gesture from last update. + delta: PhysicalPosition, + phase: TouchPhase, + }, + /// Double tap gesture. /// /// On a Mac, smart magnification is triggered by a double tap with two fingers @@ -322,7 +335,12 @@ pub enum WindowEvent { /// /// - Only available on **macOS** and **iOS**. /// - On iOS, not recognized by default. It must be enabled when needed. - RotationGesture { device_id: DeviceId, delta: f32, phase: TouchPhase }, + RotationGesture { + device_id: DeviceId, + /// change in rotation in degrees + delta: f32, + phase: TouchPhase, + }, /// Touchpad pressure event. /// @@ -993,6 +1011,7 @@ impl PartialEq for InnerSizeWriter { #[cfg(test)] mod tests { + use crate::dpi::PhysicalPosition; use crate::event; use std::collections::{BTreeSet, HashSet}; @@ -1055,6 +1074,11 @@ mod tests { delta: 0.0, phase: event::TouchPhase::Started, }); + with_window_event(PanGesture { + device_id: did, + delta: PhysicalPosition::::new(0.0, 0.0), + phase: event::TouchPhase::Started, + }); with_window_event(TouchpadPressure { device_id: did, pressure: 0.0, stage: 0 }); with_window_event(AxisMotion { device_id: did, axis: 0, value: 0.0 }); with_window_event(Touch(event::Touch { diff --git a/src/platform/ios.rs b/src/platform/ios.rs index 500cf3db19..daba5827ba 100644 --- a/src/platform/ios.rs +++ b/src/platform/ios.rs @@ -155,6 +155,21 @@ pub trait WindowExtIOS { /// The default is to not recognize gestures. fn recognize_pinch_gesture(&self, should_recognize: bool); + /// Sets whether the [`Window`] should recognize pan gestures. + /// + /// The default is to not recognize gestures. + /// Installs [`UIPanGestureRecognizer`](https://developer.apple.com/documentation/uikit/uipangesturerecognizer) onto view + /// + /// Set the minimum number of touches required: [`minimumNumberOfTouches`](https://developer.apple.com/documentation/uikit/uipangesturerecognizer/1621208-minimumnumberoftouches) + /// + /// Set the maximum number of touches recognized: [`maximumNumberOfTouches`](https://developer.apple.com/documentation/uikit/uipangesturerecognizer/1621208-maximumnumberoftouches) + fn recognize_pan_gesture( + &self, + should_recognize: bool, + minimum_number_of_touches: u8, + maximum_number_of_touches: u8, + ); + /// Sets whether the [`Window`] should recognize double tap gestures. /// /// The default is to not recognize gestures. @@ -204,6 +219,22 @@ impl WindowExtIOS for Window { self.window.maybe_queue_on_main(move |w| w.recognize_pinch_gesture(should_recognize)); } + #[inline] + fn recognize_pan_gesture( + &self, + should_recognize: bool, + minimum_number_of_touches: u8, + maximum_number_of_touches: u8, + ) { + self.window.maybe_queue_on_main(move |w| { + w.recognize_pan_gesture( + should_recognize, + minimum_number_of_touches, + maximum_number_of_touches, + ) + }); + } + #[inline] fn recognize_doubletap_gesture(&self, should_recognize: bool) { self.window.maybe_queue_on_main(move |w| w.recognize_doubletap_gesture(should_recognize)); diff --git a/src/platform_impl/ios/uikit/gesture_recognizer.rs b/src/platform_impl/ios/uikit/gesture_recognizer.rs index 9092471a3c..ab5e7a329d 100644 --- a/src/platform_impl/ios/uikit/gesture_recognizer.rs +++ b/src/platform_impl/ios/uikit/gesture_recognizer.rs @@ -1,9 +1,13 @@ use objc2::encode::{Encode, Encoding}; -use objc2::{extern_class, extern_methods, mutability, ClassType}; -use objc2_foundation::{CGFloat, NSInteger, NSObject, NSUInteger}; +use objc2::rc::Id; +use objc2::runtime::ProtocolObject; +use objc2::{extern_class, extern_methods, extern_protocol, mutability, ClassType, ProtocolType}; +use objc2_foundation::{CGFloat, CGPoint, NSInteger, NSObject, NSObjectProtocol, NSUInteger}; + +use super::UIView; -// https://developer.apple.com/documentation/uikit/uigesturerecognizer extern_class!( + /// [`UIGestureRecognizer`](https://developer.apple.com/documentation/uikit/uigesturerecognizer) #[derive(Debug, PartialEq, Eq, Hash)] pub(crate) struct UIGestureRecognizer; @@ -17,6 +21,14 @@ extern_methods!( unsafe impl UIGestureRecognizer { #[method(state)] pub fn state(&self) -> UIGestureRecognizerState; + + /// [`delegate`](https://developer.apple.com/documentation/uikit/uigesturerecognizer/1624207-delegate?language=objc) + /// @property(nullable, nonatomic, weak) id delegate; + #[method(setDelegate:)] + pub fn setDelegate(&self, delegate: &ProtocolObject); + + #[method_id(delegate)] + pub fn delegate(&self) -> Id>; } ); @@ -24,7 +36,7 @@ unsafe impl Encode for UIGestureRecognizer { const ENCODING: Encoding = Encoding::Object; } -// https://developer.apple.com/documentation/uikit/uigesturerecognizer/state +// [`UIGestureRecognizerState`](https://developer.apple.com/documentation/uikit/uigesturerecognizer/state) #[repr(transparent)] #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct UIGestureRecognizerState(NSInteger); @@ -43,7 +55,7 @@ impl UIGestureRecognizerState { pub const Failed: Self = Self(5); } -// https://developer.apple.com/documentation/uikit/uipinchgesturerecognizer +// [`UIPinchGestureRecognizer`](https://developer.apple.com/documentation/uikit/uipinchgesturerecognizer) extern_class!( #[derive(Debug, PartialEq, Eq, Hash)] pub(crate) struct UIPinchGestureRecognizer; @@ -68,8 +80,8 @@ unsafe impl Encode for UIPinchGestureRecognizer { const ENCODING: Encoding = Encoding::Object; } -// https://developer.apple.com/documentation/uikit/uirotationgesturerecognizer extern_class!( + /// [`UIRotationGestureRecognizer`](https://developer.apple.com/documentation/uikit/uirotationgesturerecognizer) #[derive(Debug, PartialEq, Eq, Hash)] pub(crate) struct UIRotationGestureRecognizer; @@ -93,8 +105,8 @@ unsafe impl Encode for UIRotationGestureRecognizer { const ENCODING: Encoding = Encoding::Object; } -// https://developer.apple.com/documentation/uikit/uitapgesturerecognizer extern_class!( + /// [`UITapGestureRecognizer`](https://developer.apple.com/documentation/uikit/uitapgesturerecognizer) #[derive(Debug, PartialEq, Eq, Hash)] pub(crate) struct UITapGestureRecognizer; @@ -117,3 +129,48 @@ extern_methods!( unsafe impl Encode for UITapGestureRecognizer { const ENCODING: Encoding = Encoding::Object; } + +extern_class!( + /// [`UIPanGestureRecognizer`](https://developer.apple.com/documentation/uikit/uipangesturerecognizer) + #[derive(Debug, PartialEq, Eq, Hash)] + pub(crate) struct UIPanGestureRecognizer; + + unsafe impl ClassType for UIPanGestureRecognizer { + type Super = UIGestureRecognizer; + type Mutability = mutability::InteriorMutable; + } +); + +extern_methods!( + unsafe impl UIPanGestureRecognizer { + #[method(translationInView:)] + pub fn translationInView(&self, view: &UIView) -> CGPoint; + + #[method(setTranslation:inView:)] + pub fn setTranslationInView(&self, translation: CGPoint, view: &UIView); + + #[method(velocityInView:)] + pub fn velocityInView(&self, view: &UIView) -> CGPoint; + + #[method(setMinimumNumberOfTouches:)] + pub fn setMinimumNumberOfTouches(&self, minimum_number_of_touches: NSUInteger); + + #[method(minimumNumberOfTouches)] + pub fn minimumNumberOfTouches(&self) -> NSUInteger; + + #[method(setMaximumNumberOfTouches:)] + pub fn setMaximumNumberOfTouches(&self, maximum_number_of_touches: NSUInteger); + + #[method(maximumNumberOfTouches)] + pub fn maximumNumberOfTouches(&self) -> NSUInteger; + } +); + +extern_protocol!( + /// (@protocol UIGestureRecognizerDelegate)[https://developer.apple.com/documentation/uikit/uigesturerecognizerdelegate?language=objc] + pub(crate) unsafe trait UIGestureRecognizerDelegate: NSObjectProtocol {} + + unsafe impl ProtocolType for dyn UIGestureRecognizerDelegate { + const NAME: &'static str = "UIGestureRecognizerDelegate"; + } +); diff --git a/src/platform_impl/ios/uikit/mod.rs b/src/platform_impl/ios/uikit/mod.rs index 88d5a84656..c415cac018 100644 --- a/src/platform_impl/ios/uikit/mod.rs +++ b/src/platform_impl/ios/uikit/mod.rs @@ -27,8 +27,9 @@ pub(crate) use self::device::{UIDevice, UIUserInterfaceIdiom}; pub(crate) use self::event::UIEvent; pub(crate) use self::geometry::UIRectEdge; pub(crate) use self::gesture_recognizer::{ - UIGestureRecognizer, UIGestureRecognizerState, UIPinchGestureRecognizer, - UIRotationGestureRecognizer, UITapGestureRecognizer, + UIGestureRecognizer, UIGestureRecognizerDelegate, UIGestureRecognizerState, + UIPanGestureRecognizer, UIPinchGestureRecognizer, UIRotationGestureRecognizer, + UITapGestureRecognizer, }; pub(crate) use self::responder::UIResponder; pub(crate) use self::screen::{UIScreen, UIScreenOverscanCompensation}; diff --git a/src/platform_impl/ios/view.rs b/src/platform_impl/ios/view.rs index 8531a60d14..39316dd1a0 100644 --- a/src/platform_impl/ios/view.rs +++ b/src/platform_impl/ios/view.rs @@ -1,18 +1,19 @@ #![allow(clippy::unnecessary_cast)] -use std::cell::RefCell; +use std::cell::{Cell, RefCell}; use objc2::rc::Id; -use objc2::runtime::AnyClass; +use objc2::runtime::{AnyClass, NSObjectProtocol, ProtocolObject}; use objc2::{ declare_class, extern_methods, msg_send, msg_send_id, mutability, sel, ClassType, DeclaredClass, }; -use objc2_foundation::{CGFloat, CGRect, MainThreadMarker, NSObject, NSSet}; +use objc2_foundation::{CGFloat, CGPoint, CGRect, MainThreadMarker, NSObject, NSSet}; use super::app_state::{self, EventWrapper}; use super::uikit::{ - UIEvent, UIForceTouchCapability, UIGestureRecognizerState, UIPinchGestureRecognizer, - UIResponder, UIRotationGestureRecognizer, UITapGestureRecognizer, UITouch, UITouchPhase, - UITouchType, UITraitCollection, UIView, + UIEvent, UIForceTouchCapability, UIGestureRecognizer, UIGestureRecognizerDelegate, + UIGestureRecognizerState, UIPanGestureRecognizer, UIPinchGestureRecognizer, UIResponder, + UIRotationGestureRecognizer, UITapGestureRecognizer, UITouch, UITouchPhase, UITouchType, + UITraitCollection, UIView, }; use super::window::WinitUIWindow; use crate::dpi::PhysicalPosition; @@ -24,6 +25,12 @@ pub struct WinitViewState { pinch_gesture_recognizer: RefCell>>, doubletap_gesture_recognizer: RefCell>>, rotation_gesture_recognizer: RefCell>>, + pan_gesture_recognizer: RefCell>>, + + // for iOS delta references the start of the Gesture + rotation_last_delta: Cell, + pinch_last_delta: Cell, + pan_last_delta: Cell, } declare_class!( @@ -165,12 +172,23 @@ declare_class!( fn pinch_gesture(&self, recognizer: &UIPinchGestureRecognizer) { let window = self.window().unwrap(); - let phase = match recognizer.state() { - UIGestureRecognizerState::Began => TouchPhase::Started, - UIGestureRecognizerState::Changed => TouchPhase::Moved, - UIGestureRecognizerState::Ended => TouchPhase::Ended, + let (phase, delta) = match recognizer.state() { + UIGestureRecognizerState::Began => { + self.ivars().pinch_last_delta.set(recognizer.scale()); + (TouchPhase::Started, 0.0) + } + UIGestureRecognizerState::Changed => { + let last_scale: f64 = self.ivars().pinch_last_delta.replace(recognizer.scale()); + (TouchPhase::Moved, recognizer.scale() - last_scale) + } + UIGestureRecognizerState::Ended => { + let last_scale: f64 = self.ivars().pinch_last_delta.replace(0.0); + (TouchPhase::Moved, recognizer.scale() - last_scale) + } UIGestureRecognizerState::Cancelled | UIGestureRecognizerState::Failed => { - TouchPhase::Cancelled + self.ivars().rotation_last_delta.set(0.0); + // Pass -delta so that action is reversed + (TouchPhase::Cancelled, -recognizer.scale()) } state => panic!("unexpected recognizer state: {:?}", state), }; @@ -179,7 +197,7 @@ declare_class!( window_id: RootWindowId(window.id()), event: WindowEvent::PinchGesture { device_id: DEVICE_ID, - delta: recognizer.velocity() as _, + delta: delta as f64, phase, }, }); @@ -209,23 +227,88 @@ declare_class!( fn rotation_gesture(&self, recognizer: &UIRotationGestureRecognizer) { let window = self.window().unwrap(); - let phase = match recognizer.state() { - UIGestureRecognizerState::Began => TouchPhase::Started, - UIGestureRecognizerState::Changed => TouchPhase::Moved, - UIGestureRecognizerState::Ended => TouchPhase::Ended, + let (phase, delta) = match recognizer.state() { + UIGestureRecognizerState::Began => { + self.ivars().rotation_last_delta.set(0.0); + + (TouchPhase::Started, 0.0) + } + UIGestureRecognizerState::Changed => { + let last_rotation = self.ivars().rotation_last_delta.replace(recognizer.rotation()); + + (TouchPhase::Moved, recognizer.rotation() - last_rotation) + } + UIGestureRecognizerState::Ended => { + let last_rotation = self.ivars().rotation_last_delta.replace(0.0); + + (TouchPhase::Ended, recognizer.rotation() - last_rotation) + } UIGestureRecognizerState::Cancelled | UIGestureRecognizerState::Failed => { - TouchPhase::Cancelled + self.ivars().rotation_last_delta.set(0.0); + + // Pass -delta so that action is reversed + (TouchPhase::Cancelled, -recognizer.rotation()) } state => panic!("unexpected recognizer state: {:?}", state), }; - // Flip the velocity to match macOS. - let delta = -recognizer.velocity() as _; + // Make delta negative to match macos, convert to degrees let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent { window_id: RootWindowId(window.id()), event: WindowEvent::RotationGesture { device_id: DEVICE_ID, - delta, + delta: -delta.to_degrees() as _, + phase, + }, + }); + + let mtm = MainThreadMarker::new().unwrap(); + app_state::handle_nonuser_event(mtm, gesture_event); + } + + #[method(panGesture:)] + fn pan_gesture(&self, recognizer: &UIPanGestureRecognizer) { + let window = self.window().unwrap(); + + let translation = recognizer.translationInView(self); + + let (phase, dx, dy) = match recognizer.state() { + UIGestureRecognizerState::Began => { + self.ivars().pan_last_delta.set(translation); + + (TouchPhase::Started, 0.0, 0.0) + } + UIGestureRecognizerState::Changed => { + let last_pan: CGPoint = self.ivars().pan_last_delta.replace(translation); + + let dx = translation.x - last_pan.x; + let dy = translation.y - last_pan.y; + + (TouchPhase::Moved, dx, dy) + } + UIGestureRecognizerState::Ended => { + let last_pan: CGPoint = self.ivars().pan_last_delta.replace(CGPoint{x:0.0, y:0.0}); + + let dx = translation.x - last_pan.x; + let dy = translation.y - last_pan.y; + + (TouchPhase::Ended, dx, dy) + } + UIGestureRecognizerState::Cancelled | UIGestureRecognizerState::Failed => { + let last_pan: CGPoint = self.ivars().pan_last_delta.replace(CGPoint{x:0.0, y:0.0}); + + // Pass -delta so that action is reversed + (TouchPhase::Cancelled, -last_pan.x, -last_pan.y) + } + state => panic!("unexpected recognizer state: {:?}", state), + }; + + + let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent { + window_id: RootWindowId(window.id()), + event: WindowEvent::PanGesture { + device_id: DEVICE_ID, + delta: PhysicalPosition::new(dx as _, dy as _), phase, }, }); @@ -234,6 +317,15 @@ declare_class!( app_state::handle_nonuser_event(mtm, gesture_event); } } + + unsafe impl NSObjectProtocol for WinitView {} + + unsafe impl UIGestureRecognizerDelegate for WinitView { + #[method(gestureRecognizer:shouldRecognizeSimultaneouslyWithGestureRecognizer:)] + fn should_recognize_simultaneously(&self, _gesture_recognizer: &UIGestureRecognizer, _other_gesture_recognizer: &UIGestureRecognizer) -> bool { + true + } + } ); extern_methods!( @@ -263,6 +355,11 @@ impl WinitView { pinch_gesture_recognizer: RefCell::new(None), doubletap_gesture_recognizer: RefCell::new(None), rotation_gesture_recognizer: RefCell::new(None), + pan_gesture_recognizer: RefCell::new(None), + + rotation_last_delta: Cell::new(0.0), + pinch_last_delta: Cell::new(0.0), + pan_last_delta: Cell::new(CGPoint { x: 0.0, y: 0.0 }), }); let this: Id = unsafe { msg_send_id![super(this), initWithFrame: frame] }; @@ -281,6 +378,7 @@ impl WinitView { let pinch: Id = unsafe { msg_send_id![UIPinchGestureRecognizer::alloc(), initWithTarget: self, action: sel!(pinchGesture:)] }; + pinch.setDelegate(ProtocolObject::from_ref(self)); self.addGestureRecognizer(&pinch); self.ivars().pinch_gesture_recognizer.replace(Some(pinch)); } @@ -289,12 +387,35 @@ impl WinitView { } } + pub(crate) fn recognize_pan_gesture( + &self, + should_recognize: bool, + minimum_number_of_touches: u8, + maximum_number_of_touches: u8, + ) { + if should_recognize { + if self.ivars().pan_gesture_recognizer.borrow().is_none() { + let pan: Id = unsafe { + msg_send_id![UIPanGestureRecognizer::alloc(), initWithTarget: self, action: sel!(panGesture:)] + }; + pan.setDelegate(ProtocolObject::from_ref(self)); + pan.setMinimumNumberOfTouches(minimum_number_of_touches as _); + pan.setMaximumNumberOfTouches(maximum_number_of_touches as _); + self.addGestureRecognizer(&pan); + self.ivars().pan_gesture_recognizer.replace(Some(pan)); + } + } else if let Some(recognizer) = self.ivars().pan_gesture_recognizer.take() { + self.removeGestureRecognizer(&recognizer); + } + } + pub(crate) fn recognize_doubletap_gesture(&self, should_recognize: bool) { if should_recognize { if self.ivars().doubletap_gesture_recognizer.borrow().is_none() { let tap: Id = unsafe { msg_send_id![UITapGestureRecognizer::alloc(), initWithTarget: self, action: sel!(doubleTapGesture:)] }; + tap.setDelegate(ProtocolObject::from_ref(self)); tap.setNumberOfTapsRequired(2); tap.setNumberOfTouchesRequired(1); self.addGestureRecognizer(&tap); @@ -311,6 +432,7 @@ impl WinitView { let rotation: Id = unsafe { msg_send_id![UIRotationGestureRecognizer::alloc(), initWithTarget: self, action: sel!(rotationGesture:)] }; + rotation.setDelegate(ProtocolObject::from_ref(self)); self.addGestureRecognizer(&rotation); self.ivars().rotation_gesture_recognizer.replace(Some(rotation)); } diff --git a/src/platform_impl/ios/window.rs b/src/platform_impl/ios/window.rs index 1d9310daaa..4a4f975ce6 100644 --- a/src/platform_impl/ios/window.rs +++ b/src/platform_impl/ios/window.rs @@ -619,6 +619,19 @@ impl Inner { self.view.recognize_pinch_gesture(should_recognize); } + pub fn recognize_pan_gesture( + &self, + should_recognize: bool, + minimum_number_of_touches: u8, + maximum_number_of_touches: u8, + ) { + self.view.recognize_pan_gesture( + should_recognize, + minimum_number_of_touches, + maximum_number_of_touches, + ); + } + pub fn recognize_doubletap_gesture(&self, should_recognize: bool) { self.view.recognize_doubletap_gesture(should_recognize); }