summaryrefslogtreecommitdiff
path: root/widget/MouseEvents.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /widget/MouseEvents.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloaduxp-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
Add m-esr52 at 52.6.0
Diffstat (limited to 'widget/MouseEvents.h')
-rw-r--r--widget/MouseEvents.h724
1 files changed, 724 insertions, 0 deletions
diff --git a/widget/MouseEvents.h b/widget/MouseEvents.h
new file mode 100644
index 0000000000..643132618f
--- /dev/null
+++ b/widget/MouseEvents.h
@@ -0,0 +1,724 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_MouseEvents_h__
+#define mozilla_MouseEvents_h__
+
+#include <stdint.h>
+
+#include "mozilla/BasicEvents.h"
+#include "mozilla/MathAlgorithms.h"
+#include "mozilla/dom/DataTransfer.h"
+#include "nsCOMPtr.h"
+#include "nsIDOMMouseEvent.h"
+#include "nsIDOMWheelEvent.h"
+
+/******************************************************************************
+ * nsDragDropEventStatus
+ ******************************************************************************/
+
+enum nsDragDropEventStatus
+{
+ // The event is a enter
+ nsDragDropEventStatus_eDragEntered,
+ // The event is exit
+ nsDragDropEventStatus_eDragExited,
+ // The event is drop
+ nsDragDropEventStatus_eDrop
+};
+
+namespace mozilla {
+
+namespace dom {
+ class PBrowserParent;
+ class PBrowserChild;
+} // namespace dom
+
+/******************************************************************************
+ * mozilla::WidgetPointerHelper
+ ******************************************************************************/
+
+class WidgetPointerHelper
+{
+public:
+ bool convertToPointer;
+ uint32_t pointerId;
+ uint32_t tiltX;
+ uint32_t tiltY;
+ bool retargetedByPointerCapture;
+
+ WidgetPointerHelper() : convertToPointer(true), pointerId(0), tiltX(0), tiltY(0),
+ retargetedByPointerCapture(false) {}
+
+ void AssignPointerHelperData(const WidgetPointerHelper& aEvent)
+ {
+ convertToPointer = aEvent.convertToPointer;
+ pointerId = aEvent.pointerId;
+ tiltX = aEvent.tiltX;
+ tiltY = aEvent.tiltY;
+ retargetedByPointerCapture = aEvent.retargetedByPointerCapture;
+ }
+};
+
+/******************************************************************************
+ * mozilla::WidgetMouseEventBase
+ ******************************************************************************/
+
+class WidgetMouseEventBase : public WidgetInputEvent
+{
+private:
+ friend class dom::PBrowserParent;
+ friend class dom::PBrowserChild;
+
+protected:
+ WidgetMouseEventBase()
+ : button(0)
+ , buttons(0)
+ , pressure(0)
+ , hitCluster(false)
+ , inputSource(nsIDOMMouseEvent::MOZ_SOURCE_MOUSE)
+ {
+ }
+
+ WidgetMouseEventBase(bool aIsTrusted, EventMessage aMessage,
+ nsIWidget* aWidget, EventClassID aEventClassID)
+ : WidgetInputEvent(aIsTrusted, aMessage, aWidget, aEventClassID)
+ , button(0)
+ , buttons(0)
+ , pressure(0)
+ , hitCluster(false)
+ , inputSource(nsIDOMMouseEvent::MOZ_SOURCE_MOUSE)
+ {
+ }
+
+public:
+ virtual WidgetMouseEventBase* AsMouseEventBase() override { return this; }
+
+ virtual WidgetEvent* Duplicate() const override
+ {
+ MOZ_CRASH("WidgetMouseEventBase must not be most-subclass");
+ }
+
+ /// The possible related target
+ nsCOMPtr<nsISupports> relatedTarget;
+
+ enum buttonType
+ {
+ eLeftButton = 0,
+ eMiddleButton = 1,
+ eRightButton = 2
+ };
+ // Pressed button ID of mousedown or mouseup event.
+ // This is set only when pressing a button causes the event.
+ int16_t button;
+
+ enum buttonsFlag {
+ eNoButtonFlag = 0x00,
+ eLeftButtonFlag = 0x01,
+ eRightButtonFlag = 0x02,
+ eMiddleButtonFlag = 0x04,
+ // typicall, "back" button being left side of 5-button
+ // mice, see "buttons" attribute document of DOM3 Events.
+ e4thButtonFlag = 0x08,
+ // typicall, "forward" button being right side of 5-button
+ // mice, see "buttons" attribute document of DOM3 Events.
+ e5thButtonFlag = 0x10
+ };
+
+ // Flags of all pressed buttons at the event fired.
+ // This is set at any mouse event, don't be confused with |button|.
+ int16_t buttons;
+
+ // Finger or touch pressure of event. It ranges between 0.0 and 1.0.
+ float pressure;
+ // Touch near a cluster of links (true)
+ bool hitCluster;
+
+ // Possible values at nsIDOMMouseEvent
+ uint16_t inputSource;
+
+ // ID of the canvas HitRegion
+ nsString region;
+
+ bool IsLeftButtonPressed() const { return !!(buttons & eLeftButtonFlag); }
+ bool IsRightButtonPressed() const { return !!(buttons & eRightButtonFlag); }
+ bool IsMiddleButtonPressed() const { return !!(buttons & eMiddleButtonFlag); }
+ bool Is4thButtonPressed() const { return !!(buttons & e4thButtonFlag); }
+ bool Is5thButtonPressed() const { return !!(buttons & e5thButtonFlag); }
+
+ void AssignMouseEventBaseData(const WidgetMouseEventBase& aEvent,
+ bool aCopyTargets)
+ {
+ AssignInputEventData(aEvent, aCopyTargets);
+
+ relatedTarget = aCopyTargets ? aEvent.relatedTarget : nullptr;
+ button = aEvent.button;
+ buttons = aEvent.buttons;
+ pressure = aEvent.pressure;
+ hitCluster = aEvent.hitCluster;
+ inputSource = aEvent.inputSource;
+ }
+
+ /**
+ * Returns true if left click event.
+ */
+ bool IsLeftClickEvent() const
+ {
+ return mMessage == eMouseClick && button == eLeftButton;
+ }
+};
+
+/******************************************************************************
+ * mozilla::WidgetMouseEvent
+ ******************************************************************************/
+
+class WidgetMouseEvent : public WidgetMouseEventBase
+ , public WidgetPointerHelper
+{
+private:
+ friend class dom::PBrowserParent;
+ friend class dom::PBrowserChild;
+
+public:
+ typedef bool ReasonType;
+ enum Reason : ReasonType
+ {
+ eReal,
+ eSynthesized
+ };
+
+ typedef bool ContextMenuTriggerType;
+ enum ContextMenuTrigger : ContextMenuTriggerType
+ {
+ eNormal,
+ eContextMenuKey
+ };
+
+ typedef bool ExitFromType;
+ enum ExitFrom : ExitFromType
+ {
+ eChild,
+ eTopLevel
+ };
+
+protected:
+ WidgetMouseEvent()
+ : mReason(eReal)
+ , mContextMenuTrigger(eNormal)
+ , mExitFrom(eChild)
+ , mIgnoreRootScrollFrame(false)
+ , mClickCount(0)
+ {
+ }
+
+ WidgetMouseEvent(bool aIsTrusted,
+ EventMessage aMessage,
+ nsIWidget* aWidget,
+ EventClassID aEventClassID,
+ Reason aReason)
+ : WidgetMouseEventBase(aIsTrusted, aMessage, aWidget, aEventClassID)
+ , mReason(aReason)
+ , mContextMenuTrigger(eNormal)
+ , mExitFrom(eChild)
+ , mIgnoreRootScrollFrame(false)
+ , mClickCount(0)
+ {
+ }
+
+public:
+ virtual WidgetMouseEvent* AsMouseEvent() override { return this; }
+
+ WidgetMouseEvent(bool aIsTrusted,
+ EventMessage aMessage,
+ nsIWidget* aWidget,
+ Reason aReason,
+ ContextMenuTrigger aContextMenuTrigger = eNormal)
+ : WidgetMouseEventBase(aIsTrusted, aMessage, aWidget, eMouseEventClass)
+ , mReason(aReason)
+ , mContextMenuTrigger(aContextMenuTrigger)
+ , mExitFrom(eChild)
+ , mIgnoreRootScrollFrame(false)
+ , mClickCount(0)
+ {
+ if (aMessage == eContextMenu) {
+ button = (mContextMenuTrigger == eNormal) ? eRightButton : eLeftButton;
+ }
+ }
+
+#ifdef DEBUG
+ virtual ~WidgetMouseEvent()
+ {
+ NS_WARNING_ASSERTION(
+ mMessage != eContextMenu ||
+ button == ((mContextMenuTrigger == eNormal) ? eRightButton : eLeftButton),
+ "Wrong button set to eContextMenu event?");
+ }
+#endif
+
+ virtual WidgetEvent* Duplicate() const override
+ {
+ MOZ_ASSERT(mClass == eMouseEventClass,
+ "Duplicate() must be overridden by sub class");
+ // Not copying widget, it is a weak reference.
+ WidgetMouseEvent* result =
+ new WidgetMouseEvent(false, mMessage, nullptr,
+ mReason, mContextMenuTrigger);
+ result->AssignMouseEventData(*this, true);
+ result->mFlags = mFlags;
+ return result;
+ }
+
+ // mReason indicates the reason why the event is fired:
+ // - Representing mouse operation.
+ // - Synthesized for emulating mousemove event when the content under the
+ // mouse cursor is scrolled.
+ Reason mReason;
+
+ // mContextMenuTrigger is valid only when mMessage is eContextMenu.
+ // This indicates if the context menu event is caused by context menu key or
+ // other reasons (typically, a click of right mouse button).
+ ContextMenuTrigger mContextMenuTrigger;
+
+ // mExitFrom is valid only when mMessage is eMouseExitFromWidget.
+ // This indicates if the mouse cursor exits from a top level widget or
+ // a child widget.
+ ExitFrom mExitFrom;
+
+ // Whether the event should ignore scroll frame bounds during dispatch.
+ bool mIgnoreRootScrollFrame;
+
+ // mClickCount may be non-zero value when mMessage is eMouseDown, eMouseUp,
+ // eMouseClick or eMouseDoubleClick. The number is count of mouse clicks.
+ // Otherwise, this must be 0.
+ uint32_t mClickCount;
+
+ void AssignMouseEventData(const WidgetMouseEvent& aEvent, bool aCopyTargets)
+ {
+ AssignMouseEventBaseData(aEvent, aCopyTargets);
+ AssignPointerHelperData(aEvent);
+
+ mIgnoreRootScrollFrame = aEvent.mIgnoreRootScrollFrame;
+ mClickCount = aEvent.mClickCount;
+ }
+
+ /**
+ * Returns true if the event is a context menu event caused by key.
+ */
+ bool IsContextMenuKeyEvent() const
+ {
+ return mMessage == eContextMenu && mContextMenuTrigger == eContextMenuKey;
+ }
+
+ /**
+ * Returns true if the event is a real mouse event. Otherwise, i.e., it's
+ * a synthesized event by scroll or something, returns false.
+ */
+ bool IsReal() const
+ {
+ return mReason == eReal;
+ }
+};
+
+/******************************************************************************
+ * mozilla::WidgetDragEvent
+ ******************************************************************************/
+
+class WidgetDragEvent : public WidgetMouseEvent
+{
+private:
+ friend class mozilla::dom::PBrowserParent;
+ friend class mozilla::dom::PBrowserChild;
+protected:
+ WidgetDragEvent()
+ : mUserCancelled(false)
+ , mDefaultPreventedOnContent(false)
+ {
+ }
+public:
+ virtual WidgetDragEvent* AsDragEvent() override { return this; }
+
+ WidgetDragEvent(bool aIsTrusted, EventMessage aMessage, nsIWidget* aWidget)
+ : WidgetMouseEvent(aIsTrusted, aMessage, aWidget, eDragEventClass, eReal)
+ , mUserCancelled(false)
+ , mDefaultPreventedOnContent(false)
+ {
+ }
+
+ virtual WidgetEvent* Duplicate() const override
+ {
+ MOZ_ASSERT(mClass == eDragEventClass,
+ "Duplicate() must be overridden by sub class");
+ // Not copying widget, it is a weak reference.
+ WidgetDragEvent* result = new WidgetDragEvent(false, mMessage, nullptr);
+ result->AssignDragEventData(*this, true);
+ result->mFlags = mFlags;
+ return result;
+ }
+
+ // The dragging data.
+ nsCOMPtr<dom::DataTransfer> mDataTransfer;
+
+ // If this is true, user has cancelled the drag operation.
+ bool mUserCancelled;
+ // If this is true, the drag event's preventDefault() is called on content.
+ bool mDefaultPreventedOnContent;
+
+ // XXX Not tested by test_assign_event_data.html
+ void AssignDragEventData(const WidgetDragEvent& aEvent, bool aCopyTargets)
+ {
+ AssignMouseEventData(aEvent, aCopyTargets);
+
+ mDataTransfer = aEvent.mDataTransfer;
+ // XXX mUserCancelled isn't copied, is this intentionally?
+ mUserCancelled = false;
+ mDefaultPreventedOnContent = aEvent.mDefaultPreventedOnContent;
+ }
+};
+
+/******************************************************************************
+ * mozilla::WidgetMouseScrollEvent
+ *
+ * This is used for legacy DOM mouse scroll events, i.e.,
+ * DOMMouseScroll and MozMousePixelScroll event. These events are NOT hanbled
+ * by ESM even if widget dispatches them. Use new WidgetWheelEvent instead.
+ ******************************************************************************/
+
+class WidgetMouseScrollEvent : public WidgetMouseEventBase
+{
+private:
+ WidgetMouseScrollEvent()
+ : mDelta(0)
+ , mIsHorizontal(false)
+ {
+ }
+
+public:
+ virtual WidgetMouseScrollEvent* AsMouseScrollEvent() override
+ {
+ return this;
+ }
+
+ WidgetMouseScrollEvent(bool aIsTrusted, EventMessage aMessage,
+ nsIWidget* aWidget)
+ : WidgetMouseEventBase(aIsTrusted, aMessage, aWidget,
+ eMouseScrollEventClass)
+ , mDelta(0)
+ , mIsHorizontal(false)
+ {
+ }
+
+ virtual WidgetEvent* Duplicate() const override
+ {
+ MOZ_ASSERT(mClass == eMouseScrollEventClass,
+ "Duplicate() must be overridden by sub class");
+ // Not copying widget, it is a weak reference.
+ WidgetMouseScrollEvent* result =
+ new WidgetMouseScrollEvent(false, mMessage, nullptr);
+ result->AssignMouseScrollEventData(*this, true);
+ result->mFlags = mFlags;
+ return result;
+ }
+
+ // The delta value of mouse scroll event.
+ // If the event message is eLegacyMouseLineOrPageScroll, the value indicates
+ // scroll amount in lines. However, if the value is
+ // nsIDOMUIEvent::SCROLL_PAGE_UP or nsIDOMUIEvent::SCROLL_PAGE_DOWN, the
+ // value inducates one page scroll. If the event message is
+ // eLegacyMousePixelScroll, the value indicates scroll amount in pixels.
+ int32_t mDelta;
+
+ // If this is true, it may cause to scroll horizontally.
+ // Otherwise, vertically.
+ bool mIsHorizontal;
+
+ void AssignMouseScrollEventData(const WidgetMouseScrollEvent& aEvent,
+ bool aCopyTargets)
+ {
+ AssignMouseEventBaseData(aEvent, aCopyTargets);
+
+ mDelta = aEvent.mDelta;
+ mIsHorizontal = aEvent.mIsHorizontal;
+ }
+};
+
+/******************************************************************************
+ * mozilla::WidgetWheelEvent
+ ******************************************************************************/
+
+class WidgetWheelEvent : public WidgetMouseEventBase
+{
+private:
+ friend class mozilla::dom::PBrowserParent;
+ friend class mozilla::dom::PBrowserChild;
+
+ WidgetWheelEvent()
+ : mDeltaX(0.0)
+ , mDeltaY(0.0)
+ , mDeltaZ(0.0)
+ , mOverflowDeltaX(0.0)
+ , mOverflowDeltaY(0.0)
+ , mDeltaMode(nsIDOMWheelEvent::DOM_DELTA_PIXEL)
+ , mLineOrPageDeltaX(0)
+ , mLineOrPageDeltaY(0)
+ , mScrollType(SCROLL_DEFAULT)
+ , mCustomizedByUserPrefs(false)
+ , mIsMomentum(false)
+ , mIsNoLineOrPageDelta(false)
+ , mViewPortIsOverscrolled(false)
+ , mCanTriggerSwipe(false)
+ , mAllowToOverrideSystemScrollSpeed(false)
+ {
+ }
+
+public:
+ virtual WidgetWheelEvent* AsWheelEvent() override { return this; }
+
+ WidgetWheelEvent(bool aIsTrusted, EventMessage aMessage, nsIWidget* aWidget)
+ : WidgetMouseEventBase(aIsTrusted, aMessage, aWidget, eWheelEventClass)
+ , mDeltaX(0.0)
+ , mDeltaY(0.0)
+ , mDeltaZ(0.0)
+ , mOverflowDeltaX(0.0)
+ , mOverflowDeltaY(0.0)
+ , mDeltaMode(nsIDOMWheelEvent::DOM_DELTA_PIXEL)
+ , mLineOrPageDeltaX(0)
+ , mLineOrPageDeltaY(0)
+ , mScrollType(SCROLL_DEFAULT)
+ , mCustomizedByUserPrefs(false)
+ , mMayHaveMomentum(false)
+ , mIsMomentum(false)
+ , mIsNoLineOrPageDelta(false)
+ , mViewPortIsOverscrolled(false)
+ , mCanTriggerSwipe(false)
+ , mAllowToOverrideSystemScrollSpeed(true)
+ {
+ }
+
+ virtual WidgetEvent* Duplicate() const override
+ {
+ MOZ_ASSERT(mClass == eWheelEventClass,
+ "Duplicate() must be overridden by sub class");
+ // Not copying widget, it is a weak reference.
+ WidgetWheelEvent* result = new WidgetWheelEvent(false, mMessage, nullptr);
+ result->AssignWheelEventData(*this, true);
+ result->mFlags = mFlags;
+ return result;
+ }
+
+ // On OS X, scroll gestures that start at the edge of the scrollable range
+ // can result in a swipe gesture. For the first wheel event of such a
+ // gesture, call TriggersSwipe() after the event has been processed
+ // in order to find out whether a swipe should be started.
+ bool TriggersSwipe() const
+ {
+ return mCanTriggerSwipe && mViewPortIsOverscrolled &&
+ this->mOverflowDeltaX != 0.0;
+ }
+
+ // NOTE: mDeltaX, mDeltaY and mDeltaZ may be customized by
+ // mousewheel.*.delta_multiplier_* prefs which are applied by
+ // EventStateManager. So, after widget dispatches this event,
+ // these delta values may have different values than before.
+ double mDeltaX;
+ double mDeltaY;
+ double mDeltaZ;
+
+ // overflowed delta values for scroll, these values are set by
+ // nsEventStateManger. If the default action of the wheel event isn't scroll,
+ // these values always zero. Otherwise, remaning delta values which are
+ // not used by scroll are set.
+ // NOTE: mDeltaX, mDeltaY and mDeltaZ may be modified by EventStateManager.
+ // However, mOverflowDeltaX and mOverflowDeltaY indicate unused original
+ // delta values which are not applied the delta_multiplier prefs.
+ // So, if widget wanted to know the actual direction to be scrolled,
+ // it would need to check the mDeltaX and mDeltaY.
+ double mOverflowDeltaX;
+ double mOverflowDeltaY;
+
+ // Should be one of nsIDOMWheelEvent::DOM_DELTA_*
+ uint32_t mDeltaMode;
+
+ // If widget sets mLineOrPageDelta, EventStateManager will dispatch
+ // eLegacyMouseLineOrPageScroll event for compatibility. Note that the delta
+ // value means pages if the mDeltaMode is DOM_DELTA_PAGE, otherwise, lines.
+ int32_t mLineOrPageDeltaX;
+ int32_t mLineOrPageDeltaY;
+
+ // When the default action for an wheel event is moving history or zooming,
+ // need to chose a delta value for doing it.
+ int32_t GetPreferredIntDelta()
+ {
+ if (!mLineOrPageDeltaX && !mLineOrPageDeltaY) {
+ return 0;
+ }
+ if (mLineOrPageDeltaY && !mLineOrPageDeltaX) {
+ return mLineOrPageDeltaY;
+ }
+ if (mLineOrPageDeltaX && !mLineOrPageDeltaY) {
+ return mLineOrPageDeltaX;
+ }
+ if ((mLineOrPageDeltaX < 0 && mLineOrPageDeltaY > 0) ||
+ (mLineOrPageDeltaX > 0 && mLineOrPageDeltaY < 0)) {
+ return 0; // We cannot guess the answer in this case.
+ }
+ return (Abs(mLineOrPageDeltaX) > Abs(mLineOrPageDeltaY)) ?
+ mLineOrPageDeltaX : mLineOrPageDeltaY;
+ }
+
+ // Scroll type
+ // The default value is SCROLL_DEFAULT, which means EventStateManager will
+ // select preferred scroll type automatically.
+ enum ScrollType : uint8_t
+ {
+ SCROLL_DEFAULT,
+ SCROLL_SYNCHRONOUSLY,
+ SCROLL_ASYNCHRONOUSELY,
+ SCROLL_SMOOTHLY
+ };
+ ScrollType mScrollType;
+
+ // If the delta values are computed from prefs, this value is true.
+ // Otherwise, i.e., they are computed from native events, false.
+ bool mCustomizedByUserPrefs;
+
+ // true if the momentum events directly tied to this event may follow it.
+ bool mMayHaveMomentum;
+ // true if the event is caused by momentum.
+ bool mIsMomentum;
+
+ // If device event handlers don't know when they should set mLineOrPageDeltaX
+ // and mLineOrPageDeltaY, this is true. Otherwise, false.
+ // If mIsNoLineOrPageDelta is true, ESM will generate
+ // eLegacyMouseLineOrPageScroll events when accumulated delta values reach
+ // a line height.
+ bool mIsNoLineOrPageDelta;
+
+ // Whether or not the parent of the currently overscrolled frame is the
+ // ViewPort. This is false in situations when an element on the page is being
+ // overscrolled (such as a text field), but true when the 'page' is being
+ // overscrolled.
+ bool mViewPortIsOverscrolled;
+
+ // The wheel event can trigger a swipe to start if it's overscrolling the
+ // viewport.
+ bool mCanTriggerSwipe;
+
+ // If mAllowToOverrideSystemScrollSpeed is true, the scroll speed may be
+ // overridden. Otherwise, the scroll speed won't be overridden even if
+ // it's enabled by the pref.
+ bool mAllowToOverrideSystemScrollSpeed;
+
+ void AssignWheelEventData(const WidgetWheelEvent& aEvent, bool aCopyTargets)
+ {
+ AssignMouseEventBaseData(aEvent, aCopyTargets);
+
+ mDeltaX = aEvent.mDeltaX;
+ mDeltaY = aEvent.mDeltaY;
+ mDeltaZ = aEvent.mDeltaZ;
+ mDeltaMode = aEvent.mDeltaMode;
+ mCustomizedByUserPrefs = aEvent.mCustomizedByUserPrefs;
+ mMayHaveMomentum = aEvent.mMayHaveMomentum;
+ mIsMomentum = aEvent.mIsMomentum;
+ mIsNoLineOrPageDelta = aEvent.mIsNoLineOrPageDelta;
+ mLineOrPageDeltaX = aEvent.mLineOrPageDeltaX;
+ mLineOrPageDeltaY = aEvent.mLineOrPageDeltaY;
+ mScrollType = aEvent.mScrollType;
+ mOverflowDeltaX = aEvent.mOverflowDeltaX;
+ mOverflowDeltaY = aEvent.mOverflowDeltaY;
+ mViewPortIsOverscrolled = aEvent.mViewPortIsOverscrolled;
+ mCanTriggerSwipe = aEvent.mCanTriggerSwipe;
+ mAllowToOverrideSystemScrollSpeed =
+ aEvent.mAllowToOverrideSystemScrollSpeed;
+ }
+
+ // System scroll speed settings may be too slow at using Gecko. In such
+ // case, we should override the scroll speed computed with system settings.
+ // Following methods return preferred delta values which are multiplied by
+ // factors specified by prefs. If system scroll speed shouldn't be
+ // overridden (e.g., this feature is disabled by pref), they return raw
+ // delta values.
+ double OverriddenDeltaX() const;
+ double OverriddenDeltaY() const;
+
+ // Compute the overridden delta value. This may be useful for suppressing
+ // too fast scroll by system scroll speed overriding when widget sets
+ // mAllowToOverrideSystemScrollSpeed.
+ static double ComputeOverriddenDelta(double aDelta, bool aIsForVertical);
+
+private:
+ static bool sInitialized;
+ static bool sIsSystemScrollSpeedOverrideEnabled;
+ static int32_t sOverrideFactorX;
+ static int32_t sOverrideFactorY;
+ static void Initialize();
+};
+
+/******************************************************************************
+ * mozilla::WidgetPointerEvent
+ ******************************************************************************/
+
+class WidgetPointerEvent : public WidgetMouseEvent
+{
+ friend class mozilla::dom::PBrowserParent;
+ friend class mozilla::dom::PBrowserChild;
+
+ WidgetPointerEvent()
+ : mWidth(1)
+ , mHeight(1)
+ , mIsPrimary(true)
+ {
+ }
+
+public:
+ virtual WidgetPointerEvent* AsPointerEvent() override { return this; }
+
+ WidgetPointerEvent(bool aIsTrusted, EventMessage aMsg, nsIWidget* w)
+ : WidgetMouseEvent(aIsTrusted, aMsg, w, ePointerEventClass, eReal)
+ , mWidth(1)
+ , mHeight(1)
+ , mIsPrimary(true)
+ {
+ }
+
+ explicit WidgetPointerEvent(const WidgetMouseEvent& aEvent)
+ : WidgetMouseEvent(aEvent)
+ , mWidth(1)
+ , mHeight(1)
+ , mIsPrimary(true)
+ {
+ mClass = ePointerEventClass;
+ }
+
+ virtual WidgetEvent* Duplicate() const override
+ {
+ MOZ_ASSERT(mClass == ePointerEventClass,
+ "Duplicate() must be overridden by sub class");
+ // Not copying widget, it is a weak reference.
+ WidgetPointerEvent* result =
+ new WidgetPointerEvent(false, mMessage, nullptr);
+ result->AssignPointerEventData(*this, true);
+ result->mFlags = mFlags;
+ return result;
+ }
+
+ uint32_t mWidth;
+ uint32_t mHeight;
+ bool mIsPrimary;
+
+ // XXX Not tested by test_assign_event_data.html
+ void AssignPointerEventData(const WidgetPointerEvent& aEvent,
+ bool aCopyTargets)
+ {
+ AssignMouseEventData(aEvent, aCopyTargets);
+
+ mWidth = aEvent.mWidth;
+ mHeight = aEvent.mHeight;
+ mIsPrimary = aEvent.mIsPrimary;
+ }
+};
+
+} // namespace mozilla
+
+#endif // mozilla_MouseEvents_h__