views: Dispatch mouse events using EventDispatch interface too.

ui/views/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.
 
 #define _USE_MATH_DEFINES // For VC++ to get M_PI. This has to be first.
 
 #include "ui/views/view.h"
 
 #include <algorithm>
 #include <cmath>
@@ skipping 913 matching lines @@
 }
 
 void View::OnKeyEvent(ui::KeyEvent* event) {
   bool consumed = (event->type() == ui::ET_KEY_PRESSED) ? OnKeyPressed(*event) :
                                                           OnKeyReleased(*event);
   if (consumed)
     event->StopPropagation();
 }
 
 void View::OnMouseEvent(ui::MouseEvent* event) {
+  switch (event->type()) {
+    case ui::ET_MOUSE_PRESSED:
+      if (ProcessMousePressed(*event))
+        event->SetHandled();
+      return;
+
+    case ui::ET_MOUSE_MOVED:
+      if ((event->flags() & (ui::EF_LEFT_MOUSE_BUTTON |
+                             ui::EF_RIGHT_MOUSE_BUTTON |
+                             ui::EF_MIDDLE_MOUSE_BUTTON)) == 0) {
+        OnMouseMoved(*event);
+        return;
+      }
+      // FALL-THROUGH
+    case ui::ET_MOUSE_DRAGGED:
+      if (ProcessMouseDragged(*event))
+        event->SetHandled();
+      return;
+
+    case ui::ET_MOUSE_RELEASED:
+      ProcessMouseReleased(*event);
+      return;
+
+    case ui::ET_MOUSEWHEEL:
+      if (OnMouseWheel(*static_cast<ui::MouseWheelEvent*>(event)))
+        event->SetHandled();
+      break;
+
+    case ui::ET_MOUSE_ENTERED:
+      OnMouseEntered(*event);
+      break;
+
+    case ui::ET_MOUSE_EXITED:
+      OnMouseExited(*event);
+      break;
+
+    default:
+      return;
+  }
 }
 
 void View::OnScrollEvent(ui::ScrollEvent* event) {
 }
 
 void View::OnTouchEvent(ui::TouchEvent* event) {
 }
 
 void View::OnGestureEvent(ui::GestureEvent* event) {
 }
@@ skipping 428 matching lines @@
 // Input -----------------------------------------------------------------------
 
 bool View::HasHitTestMask() const {
   return false;
 }
 
 void View::GetHitTestMask(gfx::Path* mask) const {
   DCHECK(mask);
 }
 
+View::DragInfo* View::GetDragInfo() {
+  return parent_ ? parent_->GetDragInfo() : NULL;
+}
+
 // Focus -----------------------------------------------------------------------
 
 void View::OnFocus() {
   // TODO(beng): Investigate whether it's possible for us to move this to
   //             Focus().
   // By default, we clear the native focus. This ensures that no visible native
   // view as the focus and that we still receive keyboard inputs.
   FocusManager* focus_manager = GetFocusManager();
   if (focus_manager)
     focus_manager->ClearNativeFocus();
@@ skipping 589 matching lines @@
 
   SchedulePaint();
 
   Widget* widget = GetWidget();
   if (widget)
     widget->UpdateRootLayers();
 }
 
 // Input -----------------------------------------------------------------------
 
-bool View::ProcessMousePressed(const ui::MouseEvent& event,
-                               DragInfo* drag_info) {
+bool View::ProcessMousePressed(const ui::MouseEvent& event) {
   int drag_operations =
       (enabled_ && event.IsOnlyLeftMouseButton() &&
        HitTestPoint(event.location())) ?
        GetDragOperations(event.location()) : 0;
   ContextMenuController* context_menu_controller = event.IsRightMouseButton() ?
       context_menu_controller_ : 0;
 
   const bool enabled = enabled_;
   const bool result = OnMousePressed(event);
   // WARNING: we may have been deleted, don't use any View variables.
 
   if (!enabled)
     return result;
 
   if (drag_operations != ui::DragDropTypes::DRAG_NONE) {
-    drag_info->PossibleDrag(event.location());
+    GetDragInfo()->PossibleDrag(event.location());
     return true;
   }
   return !!context_menu_controller || result;
 }
 
-bool View::ProcessMouseDragged(const ui::MouseEvent& event,
-                               DragInfo* drag_info) {
+bool View::ProcessMouseDragged(const ui::MouseEvent& event) {
   // Copy the field, that way if we're deleted after drag and drop no harm is
   // done.
   ContextMenuController* context_menu_controller = context_menu_controller_;
-  const bool possible_drag = drag_info->possible_drag;
+  const bool possible_drag = GetDragInfo()->possible_drag;
   if (possible_drag &&
-      ExceededDragThreshold(drag_info->start_pt - event.location())) {
+      ExceededDragThreshold(GetDragInfo()->start_pt - event.location())) {
     if (!drag_controller_ ||
         drag_controller_->CanStartDragForView(
-            this, drag_info->start_pt, event.location())) {
-      DoDrag(event, drag_info->start_pt,
+            this, GetDragInfo()->start_pt, event.location())) {
+      DoDrag(event, GetDragInfo()->start_pt,
           ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE);
     }
   } else {
     if (OnMouseDragged(event))
       return true;
     // Fall through to return value based on context menu controller.
   }
   // WARNING: we may have been deleted.
   return (context_menu_controller != NULL) || possible_drag;
 }
@@ skipping 153 matching lines @@
   ConvertPointToWidget(this, &widget_location);
   GetWidget()->RunShellDrag(this, data, widget_location, drag_operations,
       source);
   return true;
 #else
   return false;
 #endif  // !defined(OS_MACOSX)
 }
 
 }  // namespace views