Rid the world of the last of views::Event types: TouchEvent, GestureEvent, MouseWheelEvent, ScrollE…

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 360 matching lines @@
 }
 
 void RootView::OnMouseExited(const ui::MouseEvent& event) {
   if (mouse_move_handler_ != NULL) {
     mouse_move_handler_->OnMouseExited(event);
     NotifyEnterExitOfDescendant(event, EVENT_EXIT, mouse_move_handler_, NULL);
     mouse_move_handler_ = NULL;
   }
 }
 
-bool RootView::OnMouseWheel(const MouseWheelEvent& event) {
+bool RootView::OnMouseWheel(const ui::MouseWheelEvent& event) {
   bool consumed = false;
   for (View* v = GetFocusManager()->GetFocusedView();
        v && v != this && !consumed; v = v->parent())
     consumed = v->OnMouseWheel(event);
   return consumed;
 }
 
-bool RootView::OnScrollEvent(const ScrollEvent& event) {
+bool RootView::OnScrollEvent(const ui::ScrollEvent& event) {
   bool consumed = false;
   for (View* v = GetEventHandlerForPoint(event.location());
        v && v != this && !consumed; v = v->parent())
     consumed = v->OnScrollEvent(event);
   return consumed;
 }
 
-ui::TouchStatus RootView::OnTouchEvent(const TouchEvent& event) {
+ui::TouchStatus RootView::OnTouchEvent(const ui::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).
 
   // 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(event, this, touch_pressed_handler_);
+    ui::TouchEvent touch_event(event, static_cast<View*>(this),
+                               touch_pressed_handler_);
     status = touch_pressed_handler_->ProcessTouchEvent(touch_event);
     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(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.
       status = ui::TOUCH_STATUS_UNKNOWN;
       break;
     }
 
     // See if this view wants to handle the touch
-    TouchEvent touch_event(event, this, touch_pressed_handler_);
+    ui::TouchEvent touch_event(event, static_cast<View*>(this),
+                               touch_pressed_handler_);
     status = touch_pressed_handler_->ProcessTouchEvent(touch_event);
 
     // 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;
 
     // The touch event wasn't processed. Go up the view hierarchy and dispatch
     // 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;
 
     return status;
   }
 
   // Reset touch_pressed_handler_ to indicate that no processing is occurring.
   touch_pressed_handler_ = NULL;
 
   return status;
 }
 
-ui::GestureStatus RootView::OnGestureEvent(const GestureEvent& event) {
+ui::GestureStatus RootView::OnGestureEvent(const ui::GestureEvent& event) {
   ui::GestureStatus status = ui::GESTURE_STATUS_UNKNOWN;
 
   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_;
-    GestureEvent handler_event(event, this, handler);
+    ui::GestureEvent handler_event(event, static_cast<View*>(this), handler);
 
     ui::GestureStatus status = handler->ProcessGestureEvent(handler_event);
 
     if (event.type() == ui::ET_GESTURE_END &&
         event.details().touch_points() <= 1)
       gesture_handler_ = NULL;
 
     if (scroll_gesture_handler_ && (event.type() == ui::ET_GESTURE_SCROLL_END ||
                                     event.type() == ui::ET_SCROLL_FLING_START))
       scroll_gesture_handler_ = NULL;
 
     if (status == ui::GESTURE_STATUS_CONSUMED)
       return status;
 
     DCHECK_EQ(ui::GESTURE_STATUS_UNKNOWN, status);
 
     if (event.type() == ui::ET_GESTURE_SCROLL_BEGIN &&
         !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()) {
-        GestureEvent gesture_event(event, this, scroll_gesture_handler_);
+        ui::GestureEvent gesture_event(event, static_cast<View*>(this),
+                                       scroll_gesture_handler_);
         status = scroll_gesture_handler_->ProcessGestureEvent(gesture_event);
         if (status == ui::GESTURE_STATUS_CONSUMED)
           return status;
       }
       scroll_gesture_handler_ = NULL;
     }
 
     return ui::GESTURE_STATUS_UNKNOWN;
   }
 
   // Walk up the tree until we find a view that wants the gesture event.
   for (gesture_handler_ = GetEventHandlerForPoint(event.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(event, this, gesture_handler_);
+    ui::GestureEvent gesture_event(event, static_cast<View*>(this),
+                                   gesture_handler_);
     status = gesture_handler_->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_handler_)
       return ui::GESTURE_STATUS_UNKNOWN;
 
     if (status == ui::GESTURE_STATUS_CONSUMED) {
       if (gesture_event.type() == ui::ET_GESTURE_SCROLL_BEGIN)
@@ skipping 80 matching lines @@
 }
 
 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();
 }
 
 }  // namespace internal
 }  // namespace views