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

ui/views/view.h

 // 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.
 
 #ifndef UI_VIEWS_VIEW_H_
 #define UI_VIEWS_VIEW_H_
 
 #include <algorithm>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
+#include "ui/base/event.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/compositor/layer_delegate.h"
 #include "ui/compositor/layer_owner.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/rect.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
-#include "ui/views/events/event.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_comptr.h"
 #endif
 
 using ui::OSExchangeData;
 
 namespace gfx {
 class Canvas;
 class Insets;
 class Path;
 }
 
 namespace ui {
 struct AccessibleViewState;
 class Compositor;
-class KeyEvent;
 class Layer;
 class TextInputClient;
 class Texture;
 class ThemeProvider;
 class Transform;
 }
 
 #if defined(OS_WIN)
 class __declspec(uuid("26f5641a-246d-457b-a96d-07f3fae6acf2"))
 NativeViewAccessibilityWin;
@@ skipping 514 matching lines @@
   // Default implementation does nothing. Override as needed.
   virtual void OnMouseEntered(const ui::MouseEvent& event);
 
   // This method is invoked when the mouse exits this control
   // The provided event location is always (0, 0)
   // Default implementation does nothing. Override as needed.
   virtual void OnMouseExited(const ui::MouseEvent& event);
 
   // This method is invoked for each touch event. Default implementation
   // does nothing. Override as needed.
-  virtual ui::TouchStatus OnTouchEvent(const TouchEvent& event);
+  virtual ui::TouchStatus OnTouchEvent(const ui::TouchEvent& event);
 
   // This method is invoked for each GestureEvent created by GestureRecognizer.
   // Default implementation does nothing. Override as needed.
   // If a View returns ui::GESTURE_STATUS_CONSUMED from OnGestureEvent, then
   // subsequent gestures will be dispatched to the same View, until the gesture
   // ends (i.e. all touch-points are released).
   // Scroll gesture events are handled slightly differently: if a View starts
   // processing gesture events, but does not process an ET_GESTURE_SCROLL_BEGIN
   // gesture, then the scroll-gesture event will bubble up (i.e. will be sent to
   // the parent view for processing). If a View then returns
   // GESTURE_STATUS_CONSUMED from OnGestureEvent, then the subsequent
   // scroll-gesture events will be sent to this View. However all the other
   // gesture-events (e.g. ET_GESTURE_END, ET_GESTURE_PINCH_BEGIN etc.) will
   // continue to be dispatched to the first View.
-  virtual ui::GestureStatus OnGestureEvent(const GestureEvent& event);
+  virtual ui::GestureStatus OnGestureEvent(const ui::GestureEvent& event);
 
   // Set the MouseHandler for a drag session.
   //
   // A drag session is a stream of mouse events starting
   // with a MousePressed event, followed by several MouseDragged
   // events and finishing with a MouseReleased event.
   //
   // This method should be only invoked while processing a
   // MouseDragged or MousePressed event.
   //
@@ skipping 13 matching lines @@
   // Subclasser should return true if the event has been processed and false
   // otherwise. If the event has not been processed, the parent will be given a
   // chance.
   virtual bool OnKeyPressed(const ui::KeyEvent& event);
   virtual bool OnKeyReleased(const ui::KeyEvent& event);
 
   // Invoked when the user uses the mousewheel. Implementors should return true
   // if the event has been processed and false otherwise. This message is sent
   // if the view is focused. If the event has not been processed, the parent
   // will be given a chance.
-  virtual bool OnMouseWheel(const MouseWheelEvent& event);
+  virtual bool OnMouseWheel(const ui::MouseWheelEvent& event);
 
   // Invoked when user scrolls (e.g. using two-finger scroll on touch pad).
   // Returns true if the event has been processed and false otherwise. The event
   // is sent to the view where the event happens first. If it has not been
   // processed, the parent will be given a chance.
