src/ui/events/event.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef UI_EVENTS_EVENT_H_
   6 #define UI_EVENTS_EVENT_H_
   7
   8 #include "base/basictypes.h"
   9 #include "base/compiler_specific.h"
  10 #include "base/event_types.h"
  11 #include "base/logging.h"
  12 #include "base/time/time.h"
  13 #include "ui/events/event_constants.h"
  14 #include "ui/events/gestures/gesture_types.h"
  15 #include "ui/events/keycodes/keyboard_codes.h"
  16 #include "ui/events/latency_info.h"
  17 #include "ui/gfx/point.h"
  18 #include "ui/gfx/point_conversions.h"
  19
  20 namespace gfx {
  21 class Transform;
  22 }
  23
  24 namespace ui {
  25 class EventTarget;
  26
  27 class EVENTS_EXPORT Event {
  28  public:
  29   virtual ~Event();
  30
  31   class DispatcherApi {
  32    public:
  33     explicit DispatcherApi(Event* event) : event_(event) {}
  34
  35     void set_target(EventTarget* target) {
  36       event_->target_ = target;
  37     }
  38
  39     void set_phase(EventPhase phase) { event_->phase_ = phase; }
  40     void set_result(int result) {
  41       event_->result_ = static_cast<EventResult>(result);
  42     }
  43
  44    private:
  45     DispatcherApi();
  46     Event* event_;
  47
  48     DISALLOW_COPY_AND_ASSIGN(DispatcherApi);
  49   };
  50
  51   const base::NativeEvent& native_event() const { return native_event_; }
  52   EventType type() const { return type_; }
  53   const std::string& name() const { return name_; }
  54   // time_stamp represents time since machine was booted.
  55   const base::TimeDelta& time_stamp() const { return time_stamp_; }
  56   int flags() const { return flags_; }
  57
  58   // This is only intended to be used externally by classes that are modifying
  59   // events in EventFilter::PreHandleKeyEvent().
  60   void set_flags(int flags) { flags_ = flags; }
  61
  62   EventTarget* target() const { return target_; }
  63   EventPhase phase() const { return phase_; }
  64   EventResult result() const { return result_; }
  65
  66   LatencyInfo* latency() { return &latency_; }
  67   const LatencyInfo* latency() const { return &latency_; }
  68   void set_latency(const LatencyInfo& latency) { latency_ = latency; }
  69
  70   // By default, events are "cancelable", this means any default processing that
  71   // the containing abstraction layer may perform can be prevented by calling
  72   // SetHandled(). SetHandled() or StopPropagation() must not be called for
  73   // events that are not cancelable.
  74   bool cancelable() const { return cancelable_; }
  75
  76   // The following methods return true if the respective keys were pressed at
  77   // the time the event was created.
  78   bool IsShiftDown() const { return (flags_ & EF_SHIFT_DOWN) != 0; }
  79   bool IsControlDown() const { return (flags_ & EF_CONTROL_DOWN) != 0; }
  80   bool IsCapsLockDown() const { return (flags_ & EF_CAPS_LOCK_DOWN) != 0; }
  81   bool IsAltDown() const { return (flags_ & EF_ALT_DOWN) != 0; }
  82   bool IsAltGrDown() const { return (flags_ & EF_ALTGR_DOWN) != 0; }
  83
  84   bool IsKeyEvent() const {
  85     return type_ == ET_KEY_PRESSED ||
  86            type_ == ET_KEY_RELEASED ||
  87            type_ == ET_TRANSLATED_KEY_PRESS ||
  88            type_ == ET_TRANSLATED_KEY_RELEASE;
  89   }
  90
  91   bool IsMouseEvent() const {
  92     return type_ == ET_MOUSE_PRESSED ||
  93            type_ == ET_MOUSE_DRAGGED ||
  94            type_ == ET_MOUSE_RELEASED ||
  95            type_ == ET_MOUSE_MOVED ||
  96            type_ == ET_MOUSE_ENTERED ||
  97            type_ == ET_MOUSE_EXITED ||
  98            type_ == ET_MOUSEWHEEL ||
  99            type_ == ET_MOUSE_CAPTURE_CHANGED;
 100   }
 101
 102   bool IsTouchEvent() const {
 103     return type_ == ET_TOUCH_RELEASED ||
 104            type_ == ET_TOUCH_PRESSED ||
 105            type_ == ET_TOUCH_MOVED ||
 106            type_ == ET_TOUCH_STATIONARY ||
 107            type_ == ET_TOUCH_CANCELLED;
 108   }
 109
 110   bool IsGestureEvent() const {
 111     switch (type_) {
 112       case ET_GESTURE_SCROLL_BEGIN:
 113       case ET_GESTURE_SCROLL_END:
 114       case ET_GESTURE_SCROLL_UPDATE:
 115       case ET_GESTURE_TAP:
 116       case ET_GESTURE_TAP_CANCEL:
 117       case ET_GESTURE_TAP_DOWN:
 118       case ET_GESTURE_BEGIN:
 119       case ET_GESTURE_END:
 120       case ET_GESTURE_TWO_FINGER_TAP:
 121       case ET_GESTURE_PINCH_BEGIN:
 122       case ET_GESTURE_PINCH_END:
 123       case ET_GESTURE_PINCH_UPDATE:
 124       case ET_GESTURE_LONG_PRESS:
 125       case ET_GESTURE_LONG_TAP:
 126       case ET_GESTURE_MULTIFINGER_SWIPE:
 127       case ET_GESTURE_SHOW_PRESS:
 128       case ET_GESTURE_WIN8_EDGE_SWIPE:
 129         // When adding a gesture event which is paired with an event which
 130         // occurs earlier, add the event to |IsEndingEvent|.
 131         return true;
 132
 133       case ET_SCROLL_FLING_CANCEL:
 134       case ET_SCROLL_FLING_START:
 135         // These can be ScrollEvents too. EF_FROM_TOUCH determines if they're
 136         // Gesture or Scroll events.
 137         return (flags_ & EF_FROM_TOUCH) == EF_FROM_TOUCH;
 138
 139       default:
 140         break;
 141     }
 142     return false;
 143   }
 144
 145   // An ending event is paired with the event which started it. Setting capture
 146   // should not prevent ending events from getting to their initial target.
 147   bool IsEndingEvent() const {
 148     switch(type_) {
 149       case ui::ET_TOUCH_CANCELLED:
 150       case ui::ET_GESTURE_TAP_CANCEL:
 151       case ui::ET_GESTURE_END:
 152       case ui::ET_GESTURE_SCROLL_END:
 153       case ui::ET_GESTURE_PINCH_END:
 154         return true;
 155       default:
 156         return false;
 157     }
 158   }
 159
 160   bool IsScrollEvent() const {
 161     // Flings can be GestureEvents too. EF_FROM_TOUCH determins if they're
 162     // Gesture or Scroll events.
 163     return type_ == ET_SCROLL ||
 164            ((type_ == ET_SCROLL_FLING_START ||
 165            type_ == ET_SCROLL_FLING_CANCEL) &&
 166            !(flags() & EF_FROM_TOUCH));
 167   }
 168
 169   bool IsScrollGestureEvent() const {
 170     return type_ == ET_GESTURE_SCROLL_BEGIN ||
 171            type_ == ET_GESTURE_SCROLL_UPDATE ||
 172            type_ == ET_GESTURE_SCROLL_END;
 173   }
 174
 175   bool IsFlingScrollEvent() const {
 176     return type_ == ET_SCROLL_FLING_CANCEL ||
 177            type_ == ET_SCROLL_FLING_START;
 178   }
 179
 180   bool IsMouseWheelEvent() const {
 181     return type_ == ET_MOUSEWHEEL;
 182   }
 183
 184   // Returns true if the event has a valid |native_event_|.
 185   bool HasNativeEvent() const;
 186
 187   // Immediately stops the propagation of the event. This must be called only
 188   // from an EventHandler during an event-dispatch. Any event handler that may
 189   // be in the list will not receive the event after this is called.
 190   // Note that StopPropagation() can be called only for cancelable events.
 191   void StopPropagation();
 192   bool stopped_propagation() const { return !!(result_ & ER_CONSUMED); }
 193
 194   // Marks the event as having been handled. A handled event does not reach the
 195   // next event phase. For example, if an event is handled during the pre-target
 196   // phase, then the event is dispatched to all pre-target handlers, but not to
 197   // the target or post-target handlers.
 198   // Note that SetHandled() can be called only for cancelable events.
 199   void SetHandled();
 200   bool handled() const { return result_ != ER_UNHANDLED; }
 201
 202  protected:
 203   Event(EventType type, base::TimeDelta time_stamp, int flags);
 204   Event(const base::NativeEvent& native_event, EventType type, int flags);
 205   Event(const Event& copy);
 206   void SetType(EventType type);
 207   void set_delete_native_event(bool delete_native_event) {
 208     delete_native_event_ = delete_native_event;
 209   }
 210   void set_cancelable(bool cancelable) { cancelable_ = cancelable; }
 211
 212   void set_time_stamp(const base::TimeDelta& time_stamp) {
 213     time_stamp_ = time_stamp;
 214   }
 215
 216   void set_name(const std::string& name) { name_ = name; }
 217
 218  private:
 219   friend class EventTestApi;
 220
 221   // Safely initializes the native event members of this class.
 222   void Init();
 223   void InitWithNativeEvent(const base::NativeEvent& native_event);
 224
 225   EventType type_;
 226   std::string name_;
 227   base::TimeDelta time_stamp_;
 228   LatencyInfo latency_;
 229   int flags_;
 230   base::NativeEvent native_event_;
 231   bool delete_native_event_;
 232   bool cancelable_;
 233   EventTarget* target_;
 234   EventPhase phase_;
 235   EventResult result_;
 236 };
 237
 238 class EVENTS_EXPORT CancelModeEvent : public Event {
 239  public:
 240   CancelModeEvent();
 241   virtual ~CancelModeEvent();
 242 };
 243
 244 class EVENTS_EXPORT LocatedEvent : public Event {
 245  public:
 246   virtual ~LocatedEvent();
 247
 248   float x() const { return location_.x(); }
 249   float y() const { return location_.y(); }
 250   void set_location(const gfx::PointF& location) { location_ = location; }
 251   // TODO(tdresser): Always return floating point location. See
 252   // crbug.com/337824.
 253   gfx::Point location() const { return gfx::ToFlooredPoint(location_); }
 254   gfx::PointF location_f() const { return location_; }
 255   void set_root_location(const gfx::PointF& root_location) {
 256     root_location_ = root_location;
 257   }
 258   gfx::Point root_location() const {
 259     return gfx::ToFlooredPoint(root_location_);
 260   }
 261
 262   // Transform the locations using |inverted_root_transform|.
 263   // This is applied to both |location_| and |root_location_|.
 264   virtual void UpdateForRootTransform(
 265       const gfx::Transform& inverted_root_transform);
 266
 267   template <class T> void ConvertLocationToTarget(T* source, T* target) {
 268     if (!target || target == source)
 269       return;
 270     // TODO(tdresser): Rewrite ConvertPointToTarget to use PointF. See
 271     // crbug.com/337824.
 272     gfx::Point offset = gfx::ToFlooredPoint(location_);
 273     T::ConvertPointToTarget(source, target, &offset);
 274     gfx::Vector2d diff = gfx::ToFlooredPoint(location_) - offset;
 275     location_= location_ - diff;
 276   }
 277
 278  protected:
 279   friend class LocatedEventTestApi;
 280   explicit LocatedEvent(const base::NativeEvent& native_event);
 281
 282   // Create a new LocatedEvent which is identical to the provided model.
 283   // If source / target windows are provided, the model location will be
 284   // converted from |source| coordinate system to |target| coordinate system.
 285   template <class T>
 286   LocatedEvent(const LocatedEvent& model, T* source, T* target)
 287       : Event(model),
 288         location_(model.location_),
 289         root_location_(model.root_location_) {
 290     ConvertLocationToTarget(source, target);
 291   }
 292
 293   // Used for synthetic events in testing.
 294   LocatedEvent(EventType type,
 295                const gfx::PointF& location,
 296                const gfx::PointF& root_location,
 297                base::TimeDelta time_stamp,
 298                int flags);
 299
 300   gfx::PointF location_;
 301
 302   // |location_| multiplied by an optional transformation matrix for
 303   // rotations, animations and skews.
 304   gfx::PointF root_location_;
 305 };
 306
 307 class EVENTS_EXPORT MouseEvent : public LocatedEvent {
 308  public:
 309   explicit MouseEvent(const base::NativeEvent& native_event);
 310
 311   // Create a new MouseEvent based on the provided model.
 312   // Uses the provided |type| and |flags| for the new event.
 313   // If source / target windows are provided, the model location will be
 314   // converted from |source| coordinate system to |target| coordinate system.
 315   template <class T>
 316   MouseEvent(const MouseEvent& model, T* source, T* target)
 317       : LocatedEvent(model, source, target),
 318         changed_button_flags_(model.changed_button_flags_) {
 319   }
 320
 321   template <class T>
 322   MouseEvent(const MouseEvent& model,
 323              T* source,
 324              T* target,
 325              EventType type,
 326              int flags)
 327       : LocatedEvent(model, source, target),
 328         changed_button_flags_(model.changed_button_flags_) {
 329     SetType(type);
 330     set_flags(flags);
 331   }
 332
 333   // Used for synthetic events in testing and by the gesture recognizer.
 334   MouseEvent(EventType type,
 335              const gfx::PointF& location,
 336              const gfx::PointF& root_location,
 337              int flags,
 338              int changed_button_flags);
 339
 340   // Conveniences to quickly test what button is down
 341   bool IsOnlyLeftMouseButton() const {
 342     return (flags() & EF_LEFT_MOUSE_BUTTON) &&
 343       !(flags() & (EF_MIDDLE_MOUSE_BUTTON | EF_RIGHT_MOUSE_BUTTON));
 344   }
 345
 346   bool IsLeftMouseButton() const {
 347     return (flags() & EF_LEFT_MOUSE_BUTTON) != 0;
 348   }
 349
 350   bool IsOnlyMiddleMouseButton() const {
 351     return (flags() & EF_MIDDLE_MOUSE_BUTTON) &&
 352       !(flags() & (EF_LEFT_MOUSE_BUTTON | EF_RIGHT_MOUSE_BUTTON));
 353   }
 354
 355   bool IsMiddleMouseButton() const {
 356     return (flags() & EF_MIDDLE_MOUSE_BUTTON) != 0;
 357   }
 358
 359   bool IsOnlyRightMouseButton() const {
 360     return (flags() & EF_RIGHT_MOUSE_BUTTON) &&
 361       !(flags() & (EF_LEFT_MOUSE_BUTTON | EF_MIDDLE_MOUSE_BUTTON));
 362   }
 363
 364   bool IsRightMouseButton() const {
 365     return (flags() & EF_RIGHT_MOUSE_BUTTON) != 0;
 366   }
 367
 368   bool IsAnyButton() const {
 369     return (flags() & (EF_LEFT_MOUSE_BUTTON | EF_MIDDLE_MOUSE_BUTTON |
 370                        EF_RIGHT_MOUSE_BUTTON)) != 0;
 371   }
 372
 373   // Compares two mouse down events and returns true if the second one should
 374   // be considered a repeat of the first.
 375   static bool IsRepeatedClickEvent(
 376       const MouseEvent& event1,
 377       const MouseEvent& event2);
 378
 379   // Get the click count. Can be 1, 2 or 3 for mousedown messages, 0 otherwise.
 380   int GetClickCount() const;
 381
 382   // Set the click count for a mousedown message. Can be 1, 2 or 3.
 383   void SetClickCount(int click_count);
 384
 385   // Identifies the button that changed. During a press this corresponds to the
 386   // button that was pressed and during a release this corresponds to the button
 387   // that was released.
 388   // NOTE: during a press and release flags() contains the complete set of
 389   // flags. Use this to determine the button that was pressed or released.
 390   int changed_button_flags() const { return changed_button_flags_; }
 391
 392  private:
 393   // Returns the repeat count based on the previous mouse click, if it is
 394   // recent enough and within a small enough distance.
 395   static int GetRepeatCount(const MouseEvent& click_event);
 396
 397   // See description above getter for details.
 398   int changed_button_flags_;
 399
 400   static MouseEvent* last_click_event_;
 401 };
 402
 403 class ScrollEvent;
 404
 405 class EVENTS_EXPORT MouseWheelEvent : public MouseEvent {
 406  public:
 407   // See |offset| for details.
 408   static const int kWheelDelta;
 409
 410   explicit MouseWheelEvent(const base::NativeEvent& native_event);
 411   explicit MouseWheelEvent(const ScrollEvent& scroll_event);
 412   MouseWheelEvent(const MouseEvent& mouse_event, int x_offset, int y_offset);
 413   MouseWheelEvent(const MouseWheelEvent& mouse_wheel_event);
 414
 415   template <class T>
 416   MouseWheelEvent(const MouseWheelEvent& model,
 417                   T* source,
 418                   T* target,
 419                   EventType type,
 420                   int flags)
 421       : MouseEvent(model, source, target, type, flags),
 422         offset_(model.x_offset(), model.y_offset()){
 423   }
 424
 425   // The amount to scroll. This is in multiples of kWheelDelta.
 426   // Note: x_offset() > 0/y_offset() > 0 means scroll left/up.
 427   int x_offset() const { return offset_.x(); }
 428   int y_offset() const { return offset_.y(); }
 429   const gfx::Vector2d& offset() const { return offset_; }
 430
 431   // Overridden from LocatedEvent.
 432   virtual void UpdateForRootTransform(
 433       const gfx::Transform& inverted_root_transform) OVERRIDE;
 434
 435  private:
 436   gfx::Vector2d offset_;
 437 };
 438
 439 class EVENTS_EXPORT TouchEvent : public LocatedEvent {
 440  public:
 441   explicit TouchEvent(const base::NativeEvent& native_event);
 442
 443   // Create a new TouchEvent which is identical to the provided model.
 444   // If source / target windows are provided, the model location will be
 445   // converted from |source| coordinate system to |target| coordinate system.
 446   template <class T>
 447   TouchEvent(const TouchEvent& model, T* source, T* target)
 448       : LocatedEvent(model, source, target),
 449         touch_id_(model.touch_id_),
 450         radius_x_(model.radius_x_),
 451         radius_y_(model.radius_y_),
 452         rotation_angle_(model.rotation_angle_),
 453         force_(model.force_),
 454         source_device_id_(model.source_device_id_) {
 455   }
 456
 457   TouchEvent(EventType type,
 458              const gfx::PointF& location,
 459              int touch_id,
 460              base::TimeDelta time_stamp);
 461
 462   TouchEvent(EventType type,
 463              const gfx::PointF& location,
 464              int flags,
 465              int touch_id,
 466              base::TimeDelta timestamp,
 467              float radius_x,
 468              float radius_y,
 469              float angle,
 470              float force);
 471
 472   virtual ~TouchEvent();
 473
 474   int touch_id() const { return touch_id_; }
 475   float radius_x() const { return radius_x_; }
 476   float radius_y() const { return radius_y_; }
 477   float rotation_angle() const { return rotation_angle_; }
 478   float force() const { return force_; }
 479   int source_device_id() const { return source_device_id_; }
 480
 481   // Relocate the touch-point to a new |origin|.
 482   // This is useful when touch event is in X Root Window coordinates,
 483   // and it needs to be mapped into Aura Root Window coordinates.
 484   void Relocate(const gfx::Point& origin);
 485
 486   // Used for unit tests.
 487   void set_radius_x(const float r) { radius_x_ = r; }
 488   void set_radius_y(const float r) { radius_y_ = r; }
 489   void set_source_device_id(int source_device_id) {
 490     source_device_id_ = source_device_id;
 491   }
 492
 493   // Overridden from LocatedEvent.
 494   virtual void UpdateForRootTransform(
 495       const gfx::Transform& inverted_root_transform) OVERRIDE;
 496
 497  protected:
 498   void set_radius(float radius_x, float radius_y) {
 499     radius_x_ = radius_x;
 500     radius_y_ = radius_y;
 501   }
 502
 503   void set_rotation_angle(float rotation_angle) {
 504     rotation_angle_ = rotation_angle;
 505   }
 506
 507   void set_force(float force) { force_ = force; }
 508
 509  private:
 510   // The identity (typically finger) of the touch starting at 0 and incrementing
 511   // for each separable additional touch that the hardware can detect.
 512   const int touch_id_;
 513
 514   // Radius of the X (major) axis of the touch ellipse. 0.0 if unknown.
 515   float radius_x_;
 516
 517   // Radius of the Y (minor) axis of the touch ellipse. 0.0 if unknown.
 518   float radius_y_;
 519
 520   // Angle of the major axis away from the X axis. Default 0.0.
 521   float rotation_angle_;
 522
 523   // Force (pressure) of the touch. Normalized to be [0, 1]. Default to be 0.0.
 524   float force_;
 525
 526   // The device id of the screen the event came from. Default to be -1.
 527   int source_device_id_;
 528 };
 529
 530 class EVENTS_EXPORT KeyEvent : public Event {
 531  public:
 532   KeyEvent(const base::NativeEvent& native_event, bool is_char);
 533
 534   // Used for synthetic events.
 535   KeyEvent(EventType type, KeyboardCode key_code, int flags, bool is_char);
 536
 537   // Used for synthetic events with code of DOM KeyboardEvent (e.g. 'KeyA')
 538   // See also: ui/events/keycodes/dom4/keycode_converter_data.h
 539   KeyEvent(EventType type, KeyboardCode key_code, const std::string& code,
 540            int flags, bool is_char);
 541
 542   // This allows an I18N virtual keyboard to fabricate a keyboard event that
 543   // does not have a corresponding KeyboardCode (example: U+00E1 Latin small
 544   // letter A with acute, U+0410 Cyrillic capital letter A).
 545   void set_character(uint16 character) { character_ = character; }
 546
 547   // Gets the character generated by this key event. It only supports Unicode
 548   // BMP characters.
 549   uint16 GetCharacter() const;
 550
 551   KeyboardCode key_code() const { return key_code_; }
 552   bool is_char() const { return is_char_; }
 553
 554   // This is only intended to be used externally by classes that are modifying
 555   // events in EventFilter::PreHandleKeyEvent().  set_character() should also be
 556   // called.
 557   void set_key_code(KeyboardCode key_code) { key_code_ = key_code; }
 558
 559   // Returns true for [Alt]+<num-pad digit> Unicode alt key codes used by Win.
 560   // TODO(msw): Additional work may be needed for analogues on other platforms.
 561   bool IsUnicodeKeyCode() const;
 562
 563   std::string code() const { return code_; }
 564
 565   // Normalizes flags_ to make it Windows/Mac compatible. Since the way
 566   // of setting modifier mask on X is very different than Windows/Mac as shown
 567   // in http://crbug.com/127142#c8, the normalization is necessary.
 568   void NormalizeFlags();
 569
 570  protected:
 571   // This allows a subclass TranslatedKeyEvent to be a non character event.
 572   void set_is_char(bool is_char) { is_char_ = is_char; }
 573
 574  private:
 575   KeyboardCode key_code_;
 576
 577   // String of 'code' defined in DOM KeyboardEvent (e.g. 'KeyA', 'Space')
 578   // http://www.w3.org/TR/uievents/#keyboard-key-codes.
 579   //
 580   // This value represents the physical position in the keyboard and can be
 581   // converted from / to keyboard scan code like XKB.
 582   std::string code_;
 583
 584   // True if this is a translated character event (vs. a raw key down). Both
 585   // share the same type: ET_KEY_PRESSED.
 586   bool is_char_;
 587
 588   uint16 character_;
 589 };
 590
 591 // A key event which is translated by an input method (IME).
 592 // For example, if an IME receives a KeyEvent(VKEY_SPACE), and it does not
 593 // consume the key, the IME usually generates and dispatches a
 594 // TranslatedKeyEvent(VKEY_SPACE) event. If the IME receives a KeyEvent and
 595 // it does consume the event, it might dispatch a
 596 // TranslatedKeyEvent(VKEY_PROCESSKEY) event as defined in the DOM spec.
 597 class EVENTS_EXPORT TranslatedKeyEvent : public KeyEvent {
 598  public:
 599   TranslatedKeyEvent(const base::NativeEvent& native_event, bool is_char);
 600
 601   // Used for synthetic events such as a VKEY_PROCESSKEY key event.
 602   TranslatedKeyEvent(bool is_press, KeyboardCode key_code, int flags);
 603
 604   explicit TranslatedKeyEvent(const KeyEvent& key_event);
 605
 606   // Changes the type() of the object from ET_TRANSLATED_KEY_* to ET_KEY_* so
 607   // that RenderWidgetHostViewAura and NativeWidgetAura could handle the event.
 608   void ConvertToKeyEvent();
 609
 610  private:
 611   DISALLOW_COPY_AND_ASSIGN(TranslatedKeyEvent);
 612 };
 613
 614 class EVENTS_EXPORT ScrollEvent : public MouseEvent {
 615  public:
 616   explicit ScrollEvent(const base::NativeEvent& native_event);
 617   template <class T>
 618   ScrollEvent(const ScrollEvent& model,
 619               T* source,
 620               T* target)
 621       : MouseEvent(model, source, target),
 622         x_offset_(model.x_offset_),
 623         y_offset_(model.y_offset_),
 624         x_offset_ordinal_(model.x_offset_ordinal_),
 625         y_offset_ordinal_(model.y_offset_ordinal_),
 626         finger_count_(model.finger_count_){
 627   }
 628
 629   // Used for tests.
 630   ScrollEvent(EventType type,
 631               const gfx::PointF& location,
 632               base::TimeDelta time_stamp,
 633               int flags,
 634               float x_offset,
 635               float y_offset,
 636               float x_offset_ordinal,
 637               float y_offset_ordinal,
 638               int finger_count);
 639
 640   // Scale the scroll event's offset value.
 641   // This is useful in the multi-monitor setup where it needs to be scaled
 642   // to provide a consistent user experience.
 643   void Scale(const float factor);
 644
 645   float x_offset() const { return x_offset_; }
 646   float y_offset() const { return y_offset_; }
 647   float x_offset_ordinal() const { return x_offset_ordinal_; }
 648   float y_offset_ordinal() const { return y_offset_ordinal_; }
 649   int finger_count() const { return finger_count_; }
 650
 651  private:
 652   // Potential accelerated offsets.
 653   float x_offset_;
 654   float y_offset_;
 655   // Unaccelerated offsets.
 656   float x_offset_ordinal_;
 657   float y_offset_ordinal_;
 658   // Number of fingers on the pad.
 659   int finger_count_;
 660 };
 661
 662 class EVENTS_EXPORT GestureEvent : public LocatedEvent {
 663  public:
 664   GestureEvent(EventType type,
 665                float x,
 666                float y,
 667                int flags,
 668                base::TimeDelta time_stamp,
 669                const GestureEventDetails& details,
 670                unsigned int touch_ids_bitfield);
 671
 672   // Create a new GestureEvent which is identical to the provided model.
 673   // If source / target windows are provided, the model location will be
 674   // converted from |source| coordinate system to |target| coordinate system.
 675   template <typename T>
 676   GestureEvent(const GestureEvent& model, T* source, T* target)
 677       : LocatedEvent(model, source, target),
 678         details_(model.details_),
 679         touch_ids_bitfield_(model.touch_ids_bitfield_) {
 680   }
 681
 682   virtual ~GestureEvent();
 683
 684   const GestureEventDetails& details() const { return details_; }
 685
 686   // Returns the lowest touch-id of any of the touches which make up this
 687   // gesture. If there are no touches associated with this gesture, returns -1.
 688   int GetLowestTouchId() const;
 689
 690  private:
 691   GestureEventDetails details_;
 692
 693   // The set of indices of ones in the binary representation of
 694   // touch_ids_bitfield_ is the set of touch_ids associate with this gesture.
 695   // This value is stored as a bitfield because the number of touch ids varies,
 696   // but we currently don't need more than 32 touches at a time.
 697   const unsigned int touch_ids_bitfield_;
 698 };
 699
 700 }  // namespace ui
 701
 702 #endif  // UI_EVENTS_EVENT_H_