Eager Gesture Recognizer (WIP)

ui/events/gestures/gesture_sequence.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef UI_EVENTS_GESTURES_GESTURE_SEQUENCE_H_
 #define UI_EVENTS_GESTURES_GESTURE_SEQUENCE_H_
 
 #include "base/timer/timer.h"
 #include "ui/events/event_constants.h"
+#include "ui/events/gestures/gesture_event_queue.h"
 #include "ui/events/gestures/gesture_point.h"
 #include "ui/events/gestures/gesture_recognizer.h"
 #include "ui/gfx/rect.h"
 
 namespace ui {
 class TouchEvent;
 class GestureEvent;
 
 // Gesture state.
 enum GestureState {
   GS_NO_GESTURE,
   GS_PENDING_SYNTHETIC_CLICK,
   GS_PENDING_SYNTHETIC_CLICK_NO_SCROLL,
   GS_SCROLL,
   GS_PINCH,
   GS_PENDING_TWO_FINGER_TAP,
   GS_PENDING_TWO_FINGER_TAP_NO_PINCH,
   GS_PENDING_PINCH,
   GS_PENDING_PINCH_NO_PINCH,
 };
 
 enum ScrollType {
   ST_FREE,
   ST_HORIZONTAL,
   ST_VERTICAL,
 };
 
-// Delegates dispatch of gesture events for which the GestureSequence does not
-// have enough context to dispatch itself.
-class EVENTS_EXPORT GestureSequenceDelegate {
- public:
-  virtual void DispatchPostponedGestureEvent(GestureEvent* event) = 0;
-
- protected:
-  virtual ~GestureSequenceDelegate() {}
-};
-
 // A GestureSequence recognizes gestures from touch sequences.
 class EVENTS_EXPORT GestureSequence {
  public:
   // Maximum number of points in a single gesture.
   static const int kMaxGesturePoints = 12;
 
-  explicit GestureSequence(GestureSequenceDelegate* delegate);
+  explicit GestureSequence(GestureEventQueueTimerInterface* geq_timers);
   virtual ~GestureSequence();
 
   typedef GestureRecognizer::Gestures Gestures;
 
   // Invoked for each touch event that could contribute to the current gesture.
   // Returns list of  zero or more GestureEvents identified after processing
   // TouchEvent.
   // Caller would be responsible for freeing up Gestures.
-  virtual Gestures* ProcessTouchEventForGesture(const TouchEvent& event,
-                                                EventResult status);
+  virtual Gestures* ProcessTouchEventForGesture(const TouchEvent& event);
   const GesturePoint* points() const { return points_; }
   int point_count() const { return point_count_; }
 
   const gfx::Point& last_touch_location() const { return last_touch_location_; }
 
  protected:
-  virtual base::OneShotTimer<GestureSequence>* CreateTimer();
-  base::OneShotTimer<GestureSequence>* GetLongPressTimer();
-  base::OneShotTimer<GestureSequence>* GetShowPressTimer();
+  virtual base::OneShotTimer<GestureEventQueueTimerInterface>* CreateTimer();
+  base::OneShotTimer<GestureEventQueueTimerInterface>* GetLongPressTimer();
+  base::OneShotTimer<GestureEventQueueTimerInterface>* GetShowPressTimer();
 
  private:
   // Recreates the axis-aligned bounding box that contains all the touch-points
   // at their most recent position.
   void RecreateBoundingBox();
 
   void ResetVelocities();
 
   GesturePoint& GesturePointForEvent(const TouchEvent& event);
 
@@ skipping 18 matching lines @@
   void AppendTapDownGestureEvent(const GesturePoint& point, Gestures* gestures);
   void PrependTapCancelGestureEvent(const GesturePoint& point,
                                    Gestures* gestures);
   void AppendBeginGestureEvent(const GesturePoint& point, Gestures* gestures);
   void AppendEndGestureEvent(const GesturePoint& point, Gestures* gestures);
   void AppendClickGestureEvent(const GesturePoint& point,
                                int tap_count,
                                Gestures* gestures);
   void AppendDoubleClickGestureEvent(const GesturePoint& point,
                                      Gestures* gestures);
-  void AppendLongPressGestureEvent();
-  void AppendShowPressGestureEvent();
+  void AppendLongPressGestureEvent(const GesturePoint& point,
+                                   Gestures* gestures);
+  void AppendShowPressGestureEvent(const GesturePoint& point,
+                                   Gestures* gestures);
   void AppendLongTapGestureEvent(const GesturePoint& point,
                                  Gestures* gestures);
 
   // Scroll gestures.
   void AppendScrollGestureBegin(const GesturePoint& point,
                                 const gfx::Point& location,
                                 Gestures* gestures);
   void AppendScrollGestureEnd(const GesturePoint& point,
                               const gfx::Point& location,
                               Gestures* gestures,
@@ skipping 96 matching lines @@
   float pinch_distance_start_;
 
   // This distance is updated after each PINCH_UPDATE.
   float pinch_distance_current_;
 
   // This is the time when second touch down was received. Used for determining
   // if a two finger double tap has happened.
   base::TimeDelta second_touch_time_;
 
   ScrollType scroll_type_;
-  scoped_ptr<base::OneShotTimer<GestureSequence> > long_press_timer_;
-  scoped_ptr<base::OneShotTimer<GestureSequence> > show_press_timer_;
+  scoped_ptr<base::OneShotTimer<GestureEventQueueTimerInterface> >
+      long_press_timer_;
+  scoped_ptr<base::OneShotTimer<GestureEventQueueTimerInterface> >
+      show_press_timer_;
 
   GesturePoint points_[kMaxGesturePoints];
   int point_count_;
 
   // Location of the last touch event.
   gfx::Point last_touch_location_;
 
-  GestureSequenceDelegate* delegate_;
+  GestureEventQueueTimerInterface* geq_timers_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureSequence);
 };
 
 }  // namespace ui
 
 #endif  // UI_EVENTS_GESTURES_GESTURE_SEQUENCE_H_