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

ui/base/event.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_BASE_EVENT_H_
 #define UI_BASE_EVENT_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/event_types.h"
@@ skipping 27 matching lines @@
     void set_time_stamp(const base::TimeDelta& time_stamp) {
       event_->time_stamp_ = time_stamp;
     }
 
    private:
     TestApi();
     Event* event_;
   };
 
   const base::NativeEvent& native_event() const { return native_event_; }
-  const ui::NativeEvent& ui_native_event() const { return ui_native_event_; }
+  const NativeEvent& ui_native_event() const { return ui_native_event_; }
   EventType type() const { return type_; }
   // time_stamp represents time since machine was booted.
   const base::TimeDelta& time_stamp() const { return time_stamp_; }
   int flags() const { return flags_; }
 
   // This is only intended to be used externally by classes that are modifying
   // events in EventFilter::PreHandleKeyEvent().
   void set_flags(int flags) { flags_ = flags; }
 
   // The following methods return true if the respective keys were pressed at
   // the time the event was created.
   bool IsShiftDown() const { return (flags_ & EF_SHIFT_DOWN) != 0; }
   bool IsControlDown() const { return (flags_ & EF_CONTROL_DOWN) != 0; }
   bool IsCapsLockDown() const { return (flags_ & EF_CAPS_LOCK_DOWN) != 0; }
   bool IsAltDown() const { return (flags_ & EF_ALT_DOWN) != 0; }
 
   bool IsMouseEvent() const {
-    return type_ == ui::ET_MOUSE_PRESSED ||
-           type_ == ui::ET_MOUSE_DRAGGED ||
-           type_ == ui::ET_MOUSE_RELEASED ||
-           type_ == ui::ET_MOUSE_MOVED ||
-           type_ == ui::ET_MOUSE_ENTERED ||
-           type_ == ui::ET_MOUSE_EXITED ||
-           type_ == ui::ET_MOUSEWHEEL;
+    return type_ == ET_MOUSE_PRESSED ||
+           type_ == ET_MOUSE_DRAGGED ||
+           type_ == ET_MOUSE_RELEASED ||
+           type_ == ET_MOUSE_MOVED ||
+           type_ == ET_MOUSE_ENTERED ||
+           type_ == ET_MOUSE_EXITED ||
+           type_ == ET_MOUSEWHEEL;
   }
 
   bool IsTouchEvent() const {
-    return type_ == ui::ET_TOUCH_RELEASED ||
-           type_ == ui::ET_TOUCH_PRESSED ||
-           type_ == ui::ET_TOUCH_MOVED ||
-           type_ == ui::ET_TOUCH_STATIONARY ||
-           type_ == ui::ET_TOUCH_CANCELLED;
+    return type_ == ET_TOUCH_RELEASED ||
+           type_ == ET_TOUCH_PRESSED ||
+           type_ == ET_TOUCH_MOVED ||
+           type_ == ET_TOUCH_STATIONARY ||
+           type_ == ET_TOUCH_CANCELLED;
   }
 
   bool IsScrollGestureEvent() const {
-    return type_ == ui::ET_GESTURE_SCROLL_BEGIN ||
-           type_ == ui::ET_GESTURE_SCROLL_UPDATE ||
-           type_ == ui::ET_GESTURE_SCROLL_END;
+    return type_ == ET_GESTURE_SCROLL_BEGIN ||
+           type_ == ET_GESTURE_SCROLL_UPDATE ||
+           type_ == ET_GESTURE_SCROLL_END;
   }
 
   bool IsFlingScrollEvent() const {
-    return type_ == ui::ET_SCROLL_FLING_CANCEL ||
-           type_ == ui::ET_SCROLL_FLING_START;
+    return type_ == ET_SCROLL_FLING_CANCEL ||
+           type_ == ET_SCROLL_FLING_START;
   }
 
   // Returns true if the event has a valid |native_event_|.
   bool HasNativeEvent() const;
 
  protected:
   Event(EventType type, int flags);
   Event(const base::NativeEvent& native_event, EventType type, int flags);
   Event(const Event& copy);
   void set_type(EventType type) { type_ = type; }
   void set_delete_native_event(bool delete_native_event) {
     delete_native_event_ = delete_native_event;
   }
   void set_time_stamp(base::TimeDelta time_stamp) { time_stamp_ = time_stamp; }
 
  private:
   void operator=(const Event&);
 
   // Safely initializes the native event members of this class.
   void Init();
   void InitWithNativeEvent(const base::NativeEvent& native_event);
 
   base::NativeEvent native_event_;
   // TODO(beng): check to see if this is necessary.
