Initial views touchui Gesture Recognizer support

ui/views/widget/root_view.cc

 // 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.
 
 #include "ui/views/widget/root_view.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/views/focus/view_storage.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/touchui/gesture_manager.h"
+#include "ui/views/touchui/gesture_recognizer.h"
 #include "ui/views/widget/widget.h"
 
 namespace views {
 namespace internal {
 
 // static
 const char RootView::kViewClassName[] = "views/RootView";
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootView, public:
 
 // Creation and lifetime -------------------------------------------------------
 
 RootView::RootView(Widget* widget)
     : widget_(widget),
       mouse_pressed_handler_(NULL),
       mouse_move_handler_(NULL),
       last_click_handler_(NULL),
       explicit_mouse_handler_(false),
       last_mouse_event_flags_(0),
       last_mouse_event_x_(-1),
       last_mouse_event_y_(-1),
       gesture_manager_(GestureManager::GetInstance()),
       touch_pressed_handler_(NULL),
+      gesture_recognizer_(GestureRecognizer::GetInstance()),
+      gesture_handling_view_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(focus_search_(this, false, false)),
       focus_traversable_parent_(NULL),
       focus_traversable_parent_view_(NULL) {
 }
 
 RootView::~RootView() {
   // If we have children remove them explicitly so to make sure a remove
   // notification is sent for each one of them.
   if (has_children())
     RemoveAllChildViews(true);
@@ skipping 277 matching lines @@
   TouchEvent e(event, this);
 
   // If touch_pressed_handler_ is non null, we are currently processing
   // a touch down on the screen situation. In that case we send the
   // event to touch_pressed_handler_
   ui::TouchStatus status = ui::TOUCH_STATUS_UNKNOWN;
 
   if (touch_pressed_handler_) {
     TouchEvent touch_event(e, this, touch_pressed_handler_);
     status = touch_pressed_handler_->ProcessTouchEvent(touch_event);
-    if (gesture_manager_->ProcessTouchEventForGesture(e, this, status))
+    if (DoGestureProcessing(e, status))
       status = ui::TOUCH_STATUS_SYNTH_MOUSE;
     if (status == ui::TOUCH_STATUS_END)
       touch_pressed_handler_ = NULL;
     return status;
   }
 
   // Walk up the tree until we find a view that wants the touch event.
   for (touch_pressed_handler_ = GetEventHandlerForPoint(e.location());
        touch_pressed_handler_ && (touch_pressed_handler_ != this);
        touch_pressed_handler_ = touch_pressed_handler_->parent()) {
@@ skipping 18 matching lines @@
     // the touch event.
     if (status == ui::TOUCH_STATUS_UNKNOWN)
       continue;
 
     // If the touch didn't initiate a touch-sequence, then reset the touch event
     // handler. Otherwise, leave it set so that subsequent touch events are
     // dispatched to the same handler.
     if (status != ui::TOUCH_STATUS_START)
       touch_pressed_handler_ = NULL;
 
-    if (gesture_manager_->ProcessTouchEventForGesture(e, this, status))
+    if (DoGestureProcessing(e, status))
       status = ui::TOUCH_STATUS_SYNTH_MOUSE;
     return status;
   }
 
   // Reset touch_pressed_handler_ to indicate that no processing is occurring.
   touch_pressed_handler_ = NULL;
 
   // Give the touch event to the gesture manager.
   if (gesture_manager_->ProcessTouchEventForGesture(e, this, status))
     status = ui::TOUCH_STATUS_SYNTH_MOUSE;
   return status;
 }
 
+ui::GestureStatus RootView::OnGestureEvent(const GestureEvent& event) {
+  GestureEvent e(event, this);
+  ui::GestureStatus status = ui::GESTURE_STATUS_UNKNOWN;
+
+  // Walk up the tree until we find a view that wants the gesture event.
+  for (gesture_handling_view_ = GetEventHandlerForPoint(e.location());
+      gesture_handling_view_ && (gesture_handling_view_ != this);
+      gesture_handling_view_ = gesture_handling_view_->parent()) {
+    if (!gesture_handling_view_->enabled()) {
+      // Disabled views eat events but are treated as not handled by the
+      // the GestureManager.
+      return ui::GESTURE_STATUS_UNKNOWN;
+    }
+
+    // See if this view wants to handle the Gesture.
+    GestureEvent gesture_event(e, this, gesture_handling_view_);
+    status = gesture_handling_view_->ProcessGestureEvent(gesture_event);
+
+    // The view could have removed itself from the tree when handling
+    // OnGestureEvent(). So handle as per OnMousePressed. NB: we
+    // assume that the RootView itself cannot be so removed.
+    if (!gesture_handling_view_) return ui::GESTURE_STATUS_UNKNOWN;
+
+    // The gesture event wasn't processed. Go up the view hierarchy and
+    // dispatch the gesture event.
+    if (status == ui::GESTURE_STATUS_UNKNOWN) {
+      continue;
+    } else if (status == ui::GESTURE_STATUS_CONSUMED) {
+      return status;
+    } else {
+      return ui::GESTURE_STATUS_UNKNOWN;
+    }
+  }
+  return status;
+}
+
 void RootView::SetMouseHandler(View *new_mh) {
   // If we're clearing the mouse handler, clear explicit_mouse_handler_ as well.
   explicit_mouse_handler_ = (new_mh != NULL);
   mouse_pressed_handler_ = new_mh;
   drag_info_.Reset();
 }
 
 void RootView::GetAccessibleState(ui::AccessibleViewState* state) {
   state->role = ui::AccessibilityTypes::ROLE_APPLICATION;
 }
 
 void RootView::ReorderChildLayers(ui::Layer* parent_layer) {
   View::ReorderChildLayers(parent_layer);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootView, protected:
 
 void RootView::ViewHierarchyChanged(bool is_add, View* parent, View* child) {
   widget_->ViewHierarchyChanged(is_add, parent, child);
 
   if (!is_add) {
     if (!explicit_mouse_handler_ && mouse_pressed_handler_ == child)
       mouse_pressed_handler_ = NULL;
     if (mouse_move_handler_ == child)
       mouse_move_handler_ = NULL;
     if (touch_pressed_handler_ == child)
       touch_pressed_handler_ = NULL;
+    if (gesture_handling_view_ == child)
+      gesture_handling_view_ = NULL;
   }
 }
 
 void RootView::OnPaint(gfx::Canvas* canvas) {
   if (!layer() || !layer()->fills_bounds_opaquely())
     canvas->GetSkCanvas()->drawColor(SK_ColorBLACK, SkXfermode::kClear_Mode);
 
   // TODO (pkotwicz): Remove this once we switch over to Aura desktop.
   // This is needed so that we can set the background behind the RWHV when the
   // RWHV is not visible. Not needed once there is a view between the RootView
@@ skipping 19 matching lines @@
     widget_->SetCursor(v->GetCursor(MouseEvent(event, this, v)));
   }
 }
 
 void RootView::SetMouseLocationAndFlags(const MouseEvent& event) {
   last_mouse_event_flags_ = event.flags();
   last_mouse_event_x_ = event.x();
   last_mouse_event_y_ = event.y();
 }
 
+bool RootView::DoGestureProcessing(const TouchEvent& event,
+                                   ui::TouchStatus status) {
+  if (status != ui::TOUCH_STATUS_UNKNOWN)
+    return false;  // The event was consumed by a touch sequence.
+
+  // Get the GestureEvent list processed from GestureRecognizer.
+  scoped_ptr<GestureRecognizer::Gestures> gestures;
+  gestures.reset(gesture_recognizer_->ProcessTouchEventForGesture(event,
+      status));
+  bool synthetic = true;
+  for (unsigned int i = 0; i < gestures->size(); i++) {
+    GestureEvent* event = gestures->at(i).get();
+    GestureEvent e(*event, this);
+    if (OnGestureEvent(e) == ui::GESTURE_STATUS_CONSUMED) {
+      // All gesture events should be consumed.
+      synthetic = false;
+    } else {
+      synthetic = true;
+      break;
+    }
+  }
+  if (synthetic) {
+    // TODO(Gajen): This should be removed in future once all views are capable
+    // of handling OnGestureEvent.
+    return gesture_manager_->ProcessTouchEventForGesture(event, this,
+        status);
+  }
+  return synthetic;
+}
+
 }  // namespace internal
 }  // namespace views