widget/InputData.cpp

   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 #include "InputData.h"
   7
   8 #include "mozilla/dom/MouseEventBinding.h"
   9 #include "mozilla/dom/Touch.h"
  10 #include "mozilla/dom/WheelEventBinding.h"
  11 #include "mozilla/TextEvents.h"
  12 #include "nsContentUtils.h"
  13 #include "nsDebug.h"
  14 #include "nsThreadUtils.h"
  15 #include "mozilla/MouseEvents.h"
  16 #include "mozilla/TouchEvents.h"
  17 #include "UnitTransforms.h"
  18
  19 namespace mozilla {
  20
  21 using namespace dom;
  22
  23 InputData::~InputData() = default;
  24
  25 InputData::InputData(InputType aInputType)
  26     : mInputType(aInputType),
  27       mTime(0),
  28       mFocusSequenceNumber(0),
  29       mLayersId{0},
  30       modifiers(0) {}
  31
  32 InputData::InputData(InputType aInputType, uint32_t aTime, TimeStamp aTimeStamp,
  33                      Modifiers aModifiers)
  34     : mInputType(aInputType),
  35       mTime(aTime),
  36       mTimeStamp(aTimeStamp),
  37       mFocusSequenceNumber(0),
  38       mLayersId{0},
  39       modifiers(aModifiers) {}
  40
  41 SingleTouchData::SingleTouchData(int32_t aIdentifier,
  42                                  ScreenIntPoint aScreenPoint,
  43                                  ScreenSize aRadius, float aRotationAngle,
  44                                  float aForce)
  45     : mIdentifier(aIdentifier),
  46       mScreenPoint(aScreenPoint),
  47       mRadius(aRadius),
  48       mRotationAngle(aRotationAngle),
  49       mForce(aForce) {}
  50
  51 SingleTouchData::SingleTouchData(int32_t aIdentifier,
  52                                  ParentLayerPoint aLocalScreenPoint,
  53                                  ScreenSize aRadius, float aRotationAngle,
  54                                  float aForce)
  55     : mIdentifier(aIdentifier),
  56       mLocalScreenPoint(aLocalScreenPoint),
  57       mRadius(aRadius),
  58       mRotationAngle(aRotationAngle),
  59       mForce(aForce) {}
  60
  61 SingleTouchData::SingleTouchData()
  62     : mIdentifier(0), mRotationAngle(0.0), mForce(0.0) {}
  63
  64 already_AddRefed<Touch> SingleTouchData::ToNewDOMTouch() const {
  65   MOZ_ASSERT(NS_IsMainThread(),
  66              "Can only create dom::Touch instances on main thread");
  67   RefPtr<Touch> touch =
  68       new Touch(mIdentifier,
  69                 LayoutDeviceIntPoint::Truncate(mScreenPoint.x, mScreenPoint.y),
  70                 LayoutDeviceIntPoint::Truncate(mRadius.width, mRadius.height),
  71                 mRotationAngle, mForce);
  72   return touch.forget();
  73 }
  74
  75 MultiTouchInput::MultiTouchInput(MultiTouchType aType, uint32_t aTime,
  76                                  TimeStamp aTimeStamp, Modifiers aModifiers)
  77     : InputData(MULTITOUCH_INPUT, aTime, aTimeStamp, aModifiers),
  78       mType(aType),
  79       mHandledByAPZ(false) {}
  80
  81 MultiTouchInput::MultiTouchInput()
  82     : InputData(MULTITOUCH_INPUT),
  83       mType(MULTITOUCH_START),
  84       mHandledByAPZ(false) {}
  85
  86 MultiTouchInput::MultiTouchInput(const MultiTouchInput& aOther)
  87     : InputData(MULTITOUCH_INPUT, aOther.mTime, aOther.mTimeStamp,
  88                 aOther.modifiers),
  89       mType(aOther.mType),
  90       mScreenOffset(aOther.mScreenOffset),
  91       mHandledByAPZ(aOther.mHandledByAPZ) {
  92   mTouches.AppendElements(aOther.mTouches);
  93 }
  94
  95 MultiTouchInput::MultiTouchInput(const WidgetTouchEvent& aTouchEvent)
  96     : InputData(MULTITOUCH_INPUT, aTouchEvent.mTime, aTouchEvent.mTimeStamp,
  97                 aTouchEvent.mModifiers),
  98       mHandledByAPZ(aTouchEvent.mFlags.mHandledByAPZ) {
  99   MOZ_ASSERT(NS_IsMainThread(),
 100              "Can only copy from WidgetTouchEvent on main thread");
 101
 102   switch (aTouchEvent.mMessage) {
 103     case eTouchStart:
 104       mType = MULTITOUCH_START;
 105       break;
 106     case eTouchMove:
 107       mType = MULTITOUCH_MOVE;
 108       break;
 109     case eTouchEnd:
 110       mType = MULTITOUCH_END;
 111       break;
 112     case eTouchCancel:
 113       mType = MULTITOUCH_CANCEL;
 114       break;
 115     default:
 116       MOZ_ASSERT_UNREACHABLE("Did not assign a type to a MultiTouchInput");
 117       break;
 118   }
 119
 120   mScreenOffset = ViewAs<ExternalPixel>(
 121       aTouchEvent.mWidget->WidgetToScreenOffset(),
 122       PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent);
 123
 124   for (size_t i = 0; i < aTouchEvent.mTouches.Length(); i++) {
 125     const Touch* domTouch = aTouchEvent.mTouches[i];
 126
 127     // Extract data from weird interfaces.
 128     int32_t identifier = domTouch->Identifier();
 129     int32_t radiusX = domTouch->RadiusX(CallerType::System);
 130     int32_t radiusY = domTouch->RadiusY(CallerType::System);
 131     float rotationAngle = domTouch->RotationAngle(CallerType::System);
 132     float force = domTouch->Force(CallerType::System);
 133
 134     SingleTouchData data(
 135         identifier,
 136         ViewAs<ScreenPixel>(
 137             domTouch->mRefPoint,
 138             PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent),
 139         ScreenSize(radiusX, radiusY), rotationAngle, force);
 140
 141     mTouches.AppendElement(data);
 142   }
 143 }
 144
 145 void MultiTouchInput::Translate(const ScreenPoint& aTranslation) {
 146   const int32_t xTranslation = (int32_t)(aTranslation.x + 0.5f);
 147   const int32_t yTranslation = (int32_t)(aTranslation.y + 0.5f);
 148
 149   for (auto iter = mTouches.begin(); iter != mTouches.end(); iter++) {
 150     iter->mScreenPoint.MoveBy(xTranslation, yTranslation);
 151   }
 152 }
 153
 154 WidgetTouchEvent MultiTouchInput::ToWidgetTouchEvent(nsIWidget* aWidget) const {
 155   MOZ_ASSERT(NS_IsMainThread(),
 156              "Can only convert To WidgetTouchEvent on main thread");
 157
 158   EventMessage touchEventMessage = eVoidEvent;
 159   switch (mType) {
 160     case MULTITOUCH_START:
 161       touchEventMessage = eTouchStart;
 162       break;
 163     case MULTITOUCH_MOVE:
 164       touchEventMessage = eTouchMove;
 165       break;
 166     case MULTITOUCH_END:
 167       touchEventMessage = eTouchEnd;
 168       break;
 169     case MULTITOUCH_CANCEL:
 170       touchEventMessage = eTouchCancel;
 171       break;
 172     default:
 173       MOZ_ASSERT_UNREACHABLE(
 174           "Did not assign a type to WidgetTouchEvent in MultiTouchInput");
 175       break;
 176   }
 177
 178   WidgetTouchEvent event(true, touchEventMessage, aWidget);
 179   if (touchEventMessage == eVoidEvent) {
 180     return event;
 181   }
 182
 183   event.mModifiers = this->modifiers;
 184   event.mTime = this->mTime;
 185   event.mTimeStamp = this->mTimeStamp;
 186   event.mFlags.mHandledByAPZ = mHandledByAPZ;
 187   event.mFocusSequenceNumber = mFocusSequenceNumber;
 188
 189   for (size_t i = 0; i < mTouches.Length(); i++) {
 190     *event.mTouches.AppendElement() = mTouches[i].ToNewDOMTouch();
 191   }
 192
 193   return event;
 194 }
 195
 196 WidgetMouseEvent MultiTouchInput::ToWidgetMouseEvent(nsIWidget* aWidget) const {
 197   MOZ_ASSERT(NS_IsMainThread(),
 198              "Can only convert To WidgetMouseEvent on main thread");
 199
 200   EventMessage mouseEventMessage = eVoidEvent;
 201   switch (mType) {
 202     case MultiTouchInput::MULTITOUCH_START:
 203       mouseEventMessage = eMouseDown;
 204       break;
 205     case MultiTouchInput::MULTITOUCH_MOVE:
 206       mouseEventMessage = eMouseMove;
 207       break;
 208     case MultiTouchInput::MULTITOUCH_CANCEL:
 209     case MultiTouchInput::MULTITOUCH_END:
 210       mouseEventMessage = eMouseUp;
 211       break;
 212     default:
 213       MOZ_ASSERT_UNREACHABLE("Did not assign a type to WidgetMouseEvent");
 214       break;
 215   }
 216
 217   WidgetMouseEvent event(true, mouseEventMessage, aWidget,
 218                          WidgetMouseEvent::eReal, WidgetMouseEvent::eNormal);
 219
 220   const SingleTouchData& firstTouch = mTouches[0];
 221   event.mRefPoint.x = firstTouch.mScreenPoint.x;
 222   event.mRefPoint.y = firstTouch.mScreenPoint.y;
 223
 224   event.mTime = mTime;
 225   event.mButton = MouseButton::eLeft;
 226   event.mInputSource = MouseEvent_Binding::MOZ_SOURCE_TOUCH;
 227   event.mModifiers = modifiers;
 228   event.mFlags.mHandledByAPZ = mHandledByAPZ;
 229   event.mFocusSequenceNumber = mFocusSequenceNumber;
 230
 231   if (mouseEventMessage != eMouseMove) {
 232     event.mClickCount = 1;
 233   }
 234
 235   return event;
 236 }
 237
 238 int32_t MultiTouchInput::IndexOfTouch(int32_t aTouchIdentifier) {
 239   for (size_t i = 0; i < mTouches.Length(); i++) {
 240     if (mTouches[i].mIdentifier == aTouchIdentifier) {
 241       return (int32_t)i;
 242     }
 243   }
 244   return -1;
 245 }
 246
 247 bool MultiTouchInput::TransformToLocal(
 248     const ScreenToParentLayerMatrix4x4& aTransform) {
 249   for (size_t i = 0; i < mTouches.Length(); i++) {
 250     Maybe<ParentLayerIntPoint> point =
 251         UntransformBy(aTransform, mTouches[i].mScreenPoint);
 252     if (!point) {
 253       return false;
 254     }
 255     mTouches[i].mLocalScreenPoint = *point;
 256   }
 257   return true;
 258 }
 259
 260 MouseInput::MouseInput()
 261     : InputData(MOUSE_INPUT),
 262       mType(MOUSE_NONE),
 263       mButtonType(NONE),
 264       mInputSource(0),
 265       mButtons(0),
 266       mHandledByAPZ(false) {}
 267
 268 MouseInput::MouseInput(MouseType aType, ButtonType aButtonType,
 269                        uint16_t aInputSource, int16_t aButtons,
 270                        const ScreenPoint& aPoint, uint32_t aTime,
 271                        TimeStamp aTimeStamp, Modifiers aModifiers)
 272     : InputData(MOUSE_INPUT, aTime, aTimeStamp, aModifiers),
 273       mType(aType),
 274       mButtonType(aButtonType),
 275       mInputSource(aInputSource),
 276       mButtons(aButtons),
 277       mOrigin(aPoint),
 278       mHandledByAPZ(false) {}
 279
 280 MouseInput::MouseInput(const WidgetMouseEventBase& aMouseEvent)
 281     : InputData(MOUSE_INPUT, aMouseEvent.mTime, aMouseEvent.mTimeStamp,
 282                 aMouseEvent.mModifiers),
 283       mType(MOUSE_NONE),
 284       mButtonType(NONE),
 285       mInputSource(aMouseEvent.mInputSource),
 286       mButtons(aMouseEvent.mButtons),
 287       mHandledByAPZ(aMouseEvent.mFlags.mHandledByAPZ) {
 288   MOZ_ASSERT(NS_IsMainThread(),
 289              "Can only copy from WidgetTouchEvent on main thread");
 290
 291   mButtonType = NONE;
 292
 293   switch (aMouseEvent.mButton) {
 294     case MouseButton::eLeft:
 295       mButtonType = MouseInput::LEFT_BUTTON;
 296       break;
 297     case MouseButton::eMiddle:
 298       mButtonType = MouseInput::MIDDLE_BUTTON;
 299       break;
 300     case MouseButton::eRight:
 301       mButtonType = MouseInput::RIGHT_BUTTON;
 302       break;
 303   }
 304
 305   switch (aMouseEvent.mMessage) {
 306     case eMouseMove:
 307       mType = MOUSE_MOVE;
 308       break;
 309     case eMouseUp:
 310       mType = MOUSE_UP;
 311       break;
 312     case eMouseDown:
 313       mType = MOUSE_DOWN;
 314       break;
 315     case eDragStart:
 316       mType = MOUSE_DRAG_START;
 317       break;
 318     case eDragEnd:
 319       mType = MOUSE_DRAG_END;
 320       break;
 321     case eMouseEnterIntoWidget:
 322       mType = MOUSE_WIDGET_ENTER;
 323       break;
 324     case eMouseExitFromWidget:
 325       mType = MOUSE_WIDGET_EXIT;
 326       break;
 327     case eMouseHitTest:
 328       mType = MOUSE_HITTEST;
 329       break;
 330     default:
 331       MOZ_ASSERT_UNREACHABLE("Mouse event type not supported");
 332       break;
 333   }
 334
 335   mOrigin = ScreenPoint(ViewAs<ScreenPixel>(
 336       aMouseEvent.mRefPoint,
 337       PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
 338 }
 339
 340 bool MouseInput::IsLeftButton() const { return mButtonType == LEFT_BUTTON; }
 341
 342 bool MouseInput::TransformToLocal(
 343     const ScreenToParentLayerMatrix4x4& aTransform) {
 344   Maybe<ParentLayerPoint> point = UntransformBy(aTransform, mOrigin);
 345   if (!point) {
 346     return false;
 347   }
 348   mLocalOrigin = *point;
 349
 350   return true;
 351 }
 352
 353 WidgetMouseEvent MouseInput::ToWidgetMouseEvent(nsIWidget* aWidget) const {
 354   MOZ_ASSERT(NS_IsMainThread(),
 355              "Can only convert To WidgetTouchEvent on main thread");
 356
 357   EventMessage msg = eVoidEvent;
 358   uint32_t clickCount = 0;
 359   switch (mType) {
 360     case MOUSE_MOVE:
 361       msg = eMouseMove;
 362       break;
 363     case MOUSE_UP:
 364       msg = eMouseUp;
 365       clickCount = 1;
 366       break;
 367     case MOUSE_DOWN:
 368       msg = eMouseDown;
 369       clickCount = 1;
 370       break;
 371     case MOUSE_DRAG_START:
 372       msg = eDragStart;
 373       break;
 374     case MOUSE_DRAG_END:
 375       msg = eDragEnd;
 376       break;
 377     case MOUSE_WIDGET_ENTER:
 378       msg = eMouseEnterIntoWidget;
 379       break;
 380     case MOUSE_WIDGET_EXIT:
 381       msg = eMouseExitFromWidget;
 382       break;
 383     case MOUSE_HITTEST:
 384       msg = eMouseHitTest;
 385       break;
 386     default:
 387       MOZ_ASSERT_UNREACHABLE(
 388           "Did not assign a type to WidgetMouseEvent in MouseInput");
 389       break;
 390   }
 391
 392   WidgetMouseEvent event(true, msg, aWidget, WidgetMouseEvent::eReal,
 393                          WidgetMouseEvent::eNormal);
 394
 395   if (msg == eVoidEvent) {
 396     return event;
 397   }
 398
 399   switch (mButtonType) {
 400     case MouseInput::LEFT_BUTTON:
 401       event.mButton = MouseButton::eLeft;
 402       break;
 403     case MouseInput::MIDDLE_BUTTON:
 404       event.mButton = MouseButton::eMiddle;
 405       break;
 406     case MouseInput::RIGHT_BUTTON:
 407       event.mButton = MouseButton::eRight;
 408       break;
 409     case MouseInput::NONE:
 410     default:
 411       break;
 412   }
 413
 414   event.mButtons = mButtons;
 415   event.mModifiers = modifiers;
 416   event.mTime = mTime;
 417   event.mTimeStamp = mTimeStamp;
 418   event.mFlags.mHandledByAPZ = mHandledByAPZ;
 419   event.mRefPoint = RoundedToInt(ViewAs<LayoutDevicePixel>(
 420       mOrigin,
 421       PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
 422   event.mClickCount = clickCount;
 423   event.mInputSource = mInputSource;
 424   event.mIgnoreRootScrollFrame = true;
 425   event.mFocusSequenceNumber = mFocusSequenceNumber;
 426
 427   return event;
 428 }
 429
 430 PanGestureInput::PanGestureInput()
 431     : InputData(PANGESTURE_INPUT),
 432       mType(PANGESTURE_MAYSTART),
 433       mLineOrPageDeltaX(0),
 434       mLineOrPageDeltaY(0),
 435       mUserDeltaMultiplierX(1.0),
 436       mUserDeltaMultiplierY(1.0),
 437       mHandledByAPZ(false),
 438       mFollowedByMomentum(false),
 439       mRequiresContentResponseIfCannotScrollHorizontallyInStartDirection(false),
 440       mOverscrollBehaviorAllowsSwipe(false),
 441       mSimulateMomentum(false) {}
 442
 443 PanGestureInput::PanGestureInput(PanGestureType aType, uint32_t aTime,
 444                                  TimeStamp aTimeStamp,
 445                                  const ScreenPoint& aPanStartPoint,
 446                                  const ScreenPoint& aPanDisplacement,
 447                                  Modifiers aModifiers)
 448     : InputData(PANGESTURE_INPUT, aTime, aTimeStamp, aModifiers),
 449       mType(aType),
 450       mPanStartPoint(aPanStartPoint),
 451       mPanDisplacement(aPanDisplacement),
 452       mLineOrPageDeltaX(0),
 453       mLineOrPageDeltaY(0),
 454       mUserDeltaMultiplierX(1.0),
 455       mUserDeltaMultiplierY(1.0),
 456       mHandledByAPZ(false),
 457       mFollowedByMomentum(false),
 458       mRequiresContentResponseIfCannotScrollHorizontallyInStartDirection(false),
 459       mOverscrollBehaviorAllowsSwipe(false),
 460       mSimulateMomentum(false) {}
 461
 462 bool PanGestureInput::IsMomentum() const {
 463   switch (mType) {
 464     case PanGestureInput::PANGESTURE_MOMENTUMSTART:
 465     case PanGestureInput::PANGESTURE_MOMENTUMPAN:
 466     case PanGestureInput::PANGESTURE_MOMENTUMEND:
 467       return true;
 468     default:
 469       return false;
 470   }
 471 }
 472
 473 WidgetWheelEvent PanGestureInput::ToWidgetWheelEvent(nsIWidget* aWidget) const {
 474   WidgetWheelEvent wheelEvent(true, eWheel, aWidget);
 475   wheelEvent.mModifiers = this->modifiers;
 476   wheelEvent.mTime = mTime;
 477   wheelEvent.mTimeStamp = mTimeStamp;
 478   wheelEvent.mRefPoint = RoundedToInt(ViewAs<LayoutDevicePixel>(
 479       mPanStartPoint,
 480       PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
 481   wheelEvent.mButtons = 0;
 482   wheelEvent.mMayHaveMomentum = true;  // pan inputs may have momentum
 483   wheelEvent.mIsMomentum = IsMomentum();
 484   wheelEvent.mLineOrPageDeltaX = mLineOrPageDeltaX;
 485   wheelEvent.mLineOrPageDeltaY = mLineOrPageDeltaY;
 486   wheelEvent.mDeltaX = mPanDisplacement.x;
 487   wheelEvent.mDeltaY = mPanDisplacement.y;
 488   wheelEvent.mFlags.mHandledByAPZ = mHandledByAPZ;
 489   wheelEvent.mFocusSequenceNumber = mFocusSequenceNumber;
 490   if (mDeltaType == PanGestureInput::PANDELTA_PAGE) {
 491     // Emulate legacy widget/gtk behavior
 492     wheelEvent.mDeltaMode = WheelEvent_Binding::DOM_DELTA_LINE;
 493     wheelEvent.mIsNoLineOrPageDelta = true;
 494     wheelEvent.mScrollType = WidgetWheelEvent::SCROLL_ASYNCHRONOUSELY;
 495     wheelEvent.mDeltaX *= 3;
 496     wheelEvent.mDeltaY *= 3;
 497   } else {
 498     wheelEvent.mDeltaMode = WheelEvent_Binding::DOM_DELTA_PIXEL;
 499   }
 500   return wheelEvent;
 501 }
 502
 503 bool PanGestureInput::TransformToLocal(
 504     const ScreenToParentLayerMatrix4x4& aTransform) {
 505   Maybe<ParentLayerPoint> panStartPoint =
 506       UntransformBy(aTransform, mPanStartPoint);
 507   if (!panStartPoint) {
 508     return false;
 509   }
 510   mLocalPanStartPoint = *panStartPoint;
 511
 512   if (mDeltaType == PanGestureInput::PANDELTA_PAGE) {
 513     // Skip transforming the pan displacement because we want
 514     // raw page proportion counts.
 515     mLocalPanDisplacement.x = mPanDisplacement.x;
 516     mLocalPanDisplacement.y = mPanDisplacement.y;
 517     return true;
 518   }
 519
 520   Maybe<ParentLayerPoint> panDisplacement =
 521       UntransformVector(aTransform, mPanDisplacement, mPanStartPoint);
 522   if (!panDisplacement) {
 523     return false;
 524   }
 525   mLocalPanDisplacement = *panDisplacement;
 526   return true;
 527 }
 528
 529 ScreenPoint PanGestureInput::UserMultipliedPanDisplacement() const {
 530   return ScreenPoint(mPanDisplacement.x * mUserDeltaMultiplierX,
 531                      mPanDisplacement.y * mUserDeltaMultiplierY);
 532 }
 533
 534 ParentLayerPoint PanGestureInput::UserMultipliedLocalPanDisplacement() const {
 535   return ParentLayerPoint(mLocalPanDisplacement.x * mUserDeltaMultiplierX,
 536                           mLocalPanDisplacement.y * mUserDeltaMultiplierY);
 537 }
 538
 539 PinchGestureInput::PinchGestureInput()
 540     : InputData(PINCHGESTURE_INPUT), mType(PINCHGESTURE_START) {}
 541
 542 PinchGestureInput::PinchGestureInput(
 543     PinchGestureType aType, uint32_t aTime, TimeStamp aTimeStamp,
 544     const ExternalPoint& aScreenOffset, const ScreenPoint& aFocusPoint,
 545     ScreenCoord aCurrentSpan, ScreenCoord aPreviousSpan, Modifiers aModifiers)
 546     : InputData(PINCHGESTURE_INPUT, aTime, aTimeStamp, aModifiers),
 547       mType(aType),
 548       mFocusPoint(aFocusPoint),
 549       mScreenOffset(aScreenOffset),
 550       mCurrentSpan(aCurrentSpan),
 551       mPreviousSpan(aPreviousSpan) {}
 552
 553 bool PinchGestureInput::TransformToLocal(
 554     const ScreenToParentLayerMatrix4x4& aTransform) {
 555   if (mFocusPoint == BothFingersLifted<ScreenPixel>()) {
 556     // Special value, no transform required.
 557     mLocalFocusPoint = BothFingersLifted();
 558     return true;
 559   }
 560   Maybe<ParentLayerPoint> point = UntransformBy(aTransform, mFocusPoint);
 561   if (!point) {
 562     return false;
 563   }
 564   mLocalFocusPoint = *point;
 565   return true;
 566 }
 567
 568 TapGestureInput::TapGestureInput()
 569     : InputData(TAPGESTURE_INPUT), mType(TAPGESTURE_LONG) {}
 570
 571 TapGestureInput::TapGestureInput(TapGestureType aType, uint32_t aTime,
 572                                  TimeStamp aTimeStamp,
 573                                  const ScreenIntPoint& aPoint,
 574                                  Modifiers aModifiers)
 575     : InputData(TAPGESTURE_INPUT, aTime, aTimeStamp, aModifiers),
 576       mType(aType),
 577       mPoint(aPoint) {}
 578
 579 TapGestureInput::TapGestureInput(TapGestureType aType, uint32_t aTime,
 580                                  TimeStamp aTimeStamp,
 581                                  const ParentLayerPoint& aLocalPoint,
 582                                  Modifiers aModifiers)
 583     : InputData(TAPGESTURE_INPUT, aTime, aTimeStamp, aModifiers),
 584       mType(aType),
 585       mLocalPoint(aLocalPoint) {}
 586
 587 bool TapGestureInput::TransformToLocal(
 588     const ScreenToParentLayerMatrix4x4& aTransform) {
 589   Maybe<ParentLayerIntPoint> point = UntransformBy(aTransform, mPoint);
 590   if (!point) {
 591     return false;
 592   }
 593   mLocalPoint = *point;
 594   return true;
 595 }
 596
 597 ScrollWheelInput::ScrollWheelInput()
 598     : InputData(SCROLLWHEEL_INPUT),
 599       mDeltaType(SCROLLDELTA_LINE),
 600       mScrollMode(SCROLLMODE_INSTANT),
 601       mHandledByAPZ(false),
 602       mDeltaX(0.0),
 603       mDeltaY(0.0),
 604       mLineOrPageDeltaX(0),
 605       mLineOrPageDeltaY(0),
 606       mScrollSeriesNumber(0),
 607       mUserDeltaMultiplierX(1.0),
 608       mUserDeltaMultiplierY(1.0),
 609       mMayHaveMomentum(false),
 610       mIsMomentum(false),
 611       mAPZAction(APZWheelAction::Scroll) {}
 612
 613 ScrollWheelInput::ScrollWheelInput(
 614     uint32_t aTime, TimeStamp aTimeStamp, Modifiers aModifiers,
 615     ScrollMode aScrollMode, ScrollDeltaType aDeltaType,
 616     const ScreenPoint& aOrigin, double aDeltaX, double aDeltaY,
 617     bool aAllowToOverrideSystemScrollSpeed,
 618     WheelDeltaAdjustmentStrategy aWheelDeltaAdjustmentStrategy)
 619     : InputData(SCROLLWHEEL_INPUT, aTime, aTimeStamp, aModifiers),
 620       mDeltaType(aDeltaType),
 621       mScrollMode(aScrollMode),
 622       mOrigin(aOrigin),
 623       mHandledByAPZ(false),
 624       mDeltaX(aDeltaX),
 625       mDeltaY(aDeltaY),
 626       mLineOrPageDeltaX(0),
 627       mLineOrPageDeltaY(0),
 628       mScrollSeriesNumber(0),
 629       mUserDeltaMultiplierX(1.0),
 630       mUserDeltaMultiplierY(1.0),
 631       mMayHaveMomentum(false),
 632       mIsMomentum(false),
 633       mAllowToOverrideSystemScrollSpeed(aAllowToOverrideSystemScrollSpeed),
 634       mWheelDeltaAdjustmentStrategy(aWheelDeltaAdjustmentStrategy),
 635       mAPZAction(APZWheelAction::Scroll) {}
 636
 637 ScrollWheelInput::ScrollWheelInput(const WidgetWheelEvent& aWheelEvent)
 638     : InputData(SCROLLWHEEL_INPUT, aWheelEvent.mTime, aWheelEvent.mTimeStamp,
 639                 aWheelEvent.mModifiers),
 640       mDeltaType(DeltaTypeForDeltaMode(aWheelEvent.mDeltaMode)),
 641       mScrollMode(SCROLLMODE_INSTANT),
 642       mHandledByAPZ(aWheelEvent.mFlags.mHandledByAPZ),
 643       mDeltaX(aWheelEvent.mDeltaX),
 644       mDeltaY(aWheelEvent.mDeltaY),
 645       mLineOrPageDeltaX(aWheelEvent.mLineOrPageDeltaX),
 646       mLineOrPageDeltaY(aWheelEvent.mLineOrPageDeltaY),
 647       mScrollSeriesNumber(0),
 648       mUserDeltaMultiplierX(1.0),
 649       mUserDeltaMultiplierY(1.0),
 650       mMayHaveMomentum(aWheelEvent.mMayHaveMomentum),
 651       mIsMomentum(aWheelEvent.mIsMomentum),
 652       mAllowToOverrideSystemScrollSpeed(
 653           aWheelEvent.mAllowToOverrideSystemScrollSpeed),
 654       mWheelDeltaAdjustmentStrategy(WheelDeltaAdjustmentStrategy::eNone),
 655       mAPZAction(APZWheelAction::Scroll) {
 656   mOrigin = ScreenPoint(ViewAs<ScreenPixel>(
 657       aWheelEvent.mRefPoint,
 658       PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
 659 }
 660
 661 ScrollWheelInput::ScrollDeltaType ScrollWheelInput::DeltaTypeForDeltaMode(
 662     uint32_t aDeltaMode) {
 663   switch (aDeltaMode) {
 664     case WheelEvent_Binding::DOM_DELTA_LINE:
 665       return SCROLLDELTA_LINE;
 666     case WheelEvent_Binding::DOM_DELTA_PAGE:
 667       return SCROLLDELTA_PAGE;
 668     case WheelEvent_Binding::DOM_DELTA_PIXEL:
 669       return SCROLLDELTA_PIXEL;
 670     default:
 671       MOZ_CRASH();
 672   }
 673   return SCROLLDELTA_LINE;
 674 }
 675
 676 uint32_t ScrollWheelInput::DeltaModeForDeltaType(ScrollDeltaType aDeltaType) {
 677   switch (aDeltaType) {
 678     case ScrollWheelInput::SCROLLDELTA_LINE:
 679       return WheelEvent_Binding::DOM_DELTA_LINE;
 680     case ScrollWheelInput::SCROLLDELTA_PAGE:
 681       return WheelEvent_Binding::DOM_DELTA_PAGE;
 682     case ScrollWheelInput::SCROLLDELTA_PIXEL:
 683     default:
 684       return WheelEvent_Binding::DOM_DELTA_PIXEL;
 685   }
 686 }
 687
 688 ScrollUnit ScrollWheelInput::ScrollUnitForDeltaType(
 689     ScrollDeltaType aDeltaType) {
 690   switch (aDeltaType) {
 691     case SCROLLDELTA_LINE:
 692       return ScrollUnit::LINES;
 693     case SCROLLDELTA_PAGE:
 694       return ScrollUnit::PAGES;
 695     case SCROLLDELTA_PIXEL:
 696       return ScrollUnit::DEVICE_PIXELS;
 697     default:
 698       MOZ_CRASH();
 699   }
 700   return ScrollUnit::LINES;
 701 }
 702
 703 WidgetWheelEvent ScrollWheelInput::ToWidgetWheelEvent(
 704     nsIWidget* aWidget) const {
 705   WidgetWheelEvent wheelEvent(true, eWheel, aWidget);
 706   wheelEvent.mModifiers = this->modifiers;
 707   wheelEvent.mTime = mTime;
 708   wheelEvent.mTimeStamp = mTimeStamp;
 709   wheelEvent.mRefPoint = RoundedToInt(ViewAs<LayoutDevicePixel>(
 710       mOrigin,
 711       PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
 712   wheelEvent.mButtons = 0;
 713   wheelEvent.mDeltaMode = DeltaModeForDeltaType(mDeltaType);
 714   wheelEvent.mMayHaveMomentum = mMayHaveMomentum;
 715   wheelEvent.mIsMomentum = mIsMomentum;
 716   wheelEvent.mDeltaX = mDeltaX;
 717   wheelEvent.mDeltaY = mDeltaY;
 718   wheelEvent.mLineOrPageDeltaX = mLineOrPageDeltaX;
 719   wheelEvent.mLineOrPageDeltaY = mLineOrPageDeltaY;
 720   wheelEvent.mAllowToOverrideSystemScrollSpeed =
 721       mAllowToOverrideSystemScrollSpeed;
 722   wheelEvent.mFlags.mHandledByAPZ = mHandledByAPZ;
 723   wheelEvent.mFocusSequenceNumber = mFocusSequenceNumber;
 724   return wheelEvent;
 725 }
 726
 727 bool ScrollWheelInput::TransformToLocal(
 728     const ScreenToParentLayerMatrix4x4& aTransform) {
 729   Maybe<ParentLayerPoint> point = UntransformBy(aTransform, mOrigin);
 730   if (!point) {
 731     return false;
 732   }
 733   mLocalOrigin = *point;
 734   return true;
 735 }
 736
 737 bool ScrollWheelInput::IsCustomizedByUserPrefs() const {
 738   return mUserDeltaMultiplierX != 1.0 || mUserDeltaMultiplierY != 1.0;
 739 }
 740
 741 KeyboardInput::KeyboardInput(const WidgetKeyboardEvent& aEvent)
 742     : InputData(KEYBOARD_INPUT, aEvent.mTime, aEvent.mTimeStamp,
 743                 aEvent.mModifiers),
 744       mKeyCode(aEvent.mKeyCode),
 745       mCharCode(aEvent.mCharCode),
 746       mHandledByAPZ(false) {
 747   switch (aEvent.mMessage) {
 748     case eKeyPress: {
 749       mType = KeyboardInput::KEY_PRESS;
 750       break;
 751     }
 752     case eKeyUp: {
 753       mType = KeyboardInput::KEY_UP;
 754       break;
 755     }
 756     case eKeyDown: {
 757       mType = KeyboardInput::KEY_DOWN;
 758       break;
 759     }
 760     default:
 761       mType = KeyboardInput::KEY_OTHER;
 762       break;
 763   }
 764
 765   aEvent.GetShortcutKeyCandidates(mShortcutCandidates);
 766 }
 767
 768 KeyboardInput::KeyboardInput()
 769     : InputData(KEYBOARD_INPUT),
 770       mType(KEY_DOWN),
 771       mKeyCode(0),
 772       mCharCode(0),
 773       mHandledByAPZ(false) {}
 774
 775 }  // namespace mozilla