Home | History | Annotate | Download | only in gesture_detection 
      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/gesture_touch_uma_histogram.h"
     14 #include "ui/events/gesture_detection/scale_gesture_detector.h"
     15 #include "ui/events/gesture_detection/snap_scroll_controller.h"
     16 #include "ui/gfx/display.h"
     17 
     18 namespace ui {
     19 
     20 class GESTURE_DETECTION_EXPORT GestureProviderClient {
     21  public:
     22   virtual ~GestureProviderClient() {}
     23   virtual void OnGestureEvent(const GestureEventData& gesture) = 0;
     24 };
     25 
     26 // Given a stream of |MotionEvent|'s, provides gesture detection and gesture
     27 // event dispatch.
     28 class GESTURE_DETECTION_EXPORT GestureProvider {
     29  public:
     30   struct GESTURE_DETECTION_EXPORT Config {
     31     Config();
     32     ~Config();
     33     gfx::Display display;
     34     GestureDetector::Config gesture_detector_config;
     35     ScaleGestureDetector::Config scale_gesture_detector_config;
     36 
     37     // If |disable_click_delay| is true and double-tap support is disabled,
     38     // there will be no delay before tap events. When double-tap support is
     39     // enabled, there will always be a delay before a tap event is fired, in
     40     // order to allow the double tap gesture to occur without firing any tap
     41     // events.
     42     bool disable_click_delay;
     43 
     44     // If |gesture_begin_end_types_enabled| is true, fire an ET_GESTURE_BEGIN
     45     // event for every added touch point, and an ET_GESTURE_END event for every
     46     // removed touch point. This requires one ACTION_CANCEL event to be sent per
     47     // touch point, which only occurs on Aura. Defaults to false.
     48     bool gesture_begin_end_types_enabled;
     49 
     50     // The min and max size (both length and width, in dips) of the generated
     51     // bounding box for all gesture types. This is useful for touch streams
     52     // that may report zero or unreasonably small or large touch sizes.
     53     // Note that these bounds are only applied for touch or unknown tool types;
     54     // mouse and stylus-derived gestures will not be affected.
     55     // Both values default to 0 (disabled).
     56     float min_gesture_bounds_length;
     57     float max_gesture_bounds_length;
     58   };
     59 
     60   GestureProvider(const Config& config, GestureProviderClient* client);
     61   ~GestureProvider();
     62 
     63   // Handle the incoming MotionEvent, returning false if the event could not
     64   // be handled.
     65   bool OnTouchEvent(const MotionEvent& event);
     66 
     67   // Update whether multi-touch pinch zoom is supported by the platform.
     68   void SetMultiTouchZoomSupportEnabled(bool enabled);
     69 
     70   // Update whether double-tap gestures are supported by the platform.
     71   void SetDoubleTapSupportForPlatformEnabled(bool enabled);
     72 
     73   // Update whether double-tap gesture detection should be suppressed, e.g.,
     74   // if the page scale is fixed or the page has a mobile viewport. This disables
     75   // the tap delay, allowing rapid and responsive single-tap gestures.
     76   void SetDoubleTapSupportForPageEnabled(bool enabled);
     77 
     78   // Whether a scroll gesture is in-progress.
     79   bool IsScrollInProgress() const;
     80 
     81   // Whether a pinch gesture is in-progress (i.e. a pinch update has been
     82   // forwarded and detection is still active).
     83   bool IsPinchInProgress() const;
     84 
     85   // Whether a double-tap gesture is in-progress (either double-tap or
     86   // double-tap drag zoom).
     87   bool IsDoubleTapInProgress() const;
     88 
     89   // May be NULL if there is no currently active touch sequence.
     90   const ui::MotionEvent* current_down_event() const {
     91     return current_down_event_.get();
     92   }
     93 
     94  private:
     95   bool CanHandle(const MotionEvent& event) const;
     96   void OnTouchEventHandlingBegin(const MotionEvent& event);
     97   void OnTouchEventHandlingEnd(const MotionEvent& event);
     98   void UpdateDoubleTapDetectionSupport();
     99 
    100   class GestureListenerImpl;
    101   scoped_ptr<GestureListenerImpl> gesture_listener_;
    102 
    103   scoped_ptr<MotionEvent> current_down_event_;
    104 
    105   // Logs information on touch and gesture events.
    106   GestureTouchUMAHistogram uma_histogram_;
    107 
    108   // Whether double-tap gesture detection is currently supported.
    109   bool double_tap_support_for_page_;
    110   bool double_tap_support_for_platform_;
    111 
    112   const bool gesture_begin_end_types_enabled_;
    113 };
    114 
    115 }  //  namespace ui
    116 
    117 #endif  // UI_EVENTS_GESTURE_DETECTION_GESTURE_PROVIDER_H_
    118