views: Dispatch key, touch, scroll and gesture events using the EventDispatch interface.

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 53 matching lines @@
       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_handler_(NULL),
       scroll_gesture_handler_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(focus_search_(this, false, false)),
       focus_traversable_parent_(NULL),
-      focus_traversable_parent_view_(NULL) {
+      focus_traversable_parent_view_(NULL),
+      event_dispatch_target_(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);
 }
 
 // Tree operations -------------------------------------------------------------
@@ skipping 20 matching lines @@
 }
 
 void RootView::NotifyNativeViewHierarchyChanged(bool attached,
                                                 gfx::NativeView native_view) {
   PropagateNativeViewHierarchyChanged(attached, native_view, this);
 }
 
 // Input -----------------------------------------------------------------------
 
 void RootView::DispatchKeyEvent(ui::KeyEvent* event) {
-  bool consumed = false;
-
   View* v = NULL;
   if (GetFocusManager())  // NULL in unittests.
     v = GetFocusManager()->GetFocusedView();
   // Special case to handle right-click context menus triggered by the
   // keyboard.
   if (v && v->enabled() && ((event->key_code() == ui::VKEY_APPS) ||
      (event->key_code() == ui::VKEY_F10 && event->IsShiftDown()))) {
     v->ShowContextMenu(v->GetKeyboardContextMenuLocation(), false);
     event->StopPropagation();
     return;
   }
-  for (; v && v != this && !consumed; v = v->parent()) {
-    consumed = (event->type() == ui::ET_KEY_PRESSED) ?
-        v->OnKeyPressed(*event) : v->OnKeyReleased(*event);
-  }
 
-  if (consumed)
-    event->StopPropagation();
+  for (; v && v != this && !event->handled(); v = v->parent())
+    DispatchEventToTarget(v, event);
 }
 
 void RootView::DispatchScrollEvent(ui::ScrollEvent* event) {
   for (View* v = GetEventHandlerForPoint(event->location());
        v && v != this && !event->stopped_propagation(); v = v->parent()) {
-    v->OnScrollEvent(event);
+    DispatchEventToTarget(v, event);
   }
 
   if (event->handled() || event->type() != ui::ET_SCROLL)
     return;
 
   // Convert unprocessed scroll events into mouse-wheel events. Note that
   // wheel events are normally sent to the focused view. However, if the focused
   // view does not process these wheel events, then dispatch them to the view
   // under the cursor.
   ui::MouseWheelEvent wheel(*event);
@@ skipping 19 matching lines @@
   // view and target that view with all touches with the same id until the
   // release (or keep it if captured).
 
   // 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_
 
   if (touch_pressed_handler_) {
     ui::TouchEvent touch_event(*event, static_cast<View*>(this),
                                touch_pressed_handler_);
-    touch_pressed_handler_->ProcessTouchEvent(&touch_event);
+    DispatchEventToTarget(touch_pressed_handler_, &touch_event);
     if (touch_event.handled())
       event->SetHandled();
     if (touch_event.stopped_propagation())
       event->StopPropagation();
     return;
   }
 
   // Walk up the tree until we find a view that wants the touch event.
   for (touch_pressed_handler_ = GetEventHandlerForPoint(event->location());
        touch_pressed_handler_ && (touch_pressed_handler_ != this);
        touch_pressed_handler_ = touch_pressed_handler_->parent()) {
     if (!touch_pressed_handler_->enabled()) {
       // Disabled views eat events but are treated as not handled.
       break;
     }
 
     // See if this view wants to handle the touch
     ui::TouchEvent touch_event(*event, static_cast<View*>(this),
                                touch_pressed_handler_);
-    touch_pressed_handler_->ProcessTouchEvent(&touch_event);
+    DispatchEventToTarget(touch_pressed_handler_, &touch_event);
     if (touch_event.handled())
       event->SetHandled();
     if (touch_event.stopped_propagation())
       event->StopPropagation();
 
     // The view could have removed itself from the tree when handling
     // OnTouchEvent(). So handle as per OnMousePressed. NB: we
     // assume that the RootView itself cannot be so removed.
     if (!touch_pressed_handler_)
       break;
@@ skipping 18 matching lines @@
 }
 
 void RootView::DispatchGestureEvent(ui::GestureEvent* event) {
   if (gesture_handler_) {
     // |gesture_handler_| (or |scroll_gesture_handler_|) can be deleted during
     // processing.
     View* handler = scroll_gesture_handler_ &&
         (event->IsScrollGestureEvent() || event->IsFlingScrollEvent())  ?
             scroll_gesture_handler_ : gesture_handler_;
     ui::GestureEvent handler_event(*event, static_cast<View*>(this), handler);
-    handler->ProcessGestureEvent(&handler_event);
+    DispatchEventToTarget(handler, &handler_event);
 
     if (event->type() == ui::ET_GESTURE_END &&
         event->details().touch_points() <= 1) {
       // In case a drag was in progress, reset all the handlers. Otherwise, just
       // reset the gesture handler.
       if (gesture_handler_ == mouse_pressed_handler_)
         SetMouseHandler(NULL);
       else
         gesture_handler_ = NULL;
     }
@@ skipping 16 matching lines @@
         !scroll_gesture_handler_) {
       // Some view started processing gesture events, however it does not
       // process scroll-gesture events. In such case, we allow the event to
       // bubble up, and install a different scroll-gesture handler different
       // from the default gesture handler.
       for (scroll_gesture_handler_ = gesture_handler_->parent();
           scroll_gesture_handler_ && scroll_gesture_handler_ != this;
           scroll_gesture_handler_ = scroll_gesture_handler_->parent()) {
         ui::GestureEvent gesture_event(*event, static_cast<View*>(this),
                                        scroll_gesture_handler_);
-        scroll_gesture_handler_->ProcessGestureEvent(&gesture_event);
+        DispatchEventToTarget(scroll_gesture_handler_, &gesture_event);
         if (gesture_event.stopped_propagation()) {
           event->StopPropagation();
           return;
         } else if (gesture_event.handled()) {
           event->SetHandled();
           return;
         }
       }
       scroll_gesture_handler_ = NULL;
     }
@@ skipping 17 matching lines @@
       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;
     }
 
     // See if this view wants to handle the Gesture.
     ui::GestureEvent gesture_event(*event, static_cast<View*>(this),
                                    gesture_handler_);
-    gesture_handler_->ProcessGestureEvent(&gesture_event);
+    DispatchEventToTarget(gesture_handler_, &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_handler_)
       return;
 
     if (gesture_event.handled()) {
       if (gesture_event.type() == ui::ET_GESTURE_SCROLL_BEGIN)
         scroll_gesture_handler_ = gesture_handler_;
@@ skipping 300 matching lines @@
     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_handler_ == child)
       gesture_handler_ = NULL;
     if (scroll_gesture_handler_ == child)
       scroll_gesture_handler_ = NULL;
+    if (event_dispatch_target_ == child)
+      event_dispatch_target_ = 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 @@
     widget_->SetCursor(v->GetCursor(me));
   }
 }
 
 void RootView::SetMouseLocationAndFlags(const ui::MouseEvent& event) {
   last_mouse_event_flags_ = event.flags();
   last_mouse_event_x_ = event.x();
   last_mouse_event_y_ = event.y();
 }
 
+void RootView::DispatchEventToTarget(View* target, ui::Event* event) {
+  View* old_target = event_dispatch_target_;
+  event_dispatch_target_ = target;
+  if (DispatchEvent(target, event))
+    event_dispatch_target_ = old_target;
+}
+
+bool RootView::CanDispatchToTarget(ui::EventTarget* target) {
+  return event_dispatch_target_ == target;
+}
+
 }  // namespace internal
 }  // namespace views