Gesture related changes for views:

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"
@@ skipping 48 matching lines @@
 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),
       touch_pressed_handler_(NULL),
-      gesture_handling_view_(NULL),
+      gesture_handler_(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 213 matching lines @@
     // We allow the view to delete us from ProcessMouseReleased. As such,
     // configure state such that we're done first, then call View.
     View* mouse_pressed_handler = mouse_pressed_handler_;
     SetMouseHandler(NULL);
     mouse_pressed_handler->ProcessMouseReleased(mouse_released);
     // WARNING: we may have been deleted.
   }
 }
 
 void RootView::OnMouseCaptureLost() {
-  if (mouse_pressed_handler_) {
+  // TODO: this likely needs to reset touch handler too.
+
+  if (mouse_pressed_handler_ || gesture_handler_) {
     // Synthesize a release event for UpdateCursor.
-    MouseEvent release_event(ui::ET_MOUSE_RELEASED, last_mouse_event_x_,
-                             last_mouse_event_y_, last_mouse_event_flags_);
-    UpdateCursor(release_event);
+    if (mouse_pressed_handler_) {
+      MouseEvent release_event(ui::ET_MOUSE_RELEASED, last_mouse_event_x_,
+                               last_mouse_event_y_, last_mouse_event_flags_);
+      UpdateCursor(release_event);
+    }
     // We allow the view to delete us from OnMouseCaptureLost. As such,
     // configure state such that we're done first, then call View.
     View* mouse_pressed_handler = mouse_pressed_handler_;
+    View* gesture_handler = gesture_handler_;
     SetMouseHandler(NULL);
-    mouse_pressed_handler->OnMouseCaptureLost();
+    if (mouse_pressed_handler)
+      mouse_pressed_handler->OnMouseCaptureLost();
+    else
+      gesture_handler->OnMouseCaptureLost();
     // WARNING: we may have been deleted.
   }
 }
 
 void RootView::OnMouseMoved(const MouseEvent& event) {
   MouseEvent e(event, this);
   View* v = GetEventHandlerForPoint(e.location());
   // Find the first enabled view, or the existing move handler, whichever comes
   // first.  The check for the existing handler is because if a view becomes
   // disabled while handling moves, it's wrong to suddenly send ET_MOUSE_EXITED
@@ skipping 44 matching lines @@
 bool RootView::OnMouseWheel(const MouseWheelEvent& event) {
   MouseWheelEvent e(event, this);
   bool consumed = false;
   for (View* v = GetFocusManager()->GetFocusedView();
        v && v != this && !consumed; v = v->parent())
     consumed = v->OnMouseWheel(e);
   return consumed;
 }
 
 ui::TouchStatus RootView::OnTouchEvent(const TouchEvent& event) {
+  // TODO: this looks all wrong. On a TOUCH_PRESSED we should figure out the
+  // view and target that view with all touches with the same id until the
+  // release (or keep it if captured).
+
   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);
@@ skipping 39 matching lines @@
   // Reset touch_pressed_handler_ to indicate that no processing is occurring.
   touch_pressed_handler_ = NULL;
 
   return status;
 }
 
 ui::GestureStatus RootView::OnGestureEvent(const GestureEvent& event) {
   GestureEvent e(event, this);
   ui::GestureStatus status = ui::GESTURE_STATUS_UNKNOWN;
 
+  if (gesture_handler_) {
+    // Allow |gesture_handler_| to delete this during processing.
+    View* handler = gesture_handler_;
+    GestureEvent handler_event(event, this, gesture_handler_);
+    // TODO: should only do this for the last touch id that goes up.
+    if (event.type() == ui::ET_GESTURE_TAP_UP)
+      gesture_handler_ = NULL;
+    return handler->OnGestureEvent(handler_event);
+  }
+
   // 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()) {
+  for (gesture_handler_ = GetEventHandlerForPoint(e.location());
+      gesture_handler_ && (gesture_handler_ != this);
+      gesture_handler_ = gesture_handler_->parent()) {
+    if (!gesture_handler_->enabled()) {
       // Disabled views eat events but are treated as not handled.
       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);
+    GestureEvent gesture_event(e, this, gesture_handler_);
+    status = gesture_handler_->OnGestureEvent(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_)
+    if (!gesture_handler_)
       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;
   }
+
+  gesture_handler_ = NULL;
+
   return status;
 }
 
-void RootView::SetMouseHandler(View *new_mh) {
+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;
+  gesture_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;
+    if (gesture_handler_ == child)
+      gesture_handler_ = NULL;
   }
 }
 
 void RootView::OnPaint(gfx::Canvas* canvas) {
   if (!layer() || !layer()->fills_bounds_opaquely())
     canvas->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 21 matching lines @@
 }
 
 void RootView::SetMouseLocationAndFlags(const MouseEvent& event) {
   last_mouse_event_flags_ = event.flags();
   last_mouse_event_x_ = event.x();
   last_mouse_event_y_ = event.y();
 }
 
 }  // namespace internal
 }  // namespace views