-  ui::NativeEvent ui_native_event_;
+  NativeEvent ui_native_event_;
   EventType type_;
   base::TimeDelta time_stamp_;
   int flags_;
   bool delete_native_event_;
 };
 
 class UI_EXPORT LocatedEvent : public Event {
  public:
   // For testing.
   class TestApi : public Event::TestApi {
@@ skipping 75 matching lines @@
   }
 
   // Used for synthetic events in testing and by the gesture recognizer.
   MouseEvent(EventType type,
              const gfx::Point& location,
              const gfx::Point& root_location,
              int flags);
 
   // Conveniences to quickly test what button is down
   bool IsOnlyLeftMouseButton() const {
-    return (flags() & ui::EF_LEFT_MOUSE_BUTTON) &&
-      !(flags() & (ui::EF_MIDDLE_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON));
+    return (flags() & EF_LEFT_MOUSE_BUTTON) &&
+      !(flags() & (EF_MIDDLE_MOUSE_BUTTON | EF_RIGHT_MOUSE_BUTTON));
   }
 
   bool IsLeftMouseButton() const {
-    return (flags() & ui::EF_LEFT_MOUSE_BUTTON) != 0;
+    return (flags() & EF_LEFT_MOUSE_BUTTON) != 0;
   }
 
   bool IsOnlyMiddleMouseButton() const {
-    return (flags() & ui::EF_MIDDLE_MOUSE_BUTTON) &&
-      !(flags() & (ui::EF_LEFT_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON));
+    return (flags() & EF_MIDDLE_MOUSE_BUTTON) &&
+      !(flags() & (EF_LEFT_MOUSE_BUTTON | EF_RIGHT_MOUSE_BUTTON));
   }
 
   bool IsMiddleMouseButton() const {
-    return (flags() & ui::EF_MIDDLE_MOUSE_BUTTON) != 0;
+    return (flags() & EF_MIDDLE_MOUSE_BUTTON) != 0;
   }
 
   bool IsOnlyRightMouseButton() const {
-    return (flags() & ui::EF_RIGHT_MOUSE_BUTTON) &&
-      !(flags() & (ui::EF_LEFT_MOUSE_BUTTON | ui::EF_MIDDLE_MOUSE_BUTTON));
+    return (flags() & EF_RIGHT_MOUSE_BUTTON) &&
+      !(flags() & (EF_LEFT_MOUSE_BUTTON | EF_MIDDLE_MOUSE_BUTTON));
   }
 
   bool IsRightMouseButton() const {
-    return (flags() & ui::EF_RIGHT_MOUSE_BUTTON) != 0;
+    return (flags() & EF_RIGHT_MOUSE_BUTTON) != 0;
   }
 
   // Compares two mouse down events and returns true if the second one should
   // be considered a repeat of the first.
   static bool IsRepeatedClickEvent(
       const MouseEvent& event1,
       const MouseEvent& event2);
 
   // Get the click count. Can be 1, 2 or 3 for mousedown messages, 0 otherwise.
   int GetClickCount() const;
 
   // Set the click count for a mousedown message. Can be 1, 2 or 3.
   void SetClickCount(int click_count);
 
  protected:
   explicit MouseEvent(const MouseEvent& model);
 
  private:
   gfx::Point root_location_;
 
   static MouseEvent* last_click_event_;
   // Returns the repeat count based on the previous mouse click, if it is
   // recent enough and within a small enough distance.
   static int GetRepeatCount(const MouseEvent& click_event);
 };
 
+class ScrollEvent;
+
+class UI_EXPORT MouseWheelEvent : public MouseEvent {
+ public:
+  // See |offset| for details.
+  static const int kWheelDelta;
+
+  explicit MouseWheelEvent(const NativeEvent& native_event);
+  explicit MouseWheelEvent(const ScrollEvent& scroll_event);
+
+  // The amount to scroll. This is in multiples of kWheelDelta.
+  // Note: offset() > 0 means scroll up / left.
+  int offset() const { return offset_; }
+
+ private:
+  int offset_;
+
+  DISALLOW_COPY_AND_ASSIGN(MouseWheelEvent);
+};
+
 class UI_EXPORT TouchEvent : public LocatedEvent {
  public:
   explicit TouchEvent(const base::NativeEvent& native_event);
 
   // Create a new TouchEvent which is identical to the provided model.
   // If source / target windows are provided, the model location will be
   // converted from |source| coordinate system to |target| coordinate system.
   template <class T>
   TouchEvent(const TouchEvent& model, T* source, T* target)
       : LocatedEvent(model, source, target),
@@ skipping 49 matching lines @@
 
   // Angle of the major axis away from the X axis. Default 0.0.
   float rotation_angle_;
 
   // Force (pressure) of the touch. Normalized to be [0, 1]. Default to be 0.0.
   float force_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchEvent);
 };
 
+class UI_EXPORT TestTouchEvent : public TouchEvent {
+ public:
+  // Create a new touch event.
+  TestTouchEvent(EventType type,
+                 int x,
+                 int y,
+                 int flags,
+                 int touch_id,
+                 float radius_x,
+                 float radius_y,
+                 float angle,
+                 float force);
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestTouchEvent);
+};
+
 class UI_EXPORT KeyEvent : public Event {
  public:
   KeyEvent(const base::NativeEvent& native_event, bool is_char);
 
   // Used for synthetic events in testing.
   KeyEvent(EventType type, KeyboardCode key_code, int flags);
 
   // These setters allow an I18N virtual keyboard to fabricate a keyboard event
   // which does not have a corresponding KeyboardCode (example: U+00E1 Latin
   // small letter A with acute, U+0410 Cyrillic capital letter A.)
@@ skipping 134 matching lines @@
   // This value is stored as a bitfield because the number of touch ids varies,
   // but we currently don't need more than 32 touches at a time.
   const unsigned int touch_ids_bitfield_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureEvent);
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_EVENT_H_