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