-  virtual bool OnScrollEvent(const ScrollEvent& event);
+  virtual bool OnScrollEvent(const ui::ScrollEvent& event);
 
   // See field for description.
   void set_notify_enter_exit_on_child(bool notify) {
     notify_enter_exit_on_child_ = notify;
   }
   bool notify_enter_exit_on_child() const {
     return notify_enter_exit_on_child_;
   }
 
   // Returns the View's TextInputClient instance or NULL if the View doesn't
@@ skipping 179 matching lines @@
   virtual bool AreDropTypesRequired();
 
   // A view that supports drag and drop must override this and return true if
   // data contains a type that may be dropped on this view.
   virtual bool CanDrop(const OSExchangeData& data);
 
   // OnDragEntered is invoked when the mouse enters this view during a drag and
   // drop session and CanDrop returns true. This is immediately
   // followed by an invocation of OnDragUpdated, and eventually one of
   // OnDragExited or OnPerformDrop.
-  virtual void OnDragEntered(const DropTargetEvent& event);
+  virtual void OnDragEntered(const ui::DropTargetEvent& event);
 
   // Invoked during a drag and drop session while the mouse is over the view.
   // This should return a bitmask of the DragDropTypes::DragOperation supported
   // based on the location of the event. Return 0 to indicate the drop should
   // not be accepted.
-  virtual int OnDragUpdated(const DropTargetEvent& event);
+  virtual int OnDragUpdated(const ui::DropTargetEvent& event);
 
   // Invoked during a drag and drop session when the mouse exits the views, or
   // when the drag session was canceled and the mouse was over the view.
   virtual void OnDragExited();
 
   // Invoked during a drag and drop session when OnDragUpdated returns a valid
   // operation and the user release the mouse.
-  virtual int OnPerformDrop(const DropTargetEvent& event);
+  virtual int OnPerformDrop(const ui::DropTargetEvent& event);
 
   // Invoked from DoDrag after the drag completes. This implementation does
   // nothing, and is intended for subclasses to do cleanup.
   virtual void OnDragDone();
 
   // Returns true if the mouse was dragged enough to start a drag operation.
   // delta_x and y are the distance the mouse was dragged.
   static bool ExceededDragThreshold(int delta_x, int delta_y);
 
   // Accessibility -------------------------------------------------------------
@@ skipping 417 matching lines @@
   // Input ---------------------------------------------------------------------
 
   // RootView invokes these. These in turn invoke the appropriate OnMouseXXX
   // method. If a drag is detected, DoDrag is invoked.
   bool ProcessMousePressed(const ui::MouseEvent& event, DragInfo* drop_info);
   bool ProcessMouseDragged(const ui::MouseEvent& event, DragInfo* drop_info);
   void ProcessMouseReleased(const ui::MouseEvent& event);
 
   // RootView will invoke this with incoming TouchEvents. Returns the result
   // of OnTouchEvent.
-  ui::TouchStatus ProcessTouchEvent(const TouchEvent& event);
+  ui::TouchStatus ProcessTouchEvent(const ui::TouchEvent& event);
 
   // RootView will invoke this with incoming GestureEvents. This will invoke
   // OnGestureEvent and return the result.
-  ui::GestureStatus ProcessGestureEvent(const GestureEvent& event);
+  ui::GestureStatus ProcessGestureEvent(const ui::GestureEvent& event);
 
   // Accelerators --------------------------------------------------------------
 
   // Registers this view's keyboard accelerators that are not registered to
   // FocusManager yet, if possible.
   void RegisterPendingAccelerators();
 
   // Unregisters all the keyboard accelerators associated with this view.
   // |leave_data_intact| if true does not remove data from accelerators_ array,
   // so it could be re-registered with other focus manager
@@ skipping 172 matching lines @@
   base::win::ScopedComPtr<NativeViewAccessibilityWin>
       native_view_accessibility_win_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(View);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_VIEW_H_