diff options
Diffstat (limited to 'widget/MouseEvents.h')
| -rw-r--r-- | widget/MouseEvents.h | 742 |
1 files changed, 742 insertions, 0 deletions
diff --git a/widget/MouseEvents.h b/widget/MouseEvents.h new file mode 100644 index 0000000000..5a19cb4082 --- /dev/null +++ b/widget/MouseEvents.h @@ -0,0 +1,742 @@ +/* -*- 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 "mozilla/ipc/IPCForwards.h" +#include "nsCOMPtr.h" + +namespace mozilla { + +namespace dom { +class PBrowserParent; +class PBrowserChild; +class PBrowserBridgeParent; +} // namespace dom + +class WidgetPointerEvent; +} // namespace mozilla + +namespace mozilla { +class WidgetPointerEventHolder final { + public: + nsTArray<WidgetPointerEvent> mEvents; + NS_INLINE_DECL_REFCOUNTING(WidgetPointerEventHolder) + + private: + virtual ~WidgetPointerEventHolder() = default; +}; + +/****************************************************************************** + * mozilla::WidgetPointerHelper + ******************************************************************************/ + +class WidgetPointerHelper { + public: + uint32_t pointerId; + int32_t tiltX; + int32_t tiltY; + int32_t twist; + float tangentialPressure; + bool convertToPointer; + RefPtr<WidgetPointerEventHolder> mCoalescedWidgetEvents; + + WidgetPointerHelper() + : pointerId(0), + tiltX(0), + tiltY(0), + twist(0), + tangentialPressure(0), + convertToPointer(true) {} + + WidgetPointerHelper(uint32_t aPointerId, uint32_t aTiltX, uint32_t aTiltY, + uint32_t aTwist = 0, float aTangentialPressure = 0) + : pointerId(aPointerId), + tiltX(aTiltX), + tiltY(aTiltY), + twist(aTwist), + tangentialPressure(aTangentialPressure), + convertToPointer(true) {} + + explicit WidgetPointerHelper(const WidgetPointerHelper& aHelper) = default; + + void AssignPointerHelperData(const WidgetPointerHelper& aEvent, + bool aCopyCoalescedEvents = false) { + pointerId = aEvent.pointerId; + tiltX = aEvent.tiltX; + tiltY = aEvent.tiltY; + twist = aEvent.twist; + tangentialPressure = aEvent.tangentialPressure; + convertToPointer = aEvent.convertToPointer; + if (aCopyCoalescedEvents) { + mCoalescedWidgetEvents = aEvent.mCoalescedWidgetEvents; + } + } +}; + +/****************************************************************************** + * mozilla::WidgetMouseEventBase + ******************************************************************************/ + +class WidgetMouseEventBase : public WidgetInputEvent { + private: + friend class dom::PBrowserParent; + friend class dom::PBrowserChild; + friend class dom::PBrowserBridgeParent; + ALLOW_DEPRECATED_READPARAM + + protected: + WidgetMouseEventBase() + : mPressure(0), + mButton(0), + mButtons(0), + mInputSource(/* MouseEvent_Binding::MOZ_SOURCE_MOUSE = */ 1) {} + // Including MouseEventBinding.h here leads to an include loop, so + // we have to hardcode MouseEvent_Binding::MOZ_SOURCE_MOUSE. + + WidgetMouseEventBase(bool aIsTrusted, EventMessage aMessage, + nsIWidget* aWidget, EventClassID aEventClassID) + : WidgetInputEvent(aIsTrusted, aMessage, aWidget, aEventClassID), + mPressure(0), + mButton(0), + mButtons(0), + mInputSource(/* MouseEvent_Binding::MOZ_SOURCE_MOUSE = */ 1) {} + // Including MouseEventBinding.h here leads to an include loop, so + // we have to hardcode MouseEvent_Binding::MOZ_SOURCE_MOUSE. + + public: + virtual WidgetMouseEventBase* AsMouseEventBase() override { return this; } + + virtual WidgetEvent* Duplicate() const override { + MOZ_CRASH("WidgetMouseEventBase must not be most-subclass"); + } + + // Finger or touch pressure of event. It ranges between 0.0 and 1.0. + float mPressure; + + // Pressed button ID of mousedown or mouseup event. + // This is set only when pressing a button causes the event. + int16_t mButton; + + // Flags of all pressed buttons at the event fired. + // This is set at any mouse event, don't be confused with |mButton|. + int16_t mButtons; + + // Possible values a in MouseEvent + uint16_t mInputSource; + + bool IsLeftButtonPressed() const { + return !!(mButtons & MouseButtonsFlag::ePrimaryFlag); + } + bool IsRightButtonPressed() const { + return !!(mButtons & MouseButtonsFlag::eSecondaryFlag); + } + bool IsMiddleButtonPressed() const { + return !!(mButtons & MouseButtonsFlag::eMiddleFlag); + } + bool Is4thButtonPressed() const { + return !!(mButtons & MouseButtonsFlag::e4thFlag); + } + bool Is5thButtonPressed() const { + return !!(mButtons & MouseButtonsFlag::e5thFlag); + } + + void AssignMouseEventBaseData(const WidgetMouseEventBase& aEvent, + bool aCopyTargets) { + AssignInputEventData(aEvent, aCopyTargets); + + mButton = aEvent.mButton; + mButtons = aEvent.mButtons; + mPressure = aEvent.mPressure; + mInputSource = aEvent.mInputSource; + } + + /** + * Returns true if left click event. + */ + bool IsLeftClickEvent() const { + return mMessage == eMouseClick && mButton == MouseButton::ePrimary; + } +}; + +/****************************************************************************** + * mozilla::WidgetMouseEvent + ******************************************************************************/ + +class WidgetMouseEvent : public WidgetMouseEventBase, + public WidgetPointerHelper { + private: + friend class dom::PBrowserParent; + friend class dom::PBrowserChild; + friend class dom::PBrowserBridgeParent; + ALLOW_DEPRECATED_READPARAM + + public: + typedef bool ReasonType; + enum Reason : ReasonType { eReal, eSynthesized }; + + typedef uint8_t ContextMenuTriggerType; + enum ContextMenuTrigger : ContextMenuTriggerType { + eNormal, + eContextMenuKey, + eControlClick + }; + + typedef uint8_t ExitFromType; + enum ExitFrom : ExitFromType { + ePlatformChild, + ePlatformTopLevel, + ePuppet, + ePuppetParentToPuppetChild + }; + + protected: + WidgetMouseEvent() + : mReason(eReal), + mContextMenuTrigger(eNormal), + mClickCount(0), + mIgnoreRootScrollFrame(false), + mUseLegacyNonPrimaryDispatch(false), + mClickEventPrevented(false) {} + + WidgetMouseEvent(bool aIsTrusted, EventMessage aMessage, nsIWidget* aWidget, + EventClassID aEventClassID, Reason aReason) + : WidgetMouseEventBase(aIsTrusted, aMessage, aWidget, aEventClassID), + mReason(aReason), + mContextMenuTrigger(eNormal), + mClickCount(0), + mIgnoreRootScrollFrame(false), + mUseLegacyNonPrimaryDispatch(false), + mClickEventPrevented(false) {} + +#ifdef DEBUG + void AssertContextMenuEventButtonConsistency() const; +#endif + + 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), + mClickCount(0), + mIgnoreRootScrollFrame(false), + mUseLegacyNonPrimaryDispatch(false), + mClickEventPrevented(false) { + if (aMessage == eContextMenu) { + mButton = (mContextMenuTrigger == eNormal) ? MouseButton::eSecondary + : MouseButton::ePrimary; + } + } + +#ifdef DEBUG + virtual ~WidgetMouseEvent() { AssertContextMenuEventButtonConsistency(); } +#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; + } + + // If during mouseup handling we detect that click event might need to be + // dispatched, this is setup to be the target of the click event. + nsCOMPtr<dom::EventTarget> mClickTarget; + + // 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 contains a value only when mMessage is eMouseExitFromWidget. + // This indicates if the mouse cursor exits from a top level platform widget, + // a child widget or a puppet widget. + Maybe<ExitFrom> mExitFrom; + + // 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; + + // Whether the event should ignore scroll frame bounds during dispatch. + bool mIgnoreRootScrollFrame; + + // Indicates whether the event should dispatch click events for non-primary + // mouse buttons on window and document. + bool mUseLegacyNonPrimaryDispatch; + + // Whether the event shouldn't cause click event. + bool mClickEventPrevented; + + void AssignMouseEventData(const WidgetMouseEvent& aEvent, bool aCopyTargets) { + AssignMouseEventBaseData(aEvent, aCopyTargets); + AssignPointerHelperData(aEvent, /* aCopyCoalescedEvents */ true); + + mExitFrom = aEvent.mExitFrom; + mClickCount = aEvent.mClickCount; + mIgnoreRootScrollFrame = aEvent.mIgnoreRootScrollFrame; + mUseLegacyNonPrimaryDispatch = aEvent.mUseLegacyNonPrimaryDispatch; + mClickEventPrevented = aEvent.mClickEventPrevented; + } + + /** + * 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; } + + /** + * Returns true if middle click paste is enabled. + */ + static bool IsMiddleClickPasteEnabled(); +}; + +/****************************************************************************** + * mozilla::WidgetDragEvent + ******************************************************************************/ + +class WidgetDragEvent : public WidgetMouseEvent { + private: + friend class mozilla::dom::PBrowserParent; + friend class mozilla::dom::PBrowserChild; + ALLOW_DEPRECATED_READPARAM + + 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; + } + + /** + * Should be called before dispatching the DOM tree if this event is + * synthesized for tests because drop effect is initialized before + * dispatching from widget if it's not synthesized event, but synthesized + * events are not initialized in the path. + */ + void InitDropEffectForTests(); +}; + +/****************************************************************************** + * 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 + // UIEvent::SCROLL_PAGE_UP or UIEvent::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; + ALLOW_DEPRECATED_READPARAM + + WidgetWheelEvent() + : mDeltaX(0.0), + mDeltaY(0.0), + mDeltaZ(0.0), + mOverflowDeltaX(0.0), + mOverflowDeltaY(0.0) + // Including WheelEventBinding.h here leads to an include loop, so + // we have to hardcode WheelEvent_Binding::DOM_DELTA_PIXEL. + , + mDeltaMode(/* WheelEvent_Binding::DOM_DELTA_PIXEL = */ 0), + mLineOrPageDeltaX(0), + mLineOrPageDeltaY(0), + mScrollType(SCROLL_DEFAULT), + mCustomizedByUserPrefs(false), + mMayHaveMomentum(false), + mIsMomentum(false), + mIsNoLineOrPageDelta(false), + mViewPortIsOverscrolled(false), + mCanTriggerSwipe(false), + mAllowToOverrideSystemScrollSpeed(false), + mDeltaValuesHorizontalizedForDefaultHandler(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) + // Including WheelEventBinding.h here leads to an include loop, so + // we have to hardcode WheelEvent_Binding::DOM_DELTA_PIXEL. + , + mDeltaMode(/* WheelEvent_Binding::DOM_DELTA_PIXEL = */ 0), + mLineOrPageDeltaX(0), + mLineOrPageDeltaY(0), + mScrollType(SCROLL_DEFAULT), + mCustomizedByUserPrefs(false), + mMayHaveMomentum(false), + mIsMomentum(false), + mIsNoLineOrPageDelta(false), + mViewPortIsOverscrolled(false), + mCanTriggerSwipe(false), + mAllowToOverrideSystemScrollSpeed(true), + mDeltaValuesHorizontalizedForDefaultHandler(false) {} + + 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; + } + + // 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; + + // The mousewheel tick counts. + double mWheelTicksX = 0.0; + double mWheelTicksY = 0.0; + + enum class DeltaModeCheckingState : uint8_t { + // Neither deltaMode nor the delta values have been accessed. + Unknown, + // The delta values have been accessed, without checking deltaMode first. + Unchecked, + // The deltaMode has been checked. + Checked, + }; + + // For compat reasons, we might expose a DOM_DELTA_LINE event as + // DOM_DELTA_PIXEL instead. Whether we do that depends on whether the event + // has been asked for the deltaMode before the deltas. If it has, we assume + // that the page will correctly handle DOM_DELTA_LINE. This variable tracks + // that state. See bug 1392460. + DeltaModeCheckingState mDeltaModeCheckingState = + DeltaModeCheckingState::Unknown; + + // The amount of scrolling per line or page, without accounting for mouse + // wheel transactions etc. + // + // Computed by EventStateManager::DeltaAccumulator::InitLineOrPageDelta. + nsSize mScrollAmount; + + // overflowed delta values for scroll, these values are set by + // EventStateManger. If the default action of the wheel event isn't scroll, + // these values are always zero. Otherwise, remaining 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 WheelEvent_Binding::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_ASYNCHRONOUSLY, + 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; + + // After the event's default action handler has adjusted its delta's values + // for horizontalizing a vertical wheel scroll, this variable will be set to + // true. + bool mDeltaValuesHorizontalizedForDefaultHandler; + + void AssignWheelEventData(const WidgetWheelEvent& aEvent, bool aCopyTargets) { + AssignMouseEventBaseData(aEvent, aCopyTargets); + + mDeltaX = aEvent.mDeltaX; + mDeltaY = aEvent.mDeltaY; + mDeltaZ = aEvent.mDeltaZ; + mDeltaMode = aEvent.mDeltaMode; + mScrollAmount = aEvent.mScrollAmount; + 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; + mDeltaValuesHorizontalizedForDefaultHandler = + aEvent.mDeltaValuesHorizontalizedForDefaultHandler; + } + + // 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; + ALLOW_DEPRECATED_READPARAM + + 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), + mFromTouchEvent(false) {} + + explicit WidgetPointerEvent(const WidgetMouseEvent& aEvent) + : WidgetMouseEvent(aEvent), + mWidth(1), + mHeight(1), + mIsPrimary(true), + mFromTouchEvent(false) { + 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; + } + + int32_t mWidth; + int32_t mHeight; + bool mIsPrimary; + bool mFromTouchEvent; + + // 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; + mFromTouchEvent = aEvent.mFromTouchEvent; + } +}; + +} // namespace mozilla + +#endif // mozilla_MouseEvents_h__ |