widget/MouseEvents.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 mozilla_MouseEvents_h__
   7 #define mozilla_MouseEvents_h__
   8
   9 #include <stdint.h>
  10
  11 #include "mozilla/BasicEvents.h"
  12 #include "mozilla/MathAlgorithms.h"
  13 #include "mozilla/dom/DataTransfer.h"
  14 #include "mozilla/ipc/IPCForwards.h"
  15 #include "nsCOMPtr.h"
  16
  17 namespace mozilla {
  18
  19 namespace dom {
  20 class PBrowserParent;
  21 class PBrowserChild;
  22 class PBrowserBridgeParent;
  23 }  // namespace dom
  24
  25 class WidgetPointerEvent;
  26 }  // namespace mozilla
  27
  28 namespace mozilla {
  29 class WidgetPointerEventHolder final {
  30  public:
  31   nsTArray<WidgetPointerEvent> mEvents;
  32   NS_INLINE_DECL_REFCOUNTING(WidgetPointerEventHolder)
  33
  34  private:
  35   virtual ~WidgetPointerEventHolder() = default;
  36 };
  37
  38 /******************************************************************************
  39  * mozilla::WidgetPointerHelper
  40  ******************************************************************************/
  41
  42 class WidgetPointerHelper {
  43  public:
  44   uint32_t pointerId;
  45   int32_t tiltX;
  46   int32_t tiltY;
  47   int32_t twist;
  48   float tangentialPressure;
  49   bool convertToPointer;
  50   RefPtr<WidgetPointerEventHolder> mCoalescedWidgetEvents;
  51
  52   WidgetPointerHelper()
  53       : pointerId(0),
  54         tiltX(0),
  55         tiltY(0),
  56         twist(0),
  57         tangentialPressure(0),
  58         convertToPointer(true) {}
  59
  60   WidgetPointerHelper(uint32_t aPointerId, uint32_t aTiltX, uint32_t aTiltY,
  61                       uint32_t aTwist = 0, float aTangentialPressure = 0)
  62       : pointerId(aPointerId),
  63         tiltX(aTiltX),
  64         tiltY(aTiltY),
  65         twist(aTwist),
  66         tangentialPressure(aTangentialPressure),
  67         convertToPointer(true) {}
  68
  69   explicit WidgetPointerHelper(const WidgetPointerHelper& aHelper) = default;
  70
  71   void AssignPointerHelperData(const WidgetPointerHelper& aEvent,
  72                                bool aCopyCoalescedEvents = false) {
  73     pointerId = aEvent.pointerId;
  74     tiltX = aEvent.tiltX;
  75     tiltY = aEvent.tiltY;
  76     twist = aEvent.twist;
  77     tangentialPressure = aEvent.tangentialPressure;
  78     convertToPointer = aEvent.convertToPointer;
  79     if (aCopyCoalescedEvents) {
  80       mCoalescedWidgetEvents = aEvent.mCoalescedWidgetEvents;
  81     }
  82   }
  83 };
  84
  85 /******************************************************************************
  86  * mozilla::WidgetMouseEventBase
  87  ******************************************************************************/
  88
  89 class WidgetMouseEventBase : public WidgetInputEvent {
  90  private:
  91   friend class dom::PBrowserParent;
  92   friend class dom::PBrowserChild;
  93   friend class dom::PBrowserBridgeParent;
  94   ALLOW_DEPRECATED_READPARAM
  95
  96  protected:
  97   WidgetMouseEventBase()
  98       : mPressure(0),
  99         mButton(0),
 100         mButtons(0),
 101         mInputSource(/* MouseEvent_Binding::MOZ_SOURCE_MOUSE = */ 1) {}
 102   // Including MouseEventBinding.h here leads to an include loop, so
 103   // we have to hardcode MouseEvent_Binding::MOZ_SOURCE_MOUSE.
 104
 105   WidgetMouseEventBase(bool aIsTrusted, EventMessage aMessage,
 106                        nsIWidget* aWidget, EventClassID aEventClassID,
 107                        const WidgetEventTime* aTime = nullptr)
 108       : WidgetInputEvent(aIsTrusted, aMessage, aWidget, aEventClassID, aTime),
 109         mPressure(0),
 110         mButton(0),
 111         mButtons(0),
 112         mInputSource(/* MouseEvent_Binding::MOZ_SOURCE_MOUSE = */ 1) {}
 113   // Including MouseEventBinding.h here leads to an include loop, so
 114   // we have to hardcode MouseEvent_Binding::MOZ_SOURCE_MOUSE.
 115
 116  public:
 117   virtual WidgetMouseEventBase* AsMouseEventBase() override { return this; }
 118
 119   virtual WidgetEvent* Duplicate() const override {
 120     MOZ_CRASH("WidgetMouseEventBase must not be most-subclass");
 121   }
 122
 123   // Finger or touch pressure of event. It ranges between 0.0 and 1.0.
 124   float mPressure;
 125
 126   // Pressed button ID of mousedown or mouseup event.
 127   // This is set only when pressing a button causes the event.
 128   int16_t mButton;
 129
 130   // Flags of all pressed buttons at the event fired.
 131   // This is set at any mouse event, don't be confused with |mButton|.
 132   int16_t mButtons;
 133
 134   // Possible values a in MouseEvent
 135   uint16_t mInputSource;
 136
 137   bool IsLeftButtonPressed() const {
 138     return !!(mButtons & MouseButtonsFlag::ePrimaryFlag);
 139   }
 140   bool IsRightButtonPressed() const {
 141     return !!(mButtons & MouseButtonsFlag::eSecondaryFlag);
 142   }
 143   bool IsMiddleButtonPressed() const {
 144     return !!(mButtons & MouseButtonsFlag::eMiddleFlag);
 145   }
 146   bool Is4thButtonPressed() const {
 147     return !!(mButtons & MouseButtonsFlag::e4thFlag);
 148   }
 149   bool Is5thButtonPressed() const {
 150     return !!(mButtons & MouseButtonsFlag::e5thFlag);
 151   }
 152
 153   void AssignMouseEventBaseData(const WidgetMouseEventBase& aEvent,
 154                                 bool aCopyTargets) {
 155     AssignInputEventData(aEvent, aCopyTargets);
 156
 157     mButton = aEvent.mButton;
 158     mButtons = aEvent.mButtons;
 159     mPressure = aEvent.mPressure;
 160     mInputSource = aEvent.mInputSource;
 161   }
 162
 163   /**
 164    * Returns true if left click event.
 165    */
 166   bool IsLeftClickEvent() const {
 167     return mMessage == eMouseClick && mButton == MouseButton::ePrimary;
 168   }
 169 };
 170
 171 /******************************************************************************
 172  * mozilla::WidgetMouseEvent
 173  ******************************************************************************/
 174
 175 class WidgetMouseEvent : public WidgetMouseEventBase,
 176                          public WidgetPointerHelper {
 177  private:
 178   friend class dom::PBrowserParent;
 179   friend class dom::PBrowserChild;
 180   friend class dom::PBrowserBridgeParent;
 181   ALLOW_DEPRECATED_READPARAM
 182
 183  public:
 184   typedef bool ReasonType;
 185   enum Reason : ReasonType { eReal, eSynthesized };
 186
 187   typedef uint8_t ContextMenuTriggerType;
 188   enum ContextMenuTrigger : ContextMenuTriggerType {
 189     eNormal,
 190     eContextMenuKey,
 191     eControlClick
 192   };
 193
 194   typedef uint8_t ExitFromType;
 195   enum ExitFrom : ExitFromType {
 196     ePlatformChild,
 197     ePlatformTopLevel,
 198     ePuppet,
 199     ePuppetParentToPuppetChild
 200   };
 201
 202  protected:
 203   WidgetMouseEvent()
 204       : mReason(eReal),
 205         mContextMenuTrigger(eNormal),
 206         mClickCount(0),
 207         mIgnoreRootScrollFrame(false),
 208         mUseLegacyNonPrimaryDispatch(false),
 209         mClickEventPrevented(false) {}
 210
 211   WidgetMouseEvent(bool aIsTrusted, EventMessage aMessage, nsIWidget* aWidget,
 212                    EventClassID aEventClassID, Reason aReason,
 213                    const WidgetEventTime* aTime = nullptr)
 214       : WidgetMouseEventBase(aIsTrusted, aMessage, aWidget, aEventClassID,
 215                              aTime),
 216         mReason(aReason),
 217         mContextMenuTrigger(eNormal),
 218         mClickCount(0),
 219         mIgnoreRootScrollFrame(false),
 220         mUseLegacyNonPrimaryDispatch(false),
 221         mClickEventPrevented(false) {}
 222
 223 #ifdef DEBUG
 224   void AssertContextMenuEventButtonConsistency() const;
 225 #endif
 226
 227  public:
 228   virtual WidgetMouseEvent* AsMouseEvent() override { return this; }
 229
 230   WidgetMouseEvent(bool aIsTrusted, EventMessage aMessage, nsIWidget* aWidget,
 231                    Reason aReason,
 232                    ContextMenuTrigger aContextMenuTrigger = eNormal,
 233                    const WidgetEventTime* aTime = nullptr)
 234       : WidgetMouseEventBase(aIsTrusted, aMessage, aWidget, eMouseEventClass,
 235                              aTime),
 236         mReason(aReason),
 237         mContextMenuTrigger(aContextMenuTrigger),
 238         mClickCount(0),
 239         mIgnoreRootScrollFrame(false),
 240         mUseLegacyNonPrimaryDispatch(false),
 241         mClickEventPrevented(false) {
 242     if (aMessage == eContextMenu) {
 243       mButton = (mContextMenuTrigger == eNormal) ? MouseButton::eSecondary
 244                                                  : MouseButton::ePrimary;
 245     }
 246   }
 247
 248 #ifdef DEBUG
 249   virtual ~WidgetMouseEvent() { AssertContextMenuEventButtonConsistency(); }
 250 #endif
 251
 252   virtual WidgetEvent* Duplicate() const override {
 253     MOZ_ASSERT(mClass == eMouseEventClass,
 254                "Duplicate() must be overridden by sub class");
 255     // Not copying widget, it is a weak reference.
 256     WidgetMouseEvent* result = new WidgetMouseEvent(
 257         false, mMessage, nullptr, mReason, mContextMenuTrigger, this);
 258     result->AssignMouseEventData(*this, true);
 259     result->mFlags = mFlags;
 260     return result;
 261   }
 262
 263   // If during mouseup handling we detect that click event might need to be
 264   // dispatched, this is setup to be the target of the click event.
 265   nsCOMPtr<dom::EventTarget> mClickTarget;
 266
 267   // mReason indicates the reason why the event is fired:
 268   // - Representing mouse operation.
 269   // - Synthesized for emulating mousemove event when the content under the
 270   //   mouse cursor is scrolled.
 271   Reason mReason;
 272
 273   // mContextMenuTrigger is valid only when mMessage is eContextMenu.
 274   // This indicates if the context menu event is caused by context menu key or
 275   // other reasons (typically, a click of right mouse button).
 276   ContextMenuTrigger mContextMenuTrigger;
 277
 278   // mExitFrom contains a value only when mMessage is eMouseExitFromWidget.
 279   // This indicates if the mouse cursor exits from a top level platform widget,
 280   // a child widget or a puppet widget.
 281   Maybe<ExitFrom> mExitFrom;
 282
 283   // mClickCount may be non-zero value when mMessage is eMouseDown, eMouseUp,
 284   // eMouseClick or eMouseDoubleClick. The number is count of mouse clicks.
 285   // Otherwise, this must be 0.
 286   uint32_t mClickCount;
 287
 288   // Whether the event should ignore scroll frame bounds during dispatch.
 289   bool mIgnoreRootScrollFrame;
 290
 291   // Indicates whether the event should dispatch click events for non-primary
 292   // mouse buttons on window and document.
 293   bool mUseLegacyNonPrimaryDispatch;
 294
 295   // Whether the event shouldn't cause click event.
 296   bool mClickEventPrevented;
 297
 298   void AssignMouseEventData(const WidgetMouseEvent& aEvent, bool aCopyTargets) {
 299     AssignMouseEventBaseData(aEvent, aCopyTargets);
 300     AssignPointerHelperData(aEvent, /* aCopyCoalescedEvents */ true);
 301
 302     mExitFrom = aEvent.mExitFrom;
 303     mClickCount = aEvent.mClickCount;
 304     mIgnoreRootScrollFrame = aEvent.mIgnoreRootScrollFrame;
 305     mUseLegacyNonPrimaryDispatch = aEvent.mUseLegacyNonPrimaryDispatch;
 306     mClickEventPrevented = aEvent.mClickEventPrevented;
 307   }
 308
 309   /**
 310    * Returns true if the event is a context menu event caused by key.
 311    */
 312   bool IsContextMenuKeyEvent() const {
 313     return mMessage == eContextMenu && mContextMenuTrigger == eContextMenuKey;
 314   }
 315
 316   /**
 317    * Returns true if the event is a real mouse event.  Otherwise, i.e., it's
 318    * a synthesized event by scroll or something, returns false.
 319    */
 320   bool IsReal() const { return mReason == eReal; }
 321
 322   /**
 323    * Returns true if middle click paste is enabled.
 324    */
 325   static bool IsMiddleClickPasteEnabled();
 326 };
 327
 328 /******************************************************************************
 329  * mozilla::WidgetDragEvent
 330  ******************************************************************************/
 331
 332 class WidgetDragEvent : public WidgetMouseEvent {
 333  private:
 334   friend class mozilla::dom::PBrowserParent;
 335   friend class mozilla::dom::PBrowserChild;
 336   ALLOW_DEPRECATED_READPARAM
 337
 338  protected:
 339   WidgetDragEvent()
 340       : mUserCancelled(false), mDefaultPreventedOnContent(false) {}
 341
 342  public:
 343   virtual WidgetDragEvent* AsDragEvent() override { return this; }
 344
 345   WidgetDragEvent(bool aIsTrusted, EventMessage aMessage, nsIWidget* aWidget,
 346                   const WidgetEventTime* aTime = nullptr)
 347       : WidgetMouseEvent(aIsTrusted, aMessage, aWidget, eDragEventClass, eReal,
 348                          aTime),
 349         mUserCancelled(false),
 350         mDefaultPreventedOnContent(false),
 351         mInHTMLEditorEventListener(false) {}
 352
 353   virtual WidgetEvent* Duplicate() const override {
 354     MOZ_ASSERT(mClass == eDragEventClass,
 355                "Duplicate() must be overridden by sub class");
 356     // Not copying widget, it is a weak reference.
 357     WidgetDragEvent* result =
 358         new WidgetDragEvent(false, mMessage, nullptr, this);
 359     result->AssignDragEventData(*this, true);
 360     result->mFlags = mFlags;
 361     return result;
 362   }
 363
 364   // The dragging data.
 365   nsCOMPtr<dom::DataTransfer> mDataTransfer;
 366
 367   // If this is true, user has cancelled the drag operation.
 368   bool mUserCancelled;
 369   // If this is true, the drag event's preventDefault() is called on content.
 370   bool mDefaultPreventedOnContent;
 371   // If this event is currently being handled by HTMLEditorEventListener.
 372   bool mInHTMLEditorEventListener;
 373
 374   // XXX Not tested by test_assign_event_data.html
 375   void AssignDragEventData(const WidgetDragEvent& aEvent, bool aCopyTargets) {
 376     AssignMouseEventData(aEvent, aCopyTargets);
 377
 378     mDataTransfer = aEvent.mDataTransfer;
 379     // XXX mUserCancelled isn't copied, is this intentionally?
 380     mUserCancelled = false;
 381     mDefaultPreventedOnContent = aEvent.mDefaultPreventedOnContent;
 382   }
 383
 384   /**
 385    * Should be called before dispatching the DOM tree if this event is
 386    * synthesized for tests because drop effect is initialized before
 387    * dispatching from widget if it's not synthesized event, but synthesized
 388    * events are not initialized in the path.
 389    */
 390   void InitDropEffectForTests();
 391 };
 392
 393 /******************************************************************************
 394  * mozilla::WidgetMouseScrollEvent
 395  *
 396  * This is used for legacy DOM mouse scroll events, i.e.,
 397  * DOMMouseScroll and MozMousePixelScroll event.  These events are NOT hanbled
 398  * by ESM even if widget dispatches them.  Use new WidgetWheelEvent instead.
 399  ******************************************************************************/
 400
 401 class WidgetMouseScrollEvent : public WidgetMouseEventBase {
 402  private:
 403   WidgetMouseScrollEvent() : mDelta(0), mIsHorizontal(false) {}
 404
 405  public:
 406   virtual WidgetMouseScrollEvent* AsMouseScrollEvent() override { return this; }
 407
 408   WidgetMouseScrollEvent(bool aIsTrusted, EventMessage aMessage,
 409                          nsIWidget* aWidget,
 410                          const WidgetEventTime* aTime = nullptr)
 411       : WidgetMouseEventBase(aIsTrusted, aMessage, aWidget,
 412                              eMouseScrollEventClass, aTime),
 413         mDelta(0),
 414         mIsHorizontal(false) {}
 415
 416   virtual WidgetEvent* Duplicate() const override {
 417     MOZ_ASSERT(mClass == eMouseScrollEventClass,
 418                "Duplicate() must be overridden by sub class");
 419     // Not copying widget, it is a weak reference.
 420     WidgetMouseScrollEvent* result =
 421         new WidgetMouseScrollEvent(false, mMessage, nullptr, this);
 422     result->AssignMouseScrollEventData(*this, true);
 423     result->mFlags = mFlags;
 424     return result;
 425   }
 426
 427   // The delta value of mouse scroll event.
 428   // If the event message is eLegacyMouseLineOrPageScroll, the value indicates
 429   // scroll amount in lines.  However, if the value is
 430   // UIEvent::SCROLL_PAGE_UP or UIEvent::SCROLL_PAGE_DOWN, the
 431   // value inducates one page scroll.  If the event message is
 432   // eLegacyMousePixelScroll, the value indicates scroll amount in pixels.
 433   int32_t mDelta;
 434
 435   // If this is true, it may cause to scroll horizontally.
 436   // Otherwise, vertically.
 437   bool mIsHorizontal;
 438
 439   void AssignMouseScrollEventData(const WidgetMouseScrollEvent& aEvent,
 440                                   bool aCopyTargets) {
 441     AssignMouseEventBaseData(aEvent, aCopyTargets);
 442
 443     mDelta = aEvent.mDelta;
 444     mIsHorizontal = aEvent.mIsHorizontal;
 445   }
 446 };
 447
 448 /******************************************************************************
 449  * mozilla::WidgetWheelEvent
 450  ******************************************************************************/
 451
 452 class WidgetWheelEvent : public WidgetMouseEventBase {
 453  private:
 454   friend class mozilla::dom::PBrowserParent;
 455   friend class mozilla::dom::PBrowserChild;
 456   ALLOW_DEPRECATED_READPARAM
 457
 458   WidgetWheelEvent()
 459       : mDeltaX(0.0),
 460         mDeltaY(0.0),
 461         mDeltaZ(0.0),
 462         mOverflowDeltaX(0.0),
 463         mOverflowDeltaY(0.0)
 464         // Including WheelEventBinding.h here leads to an include loop, so
 465         // we have to hardcode WheelEvent_Binding::DOM_DELTA_PIXEL.
 466         ,
 467         mDeltaMode(/* WheelEvent_Binding::DOM_DELTA_PIXEL = */ 0),
 468         mLineOrPageDeltaX(0),
 469         mLineOrPageDeltaY(0),
 470         mScrollType(SCROLL_DEFAULT),
 471         mCustomizedByUserPrefs(false),
 472         mMayHaveMomentum(false),
 473         mIsMomentum(false),
 474         mIsNoLineOrPageDelta(false),
 475         mViewPortIsOverscrolled(false),
 476         mCanTriggerSwipe(false),
 477         mAllowToOverrideSystemScrollSpeed(false),
 478         mDeltaValuesHorizontalizedForDefaultHandler(false) {}
 479
 480  public:
 481   virtual WidgetWheelEvent* AsWheelEvent() override { return this; }
 482
 483   WidgetWheelEvent(bool aIsTrusted, EventMessage aMessage, nsIWidget* aWidget,
 484                    const WidgetEventTime* aTime = nullptr)
 485       : WidgetMouseEventBase(aIsTrusted, aMessage, aWidget, eWheelEventClass,
 486                              aTime),
 487         mDeltaX(0.0),
 488         mDeltaY(0.0),
 489         mDeltaZ(0.0),
 490         mOverflowDeltaX(0.0),
 491         mOverflowDeltaY(0.0)
 492         // Including WheelEventBinding.h here leads to an include loop, so
 493         // we have to hardcode WheelEvent_Binding::DOM_DELTA_PIXEL.
 494         ,
 495         mDeltaMode(/* WheelEvent_Binding::DOM_DELTA_PIXEL = */ 0),
 496         mLineOrPageDeltaX(0),
 497         mLineOrPageDeltaY(0),
 498         mScrollType(SCROLL_DEFAULT),
 499         mCustomizedByUserPrefs(false),
 500         mMayHaveMomentum(false),
 501         mIsMomentum(false),
 502         mIsNoLineOrPageDelta(false),
 503         mViewPortIsOverscrolled(false),
 504         mCanTriggerSwipe(false),
 505         mAllowToOverrideSystemScrollSpeed(true),
 506         mDeltaValuesHorizontalizedForDefaultHandler(false) {}
 507
 508   virtual WidgetEvent* Duplicate() const override {
 509     MOZ_ASSERT(mClass == eWheelEventClass,
 510                "Duplicate() must be overridden by sub class");
 511     // Not copying widget, it is a weak reference.
 512     WidgetWheelEvent* result =
 513         new WidgetWheelEvent(false, mMessage, nullptr, this);
 514     result->AssignWheelEventData(*this, true);
 515     result->mFlags = mFlags;
 516     return result;
 517   }
 518
 519   // Scroll gestures that start at the edge of the scrollable range can result
 520   // in a swipe gesture. For the first wheel event of such a gesture, call
 521   // TriggersSwipe() after the event has been processed in order to find out
 522   // whether a swipe should be started.
 523   bool TriggersSwipe() const {
 524     return mCanTriggerSwipe && mViewPortIsOverscrolled &&
 525            this->mOverflowDeltaX != 0.0;
 526   }
 527
 528   // NOTE: mDeltaX, mDeltaY and mDeltaZ may be customized by
 529   //       mousewheel.*.delta_multiplier_* prefs which are applied by
 530   //       EventStateManager.  So, after widget dispatches this event,
 531   //       these delta values may have different values than before.
 532   double mDeltaX;
 533   double mDeltaY;
 534   double mDeltaZ;
 535
 536   // The mousewheel tick counts.
 537   double mWheelTicksX = 0.0;
 538   double mWheelTicksY = 0.0;
 539
 540   enum class DeltaModeCheckingState : uint8_t {
 541     // Neither deltaMode nor the delta values have been accessed.
 542     Unknown,
 543     // The delta values have been accessed, without checking deltaMode first.
 544     Unchecked,
 545     // The deltaMode has been checked.
 546     Checked,
 547   };
 548
 549   // For compat reasons, we might expose a DOM_DELTA_LINE event as
 550   // DOM_DELTA_PIXEL instead. Whether we do that depends on whether the event
 551   // has been asked for the deltaMode before the deltas. If it has, we assume
 552   // that the page will correctly handle DOM_DELTA_LINE. This variable tracks
 553   // that state. See bug 1392460.
 554   DeltaModeCheckingState mDeltaModeCheckingState =
 555       DeltaModeCheckingState::Unknown;
 556
 557   // The amount of scrolling per line or page, without accounting for mouse
 558   // wheel transactions etc.
 559   //
 560   // Computed by EventStateManager::DeltaAccumulator::InitLineOrPageDelta.
 561   nsSize mScrollAmount;
 562
 563   // overflowed delta values for scroll, these values are set by
 564   // EventStateManger.  If the default action of the wheel event isn't scroll,
 565   // these values are always zero.  Otherwise, remaining delta values which are
 566   // not used by scroll are set.
 567   // NOTE: mDeltaX, mDeltaY and mDeltaZ may be modified by EventStateManager.
 568   //       However, mOverflowDeltaX and mOverflowDeltaY indicate unused original
 569   //       delta values which are not applied the delta_multiplier prefs.
 570   //       So, if widget wanted to know the actual direction to be scrolled,
 571   //       it would need to check the mDeltaX and mDeltaY.
 572   double mOverflowDeltaX;
 573   double mOverflowDeltaY;
 574
 575   // Should be one of WheelEvent_Binding::DOM_DELTA_*
 576   uint32_t mDeltaMode;
 577
 578   // If widget sets mLineOrPageDelta, EventStateManager will dispatch
 579   // eLegacyMouseLineOrPageScroll event for compatibility.  Note that the delta
 580   // value means pages if the mDeltaMode is DOM_DELTA_PAGE, otherwise, lines.
 581   int32_t mLineOrPageDeltaX;
 582   int32_t mLineOrPageDeltaY;
 583
 584   // When the default action for an wheel event is moving history or zooming,
 585   // need to chose a delta value for doing it.
 586   int32_t GetPreferredIntDelta() {
 587     if (!mLineOrPageDeltaX && !mLineOrPageDeltaY) {
 588       return 0;
 589     }
 590     if (mLineOrPageDeltaY && !mLineOrPageDeltaX) {
 591       return mLineOrPageDeltaY;
 592     }
 593     if (mLineOrPageDeltaX && !mLineOrPageDeltaY) {
 594       return mLineOrPageDeltaX;
 595     }
 596     if ((mLineOrPageDeltaX < 0 && mLineOrPageDeltaY > 0) ||
 597         (mLineOrPageDeltaX > 0 && mLineOrPageDeltaY < 0)) {
 598       return 0;  // We cannot guess the answer in this case.
 599     }
 600     return (Abs(mLineOrPageDeltaX) > Abs(mLineOrPageDeltaY))
 601                ? mLineOrPageDeltaX
 602                : mLineOrPageDeltaY;
 603   }
 604
 605   // Scroll type
 606   // The default value is SCROLL_DEFAULT, which means EventStateManager will
 607   // select preferred scroll type automatically.
 608   enum ScrollType : uint8_t {
 609     SCROLL_DEFAULT,
 610     SCROLL_SYNCHRONOUSLY,
 611     SCROLL_ASYNCHRONOUSLY,
 612     SCROLL_SMOOTHLY
 613   };
 614   ScrollType mScrollType;
 615
 616   // If the delta values are computed from prefs, this value is true.
 617   // Otherwise, i.e., they are computed from native events, false.
 618   bool mCustomizedByUserPrefs;
 619
 620   // true if the momentum events directly tied to this event may follow it.
 621   bool mMayHaveMomentum;
 622   // true if the event is caused by momentum.
 623   bool mIsMomentum;
 624
 625   // If device event handlers don't know when they should set mLineOrPageDeltaX
 626   // and mLineOrPageDeltaY, this is true.  Otherwise, false.
 627   // If mIsNoLineOrPageDelta is true, ESM will generate
 628   // eLegacyMouseLineOrPageScroll events when accumulated delta values reach
 629   // a line height.
 630   bool mIsNoLineOrPageDelta;
 631
 632   // Whether or not the parent of the currently overscrolled frame is the
 633   // ViewPort. This is false in situations when an element on the page is being
 634   // overscrolled (such as a text field), but true when the 'page' is being
 635   // overscrolled.
 636   bool mViewPortIsOverscrolled;
 637
 638   // The wheel event can trigger a swipe to start if it's overscrolling the
 639   // viewport.
 640   bool mCanTriggerSwipe;
 641
 642   // If mAllowToOverrideSystemScrollSpeed is true, the scroll speed may be
 643   // overridden.  Otherwise, the scroll speed won't be overridden even if
 644   // it's enabled by the pref.
 645   bool mAllowToOverrideSystemScrollSpeed;
 646
 647   // After the event's default action handler has adjusted its delta's values
 648   // for horizontalizing a vertical wheel scroll, this variable will be set to
 649   // true.
 650   bool mDeltaValuesHorizontalizedForDefaultHandler;
 651
 652   void AssignWheelEventData(const WidgetWheelEvent& aEvent, bool aCopyTargets) {
 653     AssignMouseEventBaseData(aEvent, aCopyTargets);
 654
 655     mDeltaX = aEvent.mDeltaX;
 656     mDeltaY = aEvent.mDeltaY;
 657     mDeltaZ = aEvent.mDeltaZ;
 658     mDeltaMode = aEvent.mDeltaMode;
 659     mScrollAmount = aEvent.mScrollAmount;
 660     mCustomizedByUserPrefs = aEvent.mCustomizedByUserPrefs;
 661     mMayHaveMomentum = aEvent.mMayHaveMomentum;
 662     mIsMomentum = aEvent.mIsMomentum;
 663     mIsNoLineOrPageDelta = aEvent.mIsNoLineOrPageDelta;
 664     mLineOrPageDeltaX = aEvent.mLineOrPageDeltaX;
 665     mLineOrPageDeltaY = aEvent.mLineOrPageDeltaY;
 666     mScrollType = aEvent.mScrollType;
 667     mOverflowDeltaX = aEvent.mOverflowDeltaX;
 668     mOverflowDeltaY = aEvent.mOverflowDeltaY;
 669     mViewPortIsOverscrolled = aEvent.mViewPortIsOverscrolled;
 670     mCanTriggerSwipe = aEvent.mCanTriggerSwipe;
 671     mAllowToOverrideSystemScrollSpeed =
 672         aEvent.mAllowToOverrideSystemScrollSpeed;
 673     mDeltaValuesHorizontalizedForDefaultHandler =
 674         aEvent.mDeltaValuesHorizontalizedForDefaultHandler;
 675   }
 676
 677   // System scroll speed settings may be too slow at using Gecko.  In such
 678   // case, we should override the scroll speed computed with system settings.
 679   // Following methods return preferred delta values which are multiplied by
 680   // factors specified by prefs.  If system scroll speed shouldn't be
 681   // overridden (e.g., this feature is disabled by pref), they return raw
 682   // delta values.
 683   double OverriddenDeltaX() const;
 684   double OverriddenDeltaY() const;
 685
 686   // Compute the overridden delta value.  This may be useful for suppressing
 687   // too fast scroll by system scroll speed overriding when widget sets
 688   // mAllowToOverrideSystemScrollSpeed.
 689   static double ComputeOverriddenDelta(double aDelta, bool aIsForVertical);
 690
 691  private:
 692   static bool sInitialized;
 693   static bool sIsSystemScrollSpeedOverrideEnabled;
 694   static int32_t sOverrideFactorX;
 695   static int32_t sOverrideFactorY;
 696   static void Initialize();
 697 };
 698
 699 /******************************************************************************
 700  * mozilla::WidgetPointerEvent
 701  ******************************************************************************/
 702
 703 class WidgetPointerEvent : public WidgetMouseEvent {
 704   friend class mozilla::dom::PBrowserParent;
 705   friend class mozilla::dom::PBrowserChild;
 706   ALLOW_DEPRECATED_READPARAM
 707
 708  public:
 709   virtual WidgetPointerEvent* AsPointerEvent() override { return this; }
 710
 711   WidgetPointerEvent(bool aIsTrusted, EventMessage aMsg, nsIWidget* w,
 712                      const WidgetEventTime* aTime = nullptr)
 713       : WidgetMouseEvent(aIsTrusted, aMsg, w, ePointerEventClass, eReal, aTime),
 714         mWidth(1),
 715         mHeight(1),
 716         mIsPrimary(true),
 717         mFromTouchEvent(false) {}
 718
 719   explicit WidgetPointerEvent(const WidgetMouseEvent& aEvent)
 720       : WidgetMouseEvent(aEvent),
 721         mWidth(1),
 722         mHeight(1),
 723         mIsPrimary(true),
 724         mFromTouchEvent(false) {
 725     mClass = ePointerEventClass;
 726   }
 727
 728   virtual WidgetEvent* Duplicate() const override {
 729     MOZ_ASSERT(mClass == ePointerEventClass,
 730                "Duplicate() must be overridden by sub class");
 731     // Not copying widget, it is a weak reference.
 732     WidgetPointerEvent* result =
 733         new WidgetPointerEvent(false, mMessage, nullptr, this);
 734     result->AssignPointerEventData(*this, true);
 735     result->mFlags = mFlags;
 736     return result;
 737   }
 738
 739   int32_t mWidth;
 740   int32_t mHeight;
 741   bool mIsPrimary;
 742   bool mFromTouchEvent;
 743
 744   // XXX Not tested by test_assign_event_data.html
 745   void AssignPointerEventData(const WidgetPointerEvent& aEvent,
 746                               bool aCopyTargets) {
 747     AssignMouseEventData(aEvent, aCopyTargets);
 748
 749     mWidth = aEvent.mWidth;
 750     mHeight = aEvent.mHeight;
 751     mIsPrimary = aEvent.mIsPrimary;
 752     mFromTouchEvent = aEvent.mFromTouchEvent;
 753   }
 754 };
 755
 756 }  // namespace mozilla
 757
 758 #endif  // mozilla_MouseEvents_h__