1 // Copyright 2014 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef UI_EVENTS_GESTURE_DETECTION_GESTURE_PROVIDER_H_ 6 #define UI_EVENTS_GESTURE_DETECTION_GESTURE_PROVIDER_H_ 7 8 #include "base/basictypes.h" 9 #include "base/memory/scoped_ptr.h" 10 #include "ui/events/gesture_detection/gesture_detection_export.h" 11 #include "ui/events/gesture_detection/gesture_detector.h" 12 #include "ui/events/gesture_detection/gesture_event_data.h" 13 #include "ui/events/gesture_detection/scale_gesture_detector.h" 14 #include "ui/events/gesture_detection/snap_scroll_controller.h" 15 #include "ui/gfx/display.h" 16 17 namespace ui { 18 19 class GESTURE_DETECTION_EXPORT GestureProviderClient { 20 public: ~GestureProviderClient()21 virtual ~GestureProviderClient() {} 22 virtual void OnGestureEvent(const GestureEventData& gesture) = 0; 23 }; 24 25 // Given a stream of |MotionEvent|'s, provides gesture detection and gesture 26 // event dispatch. 27 class GESTURE_DETECTION_EXPORT GestureProvider { 28 public: 29 struct GESTURE_DETECTION_EXPORT Config { 30 Config(); 31 ~Config(); 32 gfx::Display display; 33 GestureDetector::Config gesture_detector_config; 34 ScaleGestureDetector::Config scale_gesture_detector_config; 35 36 // If |disable_click_delay| is true and double-tap support is disabled, 37 // there will be no delay before tap events. When double-tap support is 38 // enabled, there will always be a delay before a tap event is fired, in 39 // order to allow the double tap gesture to occur without firing any tap 40 // events. 41 bool disable_click_delay; 42 43 // If |gesture_begin_end_types_enabled| is true, fire an ET_GESTURE_BEGIN 44 // event for every added touch point, and an ET_GESTURE_END event for every 45 // removed touch point. Defaults to false. 46 bool gesture_begin_end_types_enabled; 47 48 // The minimum size (both length and width, in dips) of the generated 49 // bounding box for all gesture types. This is useful for touch streams 50 // that may report zero or unreasonably small touch sizes. 51 // Defaults to 0. 52 float min_gesture_bounds_length; 53 }; 54 55 GestureProvider(const Config& config, GestureProviderClient* client); 56 ~GestureProvider(); 57 58 // Handle the incoming MotionEvent, returning false if the event could not 59 // be handled. 60 bool OnTouchEvent(const MotionEvent& event); 61 62 // Update whether multi-touch pinch zoom is supported by the platform. 63 void SetMultiTouchZoomSupportEnabled(bool enabled); 64 65 // Update whether double-tap gestures are supported by the platform. 66 void SetDoubleTapSupportForPlatformEnabled(bool enabled); 67 68 // Update whether double-tap gesture detection should be suppressed, e.g., 69 // if the page scale is fixed or the page has a mobile viewport. This disables 70 // the tap delay, allowing rapid and responsive single-tap gestures. 71 void SetDoubleTapSupportForPageEnabled(bool enabled); 72 73 // Whether a scroll gesture is in-progress. 74 bool IsScrollInProgress() const; 75 76 // Whether a pinch gesture is in-progress (i.e. a pinch update has been 77 // forwarded and detection is still active). 78 bool IsPinchInProgress() const; 79 80 // Whether a double-tap gesture is in-progress (either double-tap or 81 // double-tap drag zoom). 82 bool IsDoubleTapInProgress() const; 83 84 // May be NULL if there is no currently active touch sequence. current_down_event()85 const ui::MotionEvent* current_down_event() const { 86 return current_down_event_.get(); 87 } 88 89 private: 90 void InitGestureDetectors(const Config& config); 91 92 bool CanHandle(const MotionEvent& event) const; 93 94 void Fling(const MotionEvent& e, float velocity_x, float velocity_y); 95 void Send(GestureEventData gesture); 96 bool SendLongTapIfNecessary(const MotionEvent& event); 97 void EndTouchScrollIfNecessary(const MotionEvent& event, 98 bool send_scroll_end_event); 99 void OnTouchEventHandlingBegin(const MotionEvent& event); 100 void OnTouchEventHandlingEnd(const MotionEvent& event); 101 void UpdateDoubleTapDetectionSupport(); 102 103 GestureProviderClient* const client_; 104 105 class GestureListenerImpl; 106 friend class GestureListenerImpl; 107 scoped_ptr<GestureListenerImpl> gesture_listener_; 108 109 class ScaleGestureListenerImpl; 110 friend class ScaleGestureListenerImpl; 111 scoped_ptr<ScaleGestureListenerImpl> scale_gesture_listener_; 112 113 scoped_ptr<MotionEvent> current_down_event_; 114 115 // Whether the respective {SCROLL,PINCH}_BEGIN gestures have been terminated 116 // with a {SCROLL,PINCH}_END. 117 bool touch_scroll_in_progress_; 118 bool pinch_in_progress_; 119 120 // Whether double-tap gesture detection is currently supported. 121 bool double_tap_support_for_page_; 122 bool double_tap_support_for_platform_; 123 124 // Keeps track of the current GESTURE_LONG_PRESS event. If a context menu is 125 // opened after a GESTURE_LONG_PRESS, this is used to insert a 126 // GESTURE_TAP_CANCEL for removing any ::active styling. 127 base::TimeTicks current_longpress_time_; 128 129 const bool gesture_begin_end_types_enabled_; 130 131 const float min_gesture_bounds_length_; 132 }; 133 134 } // namespace ui 135 136 #endif // UI_EVENTS_GESTURE_DETECTION_GESTURE_PROVIDER_H_ 137