Unified Gesture Recognizer

ui/events/gestures/motion_event_aura.cc

Index: ui/events/gestures/motion_event_aura.cc
diff --git a/ui/events/gestures/motion_event_aura.cc b/ui/events/gestures/motion_event_aura.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c19341ec1a40bbcd5d527c27a8e2addb6db3c54d
--- /dev/null
+++ b/ui/events/gestures/motion_event_aura.cc
@@ -0,0 +1,241 @@
+// Copyright 2014 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.
+
+#include "ui/events/gestures/motion_event_aura.h"
+
+#include "base/logging.h"
+#include "ui/events/gestures/gesture_configuration.h"
+
+namespace ui {
+
+MotionEventAura::MotionEventAura()
+    : pointer_count_(0), cached_action_index_(-1) {
+}
+
+MotionEventAura::MotionEventAura(
+    size_t pointer_count,
+    const base::TimeTicks& last_touch_time,
+    Action cached_action,
+    int cached_action_index,
+    const PointData (&active_touches)[GestureSequence::kMaxGesturePoints])
+    : pointer_count_(pointer_count),
+      last_touch_time_(last_touch_time),
+      cached_action_(cached_action),
+      cached_action_index_(cached_action_index) {
+  DCHECK(pointer_count_);
+  for (size_t i = 0; i < pointer_count; ++i)
+    active_touches_[i] = active_touches[i];
+}
+
+MotionEventAura::~MotionEventAura() {}
+
+MotionEventAura::PointData MotionEventAura::GetPointDataFromTouchEvent(
+    const TouchEvent& touch) {
+  PointData point_data;
+  point_data.x = touch.x();
+  point_data.y = touch.y();
+  point_data.touch_id = touch.touch_id();
+  point_data.pressure = touch.force();
+  point_data.source_device_id = touch.source_device_id();
+
+  // TODO(tdresser): at some point we should start using both radii if they are
+  // available, but for now we use the max.
+  point_data.major_radius = std::max(touch.radius_x(), touch.radius_y());
+  if (!point_data.major_radius)
+    point_data.major_radius = GestureConfiguration::default_radius();
+  return point_data;
+}
+
+void MotionEventAura::OnTouch(const TouchEvent& touch) {
+  switch (touch.type()) {
+    case ET_TOUCH_PRESSED:
+      AddTouch(touch);
+      break;
+    case ET_TOUCH_RELEASED:
+    case ET_TOUCH_CANCELLED:
+      // Removing these touch points needs to be postponed until after the
+      // MotionEvent has been dispatched. This cleanup occurs in
+      // CleanupRemovedTouchPoints.
+      UpdateTouch(touch);
+      break;
+    case ET_TOUCH_MOVED:
+      UpdateTouch(touch);
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+
+  UpdateCachedAction(touch);
+  last_touch_time_ = touch.time_stamp() + base::TimeTicks();
+}
+
+int MotionEventAura::GetId() const {
+  return GetPointerId(0);
+}
+
+MotionEvent::Action MotionEventAura::GetAction() const {
+  return cached_action_;
+}
+
+int MotionEventAura::GetActionIndex() const {
+  DCHECK(cached_action_ == ACTION_POINTER_DOWN ||
+         cached_action_ == ACTION_POINTER_UP);
+  DCHECK_GE(cached_action_index_, 0);
+  DCHECK_LE(cached_action_index_, static_cast<int>(pointer_count_));
+  return cached_action_index_;
+}
+
+size_t MotionEventAura::GetPointerCount() const { return pointer_count_; }
+
+int MotionEventAura::GetPointerId(size_t pointer_index) const {
+  DCHECK_LE(pointer_index, pointer_count_);
+  return active_touches_[pointer_index].touch_id;
+}
+
+float MotionEventAura::GetX(size_t pointer_index) const {
+  DCHECK_LE(pointer_index, pointer_count_);
+  return active_touches_[pointer_index].x;
+}
+
+float MotionEventAura::GetY(size_t pointer_index) const {
+  DCHECK_LE(pointer_index, pointer_count_);
+  return active_touches_[pointer_index].y;
+}
+
+float MotionEventAura::GetTouchMajor(size_t pointer_index) const {
+  DCHECK_LE(pointer_index, pointer_count_);
+  return active_touches_[pointer_index].major_radius * 2;
+}
+
+float MotionEventAura::GetPressure(size_t pointer_index) const {
+  DCHECK_LE(pointer_index, pointer_count_);
+  return active_touches_[pointer_index].pressure;
+}
+
+base::TimeTicks MotionEventAura::GetEventTime() const {
+  return last_touch_time_;
+}
+
+size_t MotionEventAura::GetHistorySize() const { return 0; }
+
+base::TimeTicks MotionEventAura::GetHistoricalEventTime(
+    size_t historical_index) const {
+  NOTIMPLEMENTED();
+  return base::TimeTicks();
+}
+
+float MotionEventAura::GetHistoricalTouchMajor(size_t pointer_index,
+                                             size_t historical_index) const {
+  NOTIMPLEMENTED();
+  return 0;
+}
+
+float MotionEventAura::GetHistoricalX(size_t pointer_index,
+                                    size_t historical_index) const {
+  NOTIMPLEMENTED();
+  return 0;
+}
+
+float MotionEventAura::GetHistoricalY(size_t pointer_index,
+                                    size_t historical_index) const {
+  NOTIMPLEMENTED();
+  return 0;
+}
+
+scoped_ptr<MotionEvent> MotionEventAura::Clone() const {
+  return scoped_ptr<MotionEvent>(new MotionEventAura(pointer_count_,
+                                                     last_touch_time_,
+                                                     cached_action_,
+                                                     cached_action_index_,
+                                                     active_touches_));
+}
+scoped_ptr<MotionEvent> MotionEventAura::Cancel() const {
+  return scoped_ptr<MotionEvent>(new MotionEventAura(
+      pointer_count_, last_touch_time_, ACTION_CANCEL, -1, active_touches_));
+}
+
+void MotionEventAura::CleanupRemovedTouchPoints(const TouchEvent& event) {
+  if (event.type() != ET_TOUCH_RELEASED &&
+      event.type() != ET_TOUCH_CANCELLED) {
+    return;
+  }
+
+  int index_to_delete = static_cast<int>(GetIndexFromId(event.touch_id()));
+  pointer_count_--;
+  active_touches_[index_to_delete] = active_touches_[pointer_count_];
+}
+
+MotionEventAura::PointData::PointData()
+    : x(0),
+      y(0),
+      touch_id(0),
+      pressure(0),
+      source_device_id(0),
+      major_radius(0) {
+}
+
+int MotionEventAura::GetSourceDeviceId(size_t pointer_index) const {
+  DCHECK_LE(pointer_index, pointer_count_);
+  return active_touches_[pointer_index].source_device_id;
+}
+
+void MotionEventAura::AddTouch(const TouchEvent& touch) {
+  if (pointer_count_ == static_cast<size_t>(GestureSequence::kMaxGesturePoints))
+    return;
+
+  active_touches_[pointer_count_] = GetPointDataFromTouchEvent(touch);
+  pointer_count_++;
+}
+
+
+void MotionEventAura::UpdateTouch(const TouchEvent& touch) {
+  active_touches_[GetIndexFromId(touch.touch_id())] =
+      GetPointDataFromTouchEvent(touch);
+}
+
+void MotionEventAura::UpdateCachedAction(const TouchEvent& touch) {
+  DCHECK(pointer_count_);
+  switch (touch.type()) {
+    case ET_TOUCH_PRESSED:
+      if (pointer_count_ == 1) {
+        cached_action_ = ACTION_DOWN;
+      } else {
+        cached_action_ = ACTION_POINTER_DOWN;
+        cached_action_index_ =
+            static_cast<int>(GetIndexFromId(touch.touch_id()));
+      }
+      break;
+    case ET_TOUCH_RELEASED:
+      if (pointer_count_ == 1) {
+        cached_action_ = ACTION_UP;
+      } else {
+        cached_action_ = ACTION_POINTER_UP;
+        cached_action_index_ =
+            static_cast<int>(GetIndexFromId(touch.touch_id()));
+        DCHECK_LE(cached_action_index_, static_cast<int>(pointer_count_));
+      }
+      break;
+    case ET_TOUCH_CANCELLED:
+      cached_action_ = ACTION_CANCEL;
+      break;
+    case ET_TOUCH_MOVED:
+      cached_action_ = ACTION_MOVE;
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+}
+
+size_t MotionEventAura::GetIndexFromId(int id) const {
+  for (size_t i = 0; i < pointer_count_; ++i) {
+    if (active_touches_[i].touch_id == id)
+      return i;
+  }
+  NOTREACHED();
+  return 0;
+}
+
+}  // namespace ui