widget/InputData.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef InputData_h__
   7 #define InputData_h__
   8
   9 #include "nsDebug.h"
  10 #include "nsIScrollableFrame.h"
  11 #include "nsPoint.h"
  12 #include "nsTArray.h"
  13 #include "Units.h"
  14 #include "mozilla/DefineEnum.h"
  15 #include "mozilla/EventForwards.h"
  16 #include "mozilla/TimeStamp.h"
  17 #include "mozilla/WheelHandlingHelper.h"  // for WheelDeltaAdjustmentStrategy
  18 #include "mozilla/gfx/MatrixFwd.h"
  19 #include "mozilla/layers/APZUtils.h"
  20 #include "mozilla/layers/KeyboardScrollAction.h"
  21
  22 template <class E>
  23 struct already_AddRefed;
  24 class nsIWidget;
  25
  26 namespace mozilla {
  27
  28 namespace layers {
  29 class APZInputBridgeChild;
  30 class PAPZInputBridgeParent;
  31 }  // namespace layers
  32
  33 namespace dom {
  34 class Touch;
  35 }  // namespace dom
  36
  37 // clang-format off
  38 MOZ_DEFINE_ENUM(
  39   InputType, (
  40     MULTITOUCH_INPUT,
  41     MOUSE_INPUT,
  42     PANGESTURE_INPUT,
  43     PINCHGESTURE_INPUT,
  44     TAPGESTURE_INPUT,
  45     SCROLLWHEEL_INPUT,
  46     KEYBOARD_INPUT
  47 ));
  48 // clang-format on
  49
  50 class MultiTouchInput;
  51 class MouseInput;
  52 class PanGestureInput;
  53 class PinchGestureInput;
  54 class TapGestureInput;
  55 class ScrollWheelInput;
  56 class KeyboardInput;
  57
  58 // This looks unnecessary now, but as we add more and more classes that derive
  59 // from InputType (eventually probably almost as many as *Events.h has), it
  60 // will be more and more clear what's going on with a macro that shortens the
  61 // definition of the RTTI functions.
  62 #define INPUTDATA_AS_CHILD_TYPE(type, enumID)                       \
  63   const type& As##type() const {                                    \
  64     MOZ_ASSERT(mInputType == enumID, "Invalid cast of InputData."); \
  65     return (const type&)*this;                                      \
  66   }                                                                 \
  67   type& As##type() {                                                \
  68     MOZ_ASSERT(mInputType == enumID, "Invalid cast of InputData."); \
  69     return (type&)*this;                                            \
  70   }
  71
  72 /** Base input data class. Should never be instantiated. */
  73 class InputData {
  74  public:
  75   // Warning, this class is serialized and sent over IPC. Any change to its
  76   // fields must be reflected in its ParamTraits<>, in nsGUIEventIPC.h
  77   InputType mInputType;
  78   // Time in milliseconds that this data is relevant to. This only really
  79   // matters when this data is used as an event. We use uint32_t instead of
  80   // TimeStamp because it is easier to convert from WidgetInputEvent. The time
  81   // is platform-specific but it in the case of B2G and Fennec it is since
  82   // startup.
  83   uint32_t mTime;
  84   // Set in parallel to mTime until we determine it is safe to drop
  85   // platform-specific event times (see bug 77992).
  86   TimeStamp mTimeStamp;
  87   // The sequence number of the last potentially focus changing event handled
  88   // by APZ. This is used to track when that event has been processed by
  89   // content, and focus can be reconfirmed for async keyboard scrolling.
  90   uint64_t mFocusSequenceNumber;
  91
  92   // The LayersId of the content process that the corresponding WidgetEvent
  93   // should be dispatched to.
  94   layers::LayersId mLayersId;
  95
  96   Modifiers modifiers;
  97
  98   INPUTDATA_AS_CHILD_TYPE(MultiTouchInput, MULTITOUCH_INPUT)
  99   INPUTDATA_AS_CHILD_TYPE(MouseInput, MOUSE_INPUT)
 100   INPUTDATA_AS_CHILD_TYPE(PanGestureInput, PANGESTURE_INPUT)
 101   INPUTDATA_AS_CHILD_TYPE(PinchGestureInput, PINCHGESTURE_INPUT)
 102   INPUTDATA_AS_CHILD_TYPE(TapGestureInput, TAPGESTURE_INPUT)
 103   INPUTDATA_AS_CHILD_TYPE(ScrollWheelInput, SCROLLWHEEL_INPUT)
 104   INPUTDATA_AS_CHILD_TYPE(KeyboardInput, KEYBOARD_INPUT)
 105
 106   virtual ~InputData();
 107   explicit InputData(InputType aInputType);
 108
 109  protected:
 110   InputData(InputType aInputType, uint32_t aTime, TimeStamp aTimeStamp,
 111             Modifiers aModifiers);
 112 };
 113
 114 /**
 115  * Data container for a single touch input. Similar to dom::Touch, but used in
 116  * off-main-thread situations. This is more for just storing touch data, whereas
 117  * dom::Touch is more useful for dispatching through the DOM (which can only
 118  * happen on the main thread). dom::Touch also bears the problem of storing
 119  * pointers to nsIWidget instances which can only be used on the main thread,
 120  * so if instead we used dom::Touch and ever set these pointers
 121  * off-main-thread, Bad Things Can Happen(tm).
 122  *
 123  * Note that this doesn't inherit from InputData because this itself is not an
 124  * event. It is only a container/struct that should have any number of instances
 125  * within a MultiTouchInput.
 126  *
 127  * fixme/bug 775746: Make dom::Touch inherit from this class.
 128  */
 129 class SingleTouchData {
 130  public:
 131   // Construct a SingleTouchData from a Screen point.
 132   // mLocalScreenPoint remains (0,0) unless it's set later.
 133   SingleTouchData(int32_t aIdentifier, ScreenIntPoint aScreenPoint,
 134                   ScreenSize aRadius, float aRotationAngle, float aForce);
 135
 136   // Construct a SingleTouchData from a ParentLayer point.
 137   // mScreenPoint remains (0,0) unless it's set later.
 138   // Note: if APZ starts using the radius for anything, we should add a local
 139   // version of that too, and have this constructor take it as a
 140   // ParentLayerSize.
 141   SingleTouchData(int32_t aIdentifier, ParentLayerPoint aLocalScreenPoint,
 142                   ScreenSize aRadius, float aRotationAngle, float aForce);
 143
 144   SingleTouchData();
 145
 146   already_AddRefed<dom::Touch> ToNewDOMTouch() const;
 147
 148   // Warning, this class is serialized and sent over IPC. Any change to its
 149   // fields must be reflected in its ParamTraits<>, in nsGUIEventIPC.h
 150
 151   // A unique number assigned to each SingleTouchData within a MultiTouchInput
 152   // so that they can be easily distinguished when handling a touch
 153   // start/move/end.
 154   int32_t mIdentifier;
 155
 156   // Point on the screen that the touch hit, in device pixels. They are
 157   // coordinates on the screen.
 158   ScreenIntPoint mScreenPoint;
 159
 160   // |mScreenPoint| transformed to the local coordinates of the APZC targeted
 161   // by the hit. This is set and used by APZ.
 162   ParentLayerPoint mLocalScreenPoint;
 163
 164   // Radius that the touch covers, i.e. if you're using your thumb it will
 165   // probably be larger than using your pinky, even with the same force.
 166   // Radius can be different along x and y. For example, if you press down with
 167   // your entire finger vertically, the y radius will be much larger than the x
 168   // radius.
 169   ScreenSize mRadius;
 170
 171   float mRotationAngle;
 172
 173   // How hard the screen is being pressed.
 174   float mForce;
 175 };
 176
 177 /**
 178  * Similar to WidgetTouchEvent, but for use off-main-thread. Also only stores a
 179  * screen touch point instead of the many different coordinate spaces
 180  * WidgetTouchEvent stores its touch point in. This includes a way to initialize
 181  * itself from a WidgetTouchEvent by copying all relevant data over. Note that
 182  * this copying from WidgetTouchEvent functionality can only be used on the main
 183  * thread.
 184  *
 185  * Stores an array of SingleTouchData.
 186  */
 187 class MultiTouchInput : public InputData {
 188  public:
 189   // clang-format off
 190   MOZ_DEFINE_ENUM_AT_CLASS_SCOPE(
 191     MultiTouchType, (
 192       MULTITOUCH_START,
 193       MULTITOUCH_MOVE,
 194       MULTITOUCH_END,
 195       MULTITOUCH_CANCEL
 196   ));
 197   // clang-format on
 198
 199   MultiTouchInput(MultiTouchType aType, uint32_t aTime, TimeStamp aTimeStamp,
 200                   Modifiers aModifiers);
 201   MultiTouchInput();
 202   MultiTouchInput(const MultiTouchInput& aOther);
 203   explicit MultiTouchInput(const WidgetTouchEvent& aTouchEvent);
 204   void Translate(const ScreenPoint& aTranslation);
 205
 206   WidgetTouchEvent ToWidgetTouchEvent(nsIWidget* aWidget) const;
 207   WidgetMouseEvent ToWidgetMouseEvent(nsIWidget* aWidget) const;
 208
 209   // Return the index into mTouches of the SingleTouchData with the given
 210   // identifier, or -1 if there is no such SingleTouchData.
 211   int32_t IndexOfTouch(int32_t aTouchIdentifier);
 212
 213   bool TransformToLocal(const ScreenToParentLayerMatrix4x4& aTransform);
 214
 215   // Warning, this class is serialized and sent over IPC. Any change to its
 216   // fields must be reflected in its ParamTraits<>, in nsGUIEventIPC.h
 217   MultiTouchType mType;
 218   nsTArray<SingleTouchData> mTouches;
 219   // The screen offset of the root widget. This can be changing along with
 220   // the touch interaction, so we sstore it in the event.
 221   ExternalPoint mScreenOffset;
 222   bool mHandledByAPZ;
 223 };
 224
 225 class MouseInput : public InputData {
 226  protected:
 227   friend mozilla::layers::APZInputBridgeChild;
 228   friend mozilla::layers::PAPZInputBridgeParent;
 229
 230   MouseInput();
 231
 232  public:
 233   // clang-format off
 234   MOZ_DEFINE_ENUM_AT_CLASS_SCOPE(
 235     MouseType, (
 236       MOUSE_NONE,
 237       MOUSE_MOVE,
 238       MOUSE_DOWN,
 239       MOUSE_UP,
 240       MOUSE_DRAG_START,
 241       MOUSE_DRAG_END,
 242       MOUSE_WIDGET_ENTER,
 243       MOUSE_WIDGET_EXIT,
 244       MOUSE_HITTEST
 245   ));
 246
 247   MOZ_DEFINE_ENUM_AT_CLASS_SCOPE(
 248     ButtonType, (
 249       LEFT_BUTTON,
 250       MIDDLE_BUTTON,
 251       RIGHT_BUTTON,
 252       NONE
 253   ));
 254   // clang-format on
 255
 256   MouseInput(MouseType aType, ButtonType aButtonType, uint16_t aInputSource,
 257              int16_t aButtons, const ScreenPoint& aPoint, uint32_t aTime,
 258              TimeStamp aTimeStamp, Modifiers aModifiers);
 259   explicit MouseInput(const WidgetMouseEventBase& aMouseEvent);
 260
 261   bool IsLeftButton() const;
 262
 263   bool TransformToLocal(const ScreenToParentLayerMatrix4x4& aTransform);
 264   WidgetMouseEvent ToWidgetMouseEvent(nsIWidget* aWidget) const;
 265
 266   // Warning, this class is serialized and sent over IPC. Any change to its
 267   // fields must be reflected in its ParamTraits<>, in nsGUIEventIPC.h
 268   MouseType mType;
 269   ButtonType mButtonType;
 270   uint16_t mInputSource;
 271   int16_t mButtons;
 272   ScreenPoint mOrigin;
 273   ParentLayerPoint mLocalOrigin;
 274   bool mHandledByAPZ;
 275 };
 276
 277 /**
 278  * Encapsulation class for pan events, can be used off-main-thread.
 279  * These events are currently only used for scrolling on desktop.
 280  */
 281 class PanGestureInput : public InputData {
 282  protected:
 283   friend mozilla::layers::APZInputBridgeChild;
 284   friend mozilla::layers::PAPZInputBridgeParent;
 285
 286   PanGestureInput();
 287
 288  public:
 289   // clang-format off
 290   MOZ_DEFINE_ENUM_AT_CLASS_SCOPE(
 291     PanGestureType, (
 292       // MayStart: Dispatched before any actual panning has occurred but when a
 293       // pan gesture is probably about to start, for example when the user
 294       // starts touching the touchpad. Should interrupt any ongoing APZ
 295       // animation and can be used to trigger scrollability indicators (e.g.
 296       // flashing overlay scrollbars).
 297       PANGESTURE_MAYSTART,
 298
 299       // Cancelled: Dispatched after MayStart when no pan gesture is going to
 300       // happen after all, for example when the user lifts their fingers from a
 301       // touchpad without having done any scrolling.
 302       PANGESTURE_CANCELLED,
 303
 304       // Start: A pan gesture is starting.
 305       // For devices that do not support the MayStart event type, this event can
 306       // be used to interrupt ongoing APZ animations.
 307       PANGESTURE_START,
 308
 309       // Pan: The actual pan motion by mPanDisplacement.
 310       PANGESTURE_PAN,
 311
 312       // End: The pan gesture has ended, for example because the user has lifted
 313       // their fingers from a touchpad after scrolling.
 314       // Any potential momentum events fire after this event.
 315       PANGESTURE_END,
 316
 317       // The following momentum event types are used in order to control the pan
 318       // momentum animation. Using these instead of our own animation ensures
 319       // that the animation curve is OS native and that the animation stops
 320       // reliably if it is cancelled by the user.
 321
 322       // MomentumStart: Dispatched between the End event of the actual
 323       // user-controlled pan, and the first MomentumPan event of the momentum
 324       // animation.
 325       PANGESTURE_MOMENTUMSTART,
 326
 327       // MomentumPan: The actual momentum motion by mPanDisplacement.
 328       PANGESTURE_MOMENTUMPAN,
 329
 330       // MomentumEnd: The momentum animation has ended, for example because the
 331       // momentum velocity has gone below the stopping threshold, or because the
 332       // user has stopped the animation by putting their fingers on a touchpad.
 333       PANGESTURE_MOMENTUMEND
 334   ));
 335
 336   MOZ_DEFINE_ENUM_AT_CLASS_SCOPE(
 337     PanDeltaType, (
 338       // There are three kinds of scroll delta modes in Gecko: "page", "line"
 339       // and "pixel". Touchpad pan gestures only support "page" and "pixel".
 340       //
 341       // NOTE: PANDELTA_PAGE currently replicates Gtk behavior
 342       // (see AsyncPanZoomController::OnPan).
 343       PANDELTA_PAGE,
 344       PANDELTA_PIXEL
 345   ));
 346   // clang-format on
 347
 348   PanGestureInput(PanGestureType aType, uint32_t aTime, TimeStamp aTimeStamp,
 349                   const ScreenPoint& aPanStartPoint,
 350                   const ScreenPoint& aPanDisplacement, Modifiers aModifiers);
 351
 352   bool IsMomentum() const;
 353
 354   WidgetWheelEvent ToWidgetWheelEvent(nsIWidget* aWidget) const;
 355
 356   bool TransformToLocal(const ScreenToParentLayerMatrix4x4& aTransform);
 357
 358   ScreenPoint UserMultipliedPanDisplacement() const;
 359   ParentLayerPoint UserMultipliedLocalPanDisplacement() const;
 360
 361   // Warning, this class is serialized and sent over IPC. Any change to its
 362   // fields must be reflected in its ParamTraits<>, in nsGUIEventIPC.h
 363   PanGestureType mType;
 364   ScreenPoint mPanStartPoint;
 365
 366   // The delta. This can be non-zero on any type of event.
 367   ScreenPoint mPanDisplacement;
 368
 369   // Versions of |mPanStartPoint| and |mPanDisplacement| in the local
 370   // coordinates of the APZC receiving the pan. These are set and used by APZ.
 371   ParentLayerPoint mLocalPanStartPoint;
 372   ParentLayerPoint mLocalPanDisplacement;
 373
 374   // See lineOrPageDeltaX/Y on WidgetWheelEvent.
 375   int32_t mLineOrPageDeltaX;
 376   int32_t mLineOrPageDeltaY;
 377
 378   // User-set delta multipliers.
 379   double mUserDeltaMultiplierX;
 380   double mUserDeltaMultiplierY;
 381
 382   PanDeltaType mDeltaType = PANDELTA_PIXEL;
 383
 384   bool mHandledByAPZ : 1;
 385
 386   // true if this is a PANGESTURE_END event that will be followed by a
 387   // PANGESTURE_MOMENTUMSTART event.
 388   bool mFollowedByMomentum : 1;
 389
 390   // If this is true, and this event started a new input block that couldn't
 391   // find a scrollable target which is scrollable in the horizontal component
 392   // of the scroll start direction, then this input block needs to be put on
 393   // hold until a content response has arrived, even if the block has a
 394   // confirmed target.
 395   // This is used by events that can result in a swipe instead of a scroll.
 396   bool mRequiresContentResponseIfCannotScrollHorizontallyInStartDirection : 1;
 397
 398   // This is used by APZ to communicate to the macOS widget code whether
 399   // the overscroll-behavior of the scroll frame handling this swipe allows
 400   // non-local overscroll behaviors in the horizontal direction (such as
 401   // swipe navigation).
 402   bool mOverscrollBehaviorAllowsSwipe : 1;
 403
 404   // true if APZ should do a fling animation after this pan ends, like
 405   // it would with touchscreens. (For platforms that don't emit momentum
 406   // events.)
 407   bool mSimulateMomentum : 1;
 408
 409   void SetHandledByAPZ(bool aHandled) { mHandledByAPZ = aHandled; }
 410   void SetFollowedByMomentum(bool aFollowed) {
 411     mFollowedByMomentum = aFollowed;
 412   }
 413   void SetRequiresContentResponseIfCannotScrollHorizontallyInStartDirection(
 414       bool aRequires) {
 415     mRequiresContentResponseIfCannotScrollHorizontallyInStartDirection =
 416         aRequires;
 417   }
 418   void SetOverscrollBehaviorAllowsSwipe(bool aAllows) {
 419     mOverscrollBehaviorAllowsSwipe = aAllows;
 420   }
 421   void SetSimulateMomentum(bool aSimulate) { mSimulateMomentum = aSimulate; }
 422 };
 423
 424 /**
 425  * Encapsulation class for pinch events. In general, these will be generated by
 426  * a gesture listener by looking at SingleTouchData/MultiTouchInput instances
 427  * and determining whether or not the user was trying to do a gesture.
 428  */
 429 class PinchGestureInput : public InputData {
 430  protected:
 431   friend mozilla::layers::APZInputBridgeChild;
 432   friend mozilla::layers::PAPZInputBridgeParent;
 433
 434   PinchGestureInput();
 435
 436  public:
 437   // clang-format off
 438   MOZ_DEFINE_ENUM_AT_CLASS_SCOPE(
 439     PinchGestureType, (
 440       PINCHGESTURE_START,
 441       PINCHGESTURE_SCALE,
 442       PINCHGESTURE_END
 443   ));
 444   // clang-format on
 445
 446   // Construct a pinch gesture from a Screen point.
 447   PinchGestureInput(PinchGestureType aType, uint32_t aTime,
 448                     TimeStamp aTimeStamp, const ExternalPoint& aScreenOffset,
 449                     const ScreenPoint& aFocusPoint, ScreenCoord aCurrentSpan,
 450                     ScreenCoord aPreviousSpan, Modifiers aModifiers);
 451
 452   bool TransformToLocal(const ScreenToParentLayerMatrix4x4& aTransform);
 453
 454   // Warning, this class is serialized and sent over IPC. Any change to its
 455   // fields must be reflected in its ParamTraits<>, in nsGUIEventIPC.h
 456   PinchGestureType mType;
 457
 458   // Center point of the pinch gesture. That is, if there are two fingers on the
 459   // screen, it is their midpoint. In the case of more than two fingers, the
 460   // point is implementation-specific, but can for example be the midpoint
 461   // between the very first and very last touch. This is in device pixels and
 462   // are the coordinates on the screen of this midpoint.
 463   // For PINCHGESTURE_END events, this instead will hold the coordinates of
 464   // the remaining finger, if there is one. If there isn't one then it will
 465   // store |BothFingersLifted()|.
 466   ScreenPoint mFocusPoint;
 467
 468   // The screen offset of the root widget. This can be changing along with
 469   // the touch interaction, so we sstore it in the event.
 470   ExternalPoint mScreenOffset;
 471
 472   // |mFocusPoint| transformed to the local coordinates of the APZC targeted
 473   // by the hit. This is set and used by APZ.
 474   ParentLayerPoint mLocalFocusPoint;
 475
 476   // The distance between the touches responsible for the pinch gesture.
 477   ScreenCoord mCurrentSpan;
 478
 479   // The previous |mCurrentSpan| in the PinchGestureInput preceding this one.
 480   // This is only really relevant during a PINCHGESTURE_SCALE because when it is
 481   // of this type then there must have been a history of spans.
 482   ScreenCoord mPreviousSpan;
 483
 484   // A special value for mFocusPoint used in PINCHGESTURE_END events to
 485   // indicate that both fingers have been lifted. If only one finger has
 486   // been lifted, the coordinates of the remaining finger are expected to
 487   // be stored in mFocusPoint.
 488   // For pinch events that were not triggered by touch gestures, the
 489   // value of mFocusPoint in a PINCHGESTURE_END event is always expected
 490   // to be this value.
 491   // For convenience, we allow retrieving this value in any coordinate system.
 492   // Since it's a special value, no conversion is needed.
 493   template <typename Units = ParentLayerPixel>
 494   static gfx::PointTyped<Units> BothFingersLifted() {
 495     return gfx::PointTyped<Units>{-1, -1};
 496   }
 497 };
 498
 499 /**
 500  * Encapsulation class for tap events. In general, these will be generated by
 501  * a gesture listener by looking at SingleTouchData/MultiTouchInput instances
 502  * and determining whether or not the user was trying to do a gesture.
 503  */
 504 class TapGestureInput : public InputData {
 505  protected:
 506   friend mozilla::layers::APZInputBridgeChild;
 507   friend mozilla::layers::PAPZInputBridgeParent;
 508
 509   TapGestureInput();
 510
 511  public:
 512   // clang-format off
 513   MOZ_DEFINE_ENUM_AT_CLASS_SCOPE(
 514     TapGestureType, (
 515       TAPGESTURE_LONG,
 516       TAPGESTURE_LONG_UP,
 517       TAPGESTURE_UP,
 518       TAPGESTURE_CONFIRMED,
 519       TAPGESTURE_DOUBLE,
 520       TAPGESTURE_SECOND, // See GeckoContentController::TapType::eSecondTap
 521       TAPGESTURE_CANCEL
 522   ));
 523   // clang-format on
 524
 525   // Construct a tap gesture from a Screen point.
 526   // mLocalPoint remains (0,0) unless it's set later.
 527   TapGestureInput(TapGestureType aType, uint32_t aTime, TimeStamp aTimeStamp,
 528                   const ScreenIntPoint& aPoint, Modifiers aModifiers);
 529
 530   // Construct a tap gesture from a ParentLayer point.
 531   // mPoint remains (0,0) unless it's set later.
 532   TapGestureInput(TapGestureType aType, uint32_t aTime, TimeStamp aTimeStamp,
 533                   const ParentLayerPoint& aLocalPoint, Modifiers aModifiers);
 534
 535   bool TransformToLocal(const ScreenToParentLayerMatrix4x4& aTransform);
 536
 537   // Warning, this class is serialized and sent over IPC. Any change to its
 538   // fields must be reflected in its ParamTraits<>, in nsGUIEventIPC.h
 539   TapGestureType mType;
 540
 541   // The location of the tap in screen pixels.
 542   ScreenIntPoint mPoint;
 543
 544   // The location of the tap in the local coordinates of the APZC receiving it.
 545   // This is set and used by APZ.
 546   ParentLayerPoint mLocalPoint;
 547 };
 548
 549 // Encapsulation class for scroll-wheel events. These are generated by mice
 550 // with physical scroll wheels, and on Windows by most touchpads when using
 551 // scroll gestures.
 552 class ScrollWheelInput : public InputData {
 553  protected:
 554   friend mozilla::layers::APZInputBridgeChild;
 555   friend mozilla::layers::PAPZInputBridgeParent;
 556
 557   typedef mozilla::layers::APZWheelAction APZWheelAction;
 558
 559   ScrollWheelInput();
 560
 561  public:
 562   // clang-format off
 563   MOZ_DEFINE_ENUM_AT_CLASS_SCOPE(
 564     ScrollDeltaType, (
 565       // There are three kinds of scroll delta modes in Gecko: "page", "line"
 566       // and "pixel".
 567       SCROLLDELTA_LINE,
 568       SCROLLDELTA_PAGE,
 569       SCROLLDELTA_PIXEL
 570   ));
 571
 572   MOZ_DEFINE_ENUM_AT_CLASS_SCOPE(
 573     ScrollMode, (
 574       SCROLLMODE_INSTANT,
 575       SCROLLMODE_SMOOTH
 576     )
 577   );
 578   // clang-format on
 579
 580   ScrollWheelInput(uint32_t aTime, TimeStamp aTimeStamp, Modifiers aModifiers,
 581                    ScrollMode aScrollMode, ScrollDeltaType aDeltaType,
 582                    const ScreenPoint& aOrigin, double aDeltaX, double aDeltaY,
 583                    bool aAllowToOverrideSystemScrollSpeed,
 584                    WheelDeltaAdjustmentStrategy aWheelDeltaAdjustmentStrategy);
 585   explicit ScrollWheelInput(const WidgetWheelEvent& aEvent);
 586
 587   static ScrollDeltaType DeltaTypeForDeltaMode(uint32_t aDeltaMode);
 588   static uint32_t DeltaModeForDeltaType(ScrollDeltaType aDeltaType);
 589   static nsIScrollableFrame::ScrollUnit ScrollUnitForDeltaType(
 590       ScrollDeltaType aDeltaType);
 591
 592   WidgetWheelEvent ToWidgetWheelEvent(nsIWidget* aWidget) const;
 593   bool TransformToLocal(const ScreenToParentLayerMatrix4x4& aTransform);
 594
 595   bool IsCustomizedByUserPrefs() const;
 596
 597   // The following two functions are for auto-dir scrolling. For detailed
 598   // information on auto-dir, @see mozilla::WheelDeltaAdjustmentStrategy
 599   bool IsAutoDir() const {
 600     switch (mWheelDeltaAdjustmentStrategy) {
 601       case WheelDeltaAdjustmentStrategy::eAutoDir:
 602       case WheelDeltaAdjustmentStrategy::eAutoDirWithRootHonour:
 603         return true;
 604       default:
 605         // Prevent compilation errors generated by -Werror=switch
 606         break;
 607     }
 608     return false;
 609   }
 610   // Indicates which element this scroll honours if it's an auto-dir scroll.
 611   // If true, honour the root element; otherwise, honour the currently scrolling
 612   // target.
 613   // Note that if IsAutoDir() returns false, then this function also returns
 614   // false, but false in this case is meaningless as IsAutoDir() indicates it's
 615   // not an auto-dir scroll.
 616   // For detailed information on auto-dir,
 617   // @see mozilla::WheelDeltaAdjustmentStrategy
 618   bool HonoursRoot() const {
 619     return WheelDeltaAdjustmentStrategy::eAutoDirWithRootHonour ==
 620            mWheelDeltaAdjustmentStrategy;
 621   }
 622
 623   // Warning, this class is serialized and sent over IPC. Any change to its
 624   // fields must be reflected in its ParamTraits<>, in nsGUIEventIPC.h
 625   ScrollDeltaType mDeltaType;
 626   ScrollMode mScrollMode;
 627   ScreenPoint mOrigin;
 628
 629   bool mHandledByAPZ;
 630
 631   // Deltas are in units corresponding to the delta type. For line deltas, they
 632   // are the number of line units to scroll. The number of device pixels for a
 633   // horizontal and vertical line unit are in FrameMetrics::mLineScrollAmount.
 634   // For pixel deltas, these values are in ScreenCoords.
 635   //
 636   // The horizontal (X) delta is > 0 for scrolling right and < 0 for scrolling
 637   // left. The vertical (Y) delta is < 0 for scrolling up and > 0 for
 638   // scrolling down.
 639   double mDeltaX;
 640   double mDeltaY;
 641
 642   // The location of the scroll in local coordinates. This is set and used by
 643   // APZ.
 644   ParentLayerPoint mLocalOrigin;
 645
 646   // See lineOrPageDeltaX/Y on WidgetWheelEvent.
 647   int32_t mLineOrPageDeltaX;
 648   int32_t mLineOrPageDeltaY;
 649
 650   // Indicates the order in which this event was added to a transaction. The
 651   // first event is 1; if not a member of a transaction, this is 0.
 652   uint32_t mScrollSeriesNumber;
 653
 654   // User-set delta multipliers.
 655   double mUserDeltaMultiplierX;
 656   double mUserDeltaMultiplierY;
 657
 658   bool mMayHaveMomentum;
 659   bool mIsMomentum;
 660   bool mAllowToOverrideSystemScrollSpeed;
 661
 662   // Sometimes a wheel event input's wheel delta should be adjusted. This member
 663   // specifies how to adjust the wheel delta.
 664   WheelDeltaAdjustmentStrategy mWheelDeltaAdjustmentStrategy;
 665
 666   APZWheelAction mAPZAction;
 667 };
 668
 669 class KeyboardInput : public InputData {
 670  public:
 671   typedef mozilla::layers::KeyboardScrollAction KeyboardScrollAction;
 672
 673   // Note that if you change the first member in this enum(I.e. KEY_DOWN) to one
 674   // other member, don't forget to update the minimum value in
 675   // ContiguousEnumSerializer for KeyboardEventType in widget/nsGUIEventIPC
 676   // accordingly.
 677   enum KeyboardEventType {
 678     KEY_DOWN,
 679     KEY_PRESS,
 680     KEY_UP,
 681     // Any other key event such as eKeyDownOnPlugin
 682     KEY_OTHER,
 683
 684     // Used as an upper bound for ContiguousEnumSerializer
 685     KEY_SENTINEL,
 686   };
 687
 688   explicit KeyboardInput(const WidgetKeyboardEvent& aEvent);
 689
 690   // Warning, this class is serialized and sent over IPC. Any change to its
 691   // fields must be reflected in its ParamTraits<>, in nsGUIEventIPC.h
 692
 693   KeyboardEventType mType;
 694   uint32_t mKeyCode;
 695   uint32_t mCharCode;
 696   nsTArray<ShortcutKeyCandidate> mShortcutCandidates;
 697
 698   bool mHandledByAPZ;
 699
 700   // The scroll action to perform on a layer for this keyboard input. This is
 701   // only used in APZ and is NOT serialized over IPC.
 702   KeyboardScrollAction mAction;
 703
 704  protected:
 705   friend mozilla::layers::APZInputBridgeChild;
 706   friend mozilla::layers::PAPZInputBridgeParent;
 707
 708   KeyboardInput();
 709 };
 710
 711 }  // namespace mozilla
 712
 713 #endif  // InputData_h__