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