Initial views touchui GestureRecognizer support

views/touchui/gesture_recognizer.h

Index: views/touchui/gesture_recognizer.h
diff --git a/views/touchui/gesture_recognizer.h b/views/touchui/gesture_recognizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..854978a6bc5cf152266a443260dc707ce066f71b
--- /dev/null
+++ b/views/touchui/gesture_recognizer.h
@@ -0,0 +1,155 @@
+// Copyright (c) 2011 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 VIEWS_TOUCHUI_GESTURE_RECOGNIZER_H_
+#define VIEWS_TOUCHUI_GESTURE_RECOGNIZER_H_
+#pragma once
+
+#include <map>
+#include <vector>
+
+#include "ui/gfx/point.h"
+#include "views/touchui/gesture_manager.h"
+#include "views/view.h"
+
+namespace ui {
+enum EventType;
+}
+
+namespace views {
+class GestureManager;
+class TouchEvent;
+class GestureEvent;
+
+// A GestureRecognizer recognizes gestures frome touch sequences.
+//
+class VIEWS_EXPORT GestureRecognizer : public GestureManager {
+ public:
+  // A GestureEvent wrapper for automatic memory management.
+  struct PassGestureEvent {
+    explicit PassGestureEvent(GestureEvent* event);
+    ~PassGestureEvent();
+
+    // Get the wrapper GestureEvent.
+    GestureEvent* GetGestureEvent() { return event_; }
+
+    // GestureEvent* instance.
+    GestureEvent* event_;
+  };
+
+  // Gesture state.
+  enum GestureState {
+    GS_NO_GESTURE,
+    GS_PENDING_SYNTHETIC_CLICK,
+    GS_SCROLL,
+  };
+
+  // Touch state.
+  enum TouchState {
+    TS_RELEASED,
+    TS_PRESSED,
+    TS_MOVED,
+    TS_STATIONARY,
+    TS_CANCELLED,
+    TS_UNKNOWN,
+  };
+
+  // List of GestureEvent*
+  typedef std::vector<PassGestureEvent> Gestures;
+  typedef bool (GestureRecognizer::*GestureTransitionFunction)(
+      const TouchEvent&, Gestures*);
+
+  GestureRecognizer();
+  virtual ~GestureRecognizer();
+
+  static GestureRecognizer* GetInstance();
+
+  // Overriden from GestureManager.
+  virtual bool ProcessTouchEventForGesture(const TouchEvent& event,
+                                           View* source,
+                                           ui::TouchStatus status) OVERRIDE;
+
+  // Clears the GestureRecognizer to it's initial state.

[rjkroege, 2011/11/01 18:42:22]

wrong its. though you probably copied it from me. :-)

[Gajen, 2011/11/02 12:59:35]

Didn't Get, do u mean its Return type "virtual" should be omitted..??

[rjkroege, 2011/11/04 17:19:28]

the word "it's" is incorrect grammatically. The word you want in the comment is
"its". This is a nit. :-)

[Gajen, 2011/11/08 08:11:44]

Done.

+  virtual void Reset();
+
+  // Accessor function.
+  GestureState GetState() { return state_; }
+
+ private:
+  // 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.
+  Gestures* StartGestureRecognitionProcess(const TouchEvent& event,
+                                           bool touch_handled);
+
+  // Get equivalent TouchState from EventType |type|
+  // This is required in order to fit TouchState in 3 bits of Signature.
+  static TouchState TouchEventTypeToTouchState(ui::EventType type);
+
+  // Create a 32 bit signature to identify GestureTransitionFunction.
+  static unsigned int Signature(GestureState state,
+                                unsigned int touch_id, ui::EventType type,
+                                bool touch_handled);
+
+  // Creates a map of Singnatures and corresponding GestureTransitionFunction.
+  void AddEdgeFunction(GestureState state,
+                       unsigned int touch_id,
+                       ui::EventType type,
+                       bool touch_handled,
+                       GestureTransitionFunction function);
+
+  // Various statistical functions to manipulate gestures.
+  bool IsInClickTimeWindow();
+  bool IsInSecondClickTimeWindow();
+  bool IsInsideManhattanSquare(const TouchEvent& event);
+  bool IsSecondClickInsideManhattanSquare(const TouchEvent& event);
+  bool IsOverMinFlickSpeed();
+
+  // Functions to be called to add GestureEvents, after succesful recognition.
+  void AppendTapDownGestureEvent(const TouchEvent& event, Gestures* gestures);
+  void AppendClickGestureEvent(const TouchEvent& event, Gestures* gestures);
+  void AppendDoubleClickGestureEvent(const TouchEvent& event,
+                                     Gestures* gestures);
+  void AppendScrollGestureBegin(const TouchEvent& event, Gestures* gestures);
+  void AppendScrollGestureEnd(const TouchEvent& event,
+                               Gestures* gestures,
+                               float x_velocity, float y_velocity);
+  void AppendScrollGestureUpdate(const TouchEvent& event, Gestures* gestures);
+
+  void UpdateValues(const TouchEvent& event);
+  void SetState(const GestureState state ) { state_ = state; }
+
+  // Various GestureTransitionFunctions for a signature.
+  // There is, 1:many mapping from GestureTransitionFunction to Signature
+  // But a Signature have only one GestureTransitionFunction.
+  bool Click(const TouchEvent& event, Gestures* gestures);
+  bool IsClickOrScroll(const TouchEvent& event, Gestures* gestures);
+  bool InScroll(const TouchEvent& event, Gestures* gestures);
+  bool NoGesture(const TouchEvent& event, Gestures* gestures);
+  bool TouchDown(const TouchEvent& event, Gestures* gestures);
+  bool ScrollEnd(const TouchEvent& event, Gestures* gestures);
+
+  typedef std::map<int, GestureTransitionFunction> GestureTransitionFunctionMap;
+  GestureTransitionFunctionMap edge_functions_;
+
+  gfx::Point first_touch_position_;
+
+  double first_touch_time_;
+  GestureState state_;
+
+  double last_touch_time_;
+  double last_click_time_;
+  gfx::Point last_click_position_;
+  gfx::Point last_touch_position_;
+  float x_velocity_;
+  float y_velocity_;
+  int flags_;
+
+  DISALLOW_COPY_AND_ASSIGN(GestureRecognizer);
+};
+
+}  // namespace views
+
+#endif  // VIEWS_TOUCHUI_GESTURE_RECOGNIZER_H_