src/ui/events/gesture_detection/gesture_provider.h

   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:
  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. This requires one ACTION_CANCEL event to be sent per
  46     // touch point, which only occurs on Aura. Defaults to false.
  47     bool gesture_begin_end_types_enabled;
  48
  49     // The min and max size (both length and width, in dips) of the generated
  50     // bounding box for all gesture types. This is useful for touch streams
  51     // that may report zero or unreasonably small or large touch sizes.
  52     // Note that these bounds are only applied for touch or unknown tool types;
  53     // mouse and stylus-derived gestures will not be affected.
  54     // Both values default to 0 (disabled).
  55     float min_gesture_bounds_length;
  56     float max_gesture_bounds_length;
  57   };
  58
  59   GestureProvider(const Config& config, GestureProviderClient* client);
  60   ~GestureProvider();
  61
  62   // Handle the incoming MotionEvent, returning false if the event could not
  63   // be handled.
  64   bool OnTouchEvent(const MotionEvent& event);
  65
  66   // Update whether multi-touch pinch zoom is supported by the platform.
  67   void SetMultiTouchZoomSupportEnabled(bool enabled);
  68
  69   // Update whether double-tap gestures are supported by the platform.
  70   void SetDoubleTapSupportForPlatformEnabled(bool enabled);
  71
  72   // Update whether double-tap gesture detection should be suppressed, e.g.,
  73   // if the page scale is fixed or the page has a mobile viewport. This disables
  74   // the tap delay, allowing rapid and responsive single-tap gestures.
  75   void SetDoubleTapSupportForPageEnabled(bool enabled);
  76
  77   // Whether a scroll gesture is in-progress.
  78   bool IsScrollInProgress() const;
  79
  80   // Whether a pinch gesture is in-progress (i.e. a pinch update has been
  81   // forwarded and detection is still active).
  82   bool IsPinchInProgress() const;
  83
  84   // Whether a double-tap gesture is in-progress (either double-tap or
  85   // double-tap drag zoom).
  86   bool IsDoubleTapInProgress() const;
  87
  88   // May be NULL if there is no currently active touch sequence.
  89   const ui::MotionEvent* current_down_event() const {
  90     return current_down_event_.get();
  91   }
  92
  93  private:
  94   void InitGestureDetectors(const Config& config);
  95
  96   bool CanHandle(const MotionEvent& event) const;
  97
  98   void Fling(const MotionEvent& e, float velocity_x, float velocity_y);
  99   void Send(GestureEventData gesture);
 100   bool SendLongTapIfNecessary(const MotionEvent& event);
 101   void EndTouchScrollIfNecessary(const MotionEvent& event,
 102                                  bool send_scroll_end_event);
 103   void OnTouchEventHandlingBegin(const MotionEvent& event);
 104   void OnTouchEventHandlingEnd(const MotionEvent& event);
 105   void UpdateDoubleTapDetectionSupport();
 106
 107   GestureProviderClient* const client_;
 108
 109   class GestureListenerImpl;
 110   friend class GestureListenerImpl;
 111   scoped_ptr<GestureListenerImpl> gesture_listener_;
 112
 113   class ScaleGestureListenerImpl;
 114   friend class ScaleGestureListenerImpl;
 115   scoped_ptr<ScaleGestureListenerImpl> scale_gesture_listener_;
 116
 117   scoped_ptr<MotionEvent> current_down_event_;
 118
 119   // Whether the respective {SCROLL,PINCH}_BEGIN gestures have been terminated
 120   // with a {SCROLL,PINCH}_END.
 121   bool touch_scroll_in_progress_;
 122   bool pinch_in_progress_;
 123
 124   // Whether double-tap gesture detection is currently supported.
 125   bool double_tap_support_for_page_;
 126   bool double_tap_support_for_platform_;
 127
 128   // Keeps track of the current GESTURE_LONG_PRESS event. If a context menu is
 129   // opened after a GESTURE_LONG_PRESS, this is used to insert a
 130   // GESTURE_TAP_CANCEL for removing any ::active styling.
 131   base::TimeTicks current_longpress_time_;
 132
 133   const bool gesture_begin_end_types_enabled_;
 134
 135   const float min_gesture_bounds_length_;
 136   const float max_gesture_bounds_length_;
 137 };
 138
 139 }  //  namespace ui
 140
 141 #endif  // UI_EVENTS_GESTURE_DETECTION_GESTURE_PROVIDER_H_