summaryrefslogtreecommitdiffstats
path: root/widget/InputData.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /widget/InputData.cpp
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'widget/InputData.cpp')
-rw-r--r--widget/InputData.cpp925
1 files changed, 925 insertions, 0 deletions
diff --git a/widget/InputData.cpp b/widget/InputData.cpp
new file mode 100644
index 0000000000..0265aab5a8
--- /dev/null
+++ b/widget/InputData.cpp
@@ -0,0 +1,925 @@
+/* -*- 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/. */
+
+#include "InputData.h"
+
+#include "mozilla/dom/MouseEventBinding.h"
+#include "mozilla/dom/Touch.h"
+#include "mozilla/dom/WheelEventBinding.h"
+#include "mozilla/TextEvents.h"
+#include "nsContentUtils.h"
+#include "nsDebug.h"
+#include "nsThreadUtils.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/TouchEvents.h"
+#include "mozilla/SwipeTracker.h"
+#include "UnitTransforms.h"
+
+namespace mozilla {
+
+using namespace dom;
+
+InputData::~InputData() = default;
+
+InputData::InputData(InputType aInputType)
+ : mInputType(aInputType),
+ mFocusSequenceNumber(0),
+ mLayersId{0},
+ modifiers(0) {}
+
+InputData::InputData(InputType aInputType, TimeStamp aTimeStamp,
+ Modifiers aModifiers)
+ : mInputType(aInputType),
+ mTimeStamp(aTimeStamp),
+ mFocusSequenceNumber(0),
+ mLayersId{0},
+ modifiers(aModifiers) {}
+
+SingleTouchData::SingleTouchData(int32_t aIdentifier,
+ ScreenIntPoint aScreenPoint,
+ ScreenSize aRadius, float aRotationAngle,
+ float aForce)
+ : mIdentifier(aIdentifier),
+ mScreenPoint(aScreenPoint),
+ mRadius(aRadius),
+ mRotationAngle(aRotationAngle),
+ mForce(aForce) {}
+
+SingleTouchData::SingleTouchData(int32_t aIdentifier,
+ ParentLayerPoint aLocalScreenPoint,
+ ScreenSize aRadius, float aRotationAngle,
+ float aForce)
+ : mIdentifier(aIdentifier),
+ mLocalScreenPoint(aLocalScreenPoint),
+ mRadius(aRadius),
+ mRotationAngle(aRotationAngle),
+ mForce(aForce) {}
+
+SingleTouchData::SingleTouchData()
+ : mIdentifier(0), mRotationAngle(0.0), mForce(0.0) {}
+
+already_AddRefed<Touch> SingleTouchData::ToNewDOMTouch() const {
+ MOZ_ASSERT(NS_IsMainThread(),
+ "Can only create dom::Touch instances on main thread");
+ RefPtr<Touch> touch =
+ new Touch(mIdentifier,
+ LayoutDeviceIntPoint::Truncate(mScreenPoint.x, mScreenPoint.y),
+ LayoutDeviceIntPoint::Truncate(mRadius.width, mRadius.height),
+ mRotationAngle, mForce);
+ touch->tiltX = mTiltX;
+ touch->tiltY = mTiltY;
+ touch->twist = mTwist;
+ return touch.forget();
+}
+
+MultiTouchInput::MultiTouchInput(MultiTouchType aType, uint32_t aTime,
+ TimeStamp aTimeStamp, Modifiers aModifiers)
+ : InputData(MULTITOUCH_INPUT, aTimeStamp, aModifiers),
+ mType(aType),
+ mHandledByAPZ(false) {}
+
+MultiTouchInput::MultiTouchInput()
+ : InputData(MULTITOUCH_INPUT),
+ mType(MULTITOUCH_START),
+ mHandledByAPZ(false) {}
+
+MultiTouchInput::MultiTouchInput(const WidgetTouchEvent& aTouchEvent)
+ : InputData(MULTITOUCH_INPUT, aTouchEvent.mTimeStamp,
+ aTouchEvent.mModifiers),
+ mHandledByAPZ(aTouchEvent.mFlags.mHandledByAPZ),
+ mButton(aTouchEvent.mButton),
+ mButtons(aTouchEvent.mButtons) {
+ MOZ_ASSERT(NS_IsMainThread(),
+ "Can only copy from WidgetTouchEvent on main thread");
+
+ switch (aTouchEvent.mMessage) {
+ case eTouchStart:
+ mType = MULTITOUCH_START;
+ break;
+ case eTouchMove:
+ mType = MULTITOUCH_MOVE;
+ break;
+ case eTouchEnd:
+ mType = MULTITOUCH_END;
+ break;
+ case eTouchCancel:
+ mType = MULTITOUCH_CANCEL;
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE("Did not assign a type to a MultiTouchInput");
+ break;
+ }
+
+ mScreenOffset = ViewAs<ExternalPixel>(
+ aTouchEvent.mWidget->WidgetToScreenOffset(),
+ PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent);
+
+ for (size_t i = 0; i < aTouchEvent.mTouches.Length(); i++) {
+ const Touch* domTouch = aTouchEvent.mTouches[i];
+
+ // Extract data from weird interfaces.
+ int32_t identifier = domTouch->Identifier();
+ int32_t radiusX = domTouch->RadiusX(CallerType::System);
+ int32_t radiusY = domTouch->RadiusY(CallerType::System);
+ float rotationAngle = domTouch->RotationAngle(CallerType::System);
+ float force = domTouch->Force(CallerType::System);
+
+ SingleTouchData data(
+ identifier,
+ ViewAs<ScreenPixel>(
+ domTouch->mRefPoint,
+ PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent),
+ ScreenSize((float)radiusX, (float)radiusY), rotationAngle, force);
+
+ mTouches.AppendElement(data);
+ }
+}
+
+void MultiTouchInput::Translate(const ScreenPoint& aTranslation) {
+ const int32_t xTranslation = (int32_t)(aTranslation.x + 0.5f);
+ const int32_t yTranslation = (int32_t)(aTranslation.y + 0.5f);
+
+ for (auto& touchData : mTouches) {
+ for (auto& historicalData : touchData.mHistoricalData) {
+ historicalData.mScreenPoint.MoveBy(xTranslation, yTranslation);
+ }
+ touchData.mScreenPoint.MoveBy(xTranslation, yTranslation);
+ }
+}
+
+WidgetTouchEvent MultiTouchInput::ToWidgetEvent(nsIWidget* aWidget,
+ uint16_t aInputSource) const {
+ MOZ_ASSERT(NS_IsMainThread(),
+ "Can only convert To WidgetTouchEvent on main thread");
+ MOZ_ASSERT(aInputSource ==
+ mozilla::dom::MouseEvent_Binding::MOZ_SOURCE_TOUCH ||
+ aInputSource == mozilla::dom::MouseEvent_Binding::MOZ_SOURCE_PEN);
+
+ EventMessage touchEventMessage = eVoidEvent;
+ switch (mType) {
+ case MULTITOUCH_START:
+ touchEventMessage = eTouchStart;
+ break;
+ case MULTITOUCH_MOVE:
+ touchEventMessage = eTouchMove;
+ break;
+ case MULTITOUCH_END:
+ touchEventMessage = eTouchEnd;
+ break;
+ case MULTITOUCH_CANCEL:
+ touchEventMessage = eTouchCancel;
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE(
+ "Did not assign a type to WidgetTouchEvent in MultiTouchInput");
+ break;
+ }
+
+ WidgetTouchEvent event(true, touchEventMessage, aWidget);
+ if (touchEventMessage == eVoidEvent) {
+ return event;
+ }
+
+ event.mModifiers = this->modifiers;
+ event.mTimeStamp = this->mTimeStamp;
+ event.mFlags.mHandledByAPZ = mHandledByAPZ;
+ event.mFocusSequenceNumber = mFocusSequenceNumber;
+ event.mLayersId = mLayersId;
+ event.mInputSource = aInputSource;
+ event.mButton = mButton;
+ event.mButtons = mButtons;
+
+ for (size_t i = 0; i < mTouches.Length(); i++) {
+ *event.mTouches.AppendElement() = mTouches[i].ToNewDOMTouch();
+ }
+
+ return event;
+}
+
+int32_t MultiTouchInput::IndexOfTouch(int32_t aTouchIdentifier) {
+ for (size_t i = 0; i < mTouches.Length(); i++) {
+ if (mTouches[i].mIdentifier == aTouchIdentifier) {
+ return (int32_t)i;
+ }
+ }
+ return -1;
+}
+
+bool MultiTouchInput::TransformToLocal(
+ const ScreenToParentLayerMatrix4x4& aTransform) {
+ for (auto& touchData : mTouches) {
+ for (auto& historicalData : touchData.mHistoricalData) {
+ Maybe<ParentLayerIntPoint> historicalPoint =
+ UntransformBy(aTransform, historicalData.mScreenPoint);
+ if (!historicalPoint) {
+ return false;
+ }
+ historicalData.mLocalScreenPoint = *historicalPoint;
+ }
+ Maybe<ParentLayerIntPoint> point =
+ UntransformBy(aTransform, touchData.mScreenPoint);
+ if (!point) {
+ return false;
+ }
+ touchData.mLocalScreenPoint = *point;
+ }
+ return true;
+}
+
+MouseInput::MouseInput()
+ : InputData(MOUSE_INPUT),
+ mType(MOUSE_NONE),
+ mButtonType(NONE),
+ mInputSource(0),
+ mButtons(0),
+ mHandledByAPZ(false),
+ mPreventClickEvent(false) {}
+
+MouseInput::MouseInput(MouseType aType, ButtonType aButtonType,
+ uint16_t aInputSource, int16_t aButtons,
+ const ScreenPoint& aPoint, TimeStamp aTimeStamp,
+ Modifiers aModifiers)
+ : InputData(MOUSE_INPUT, aTimeStamp, aModifiers),
+ mType(aType),
+ mButtonType(aButtonType),
+ mInputSource(aInputSource),
+ mButtons(aButtons),
+ mOrigin(aPoint),
+ mHandledByAPZ(false),
+ mPreventClickEvent(false) {}
+
+MouseInput::MouseInput(const WidgetMouseEventBase& aMouseEvent)
+ : InputData(MOUSE_INPUT, aMouseEvent.mTimeStamp, aMouseEvent.mModifiers),
+ mType(MOUSE_NONE),
+ mButtonType(NONE),
+ mInputSource(aMouseEvent.mInputSource),
+ mButtons(aMouseEvent.mButtons),
+ mHandledByAPZ(aMouseEvent.mFlags.mHandledByAPZ),
+ mPreventClickEvent(aMouseEvent.mClass == eMouseEventClass &&
+ aMouseEvent.AsMouseEvent()->mClickEventPrevented) {
+ MOZ_ASSERT(NS_IsMainThread(),
+ "Can only copy from WidgetTouchEvent on main thread");
+
+ mButtonType = NONE;
+
+ switch (aMouseEvent.mButton) {
+ case MouseButton::ePrimary:
+ mButtonType = MouseInput::PRIMARY_BUTTON;
+ break;
+ case MouseButton::eMiddle:
+ mButtonType = MouseInput::MIDDLE_BUTTON;
+ break;
+ case MouseButton::eSecondary:
+ mButtonType = MouseInput::SECONDARY_BUTTON;
+ break;
+ }
+
+ switch (aMouseEvent.mMessage) {
+ case eMouseMove:
+ mType = MOUSE_MOVE;
+ break;
+ case eMouseUp:
+ mType = MOUSE_UP;
+ break;
+ case eMouseDown:
+ mType = MOUSE_DOWN;
+ break;
+ case eDragStart:
+ mType = MOUSE_DRAG_START;
+ break;
+ case eDragEnd:
+ mType = MOUSE_DRAG_END;
+ break;
+ case eMouseEnterIntoWidget:
+ mType = MOUSE_WIDGET_ENTER;
+ break;
+ case eMouseExitFromWidget:
+ mType = MOUSE_WIDGET_EXIT;
+ break;
+ case eMouseExploreByTouch:
+ mType = MOUSE_EXPLORE_BY_TOUCH;
+ break;
+ case eMouseHitTest:
+ mType = MOUSE_HITTEST;
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE("Mouse event type not supported");
+ break;
+ }
+
+ mOrigin = ScreenPoint(ViewAs<ScreenPixel>(
+ aMouseEvent.mRefPoint,
+ PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
+}
+
+bool MouseInput::IsLeftButton() const { return mButtonType == PRIMARY_BUTTON; }
+
+bool MouseInput::TransformToLocal(
+ const ScreenToParentLayerMatrix4x4& aTransform) {
+ Maybe<ParentLayerPoint> point = UntransformBy(aTransform, mOrigin);
+ if (!point) {
+ return false;
+ }
+ mLocalOrigin = *point;
+
+ return true;
+}
+
+WidgetMouseEvent MouseInput::ToWidgetEvent(nsIWidget* aWidget) const {
+ MOZ_ASSERT(NS_IsMainThread(),
+ "Can only convert To WidgetTouchEvent on main thread");
+
+ EventMessage msg = eVoidEvent;
+ uint32_t clickCount = 0;
+ Maybe<WidgetMouseEvent::ExitFrom> exitFrom;
+ switch (mType) {
+ case MOUSE_MOVE:
+ msg = eMouseMove;
+ break;
+ case MOUSE_UP:
+ msg = eMouseUp;
+ clickCount = 1;
+ break;
+ case MOUSE_DOWN:
+ msg = eMouseDown;
+ clickCount = 1;
+ break;
+ case MOUSE_DRAG_START:
+ msg = eDragStart;
+ break;
+ case MOUSE_DRAG_END:
+ msg = eDragEnd;
+ break;
+ case MOUSE_WIDGET_ENTER:
+ msg = eMouseEnterIntoWidget;
+ break;
+ case MOUSE_WIDGET_EXIT:
+ msg = eMouseExitFromWidget;
+ exitFrom = Some(WidgetMouseEvent::ePlatformChild);
+ break;
+ case MOUSE_EXPLORE_BY_TOUCH:
+ msg = eMouseExploreByTouch;
+ break;
+ case MOUSE_HITTEST:
+ msg = eMouseHitTest;
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE(
+ "Did not assign a type to WidgetMouseEvent in MouseInput");
+ break;
+ }
+
+ WidgetMouseEvent event(true, msg, aWidget, WidgetMouseEvent::eReal,
+ WidgetMouseEvent::eNormal);
+
+ if (msg == eVoidEvent) {
+ return event;
+ }
+
+ switch (mButtonType) {
+ case MouseInput::PRIMARY_BUTTON:
+ event.mButton = MouseButton::ePrimary;
+ break;
+ case MouseInput::MIDDLE_BUTTON:
+ event.mButton = MouseButton::eMiddle;
+ break;
+ case MouseInput::SECONDARY_BUTTON:
+ event.mButton = MouseButton::eSecondary;
+ break;
+ case MouseInput::NONE:
+ default:
+ break;
+ }
+
+ event.mButtons = mButtons;
+ event.mModifiers = modifiers;
+ event.mTimeStamp = mTimeStamp;
+ event.mLayersId = mLayersId;
+ event.mFlags.mHandledByAPZ = mHandledByAPZ;
+ event.mRefPoint = RoundedToInt(ViewAs<LayoutDevicePixel>(
+ mOrigin,
+ PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
+ event.mClickCount = clickCount;
+ event.mInputSource = mInputSource;
+ event.mFocusSequenceNumber = mFocusSequenceNumber;
+ event.mExitFrom = exitFrom;
+ event.mClickEventPrevented = mPreventClickEvent;
+
+ return event;
+}
+
+PanGestureInput::PanGestureInput()
+ : InputData(PANGESTURE_INPUT),
+ mType(PANGESTURE_MAYSTART),
+ mLineOrPageDeltaX(0),
+ mLineOrPageDeltaY(0),
+ mUserDeltaMultiplierX(1.0),
+ mUserDeltaMultiplierY(1.0),
+ mHandledByAPZ(false),
+ mOverscrollBehaviorAllowsSwipe(false),
+ mSimulateMomentum(false),
+ mIsNoLineOrPageDelta(true),
+ mMayTriggerSwipe(false) {}
+
+PanGestureInput::PanGestureInput(PanGestureType aType, TimeStamp aTimeStamp,
+ const ScreenPoint& aPanStartPoint,
+ const ScreenPoint& aPanDisplacement,
+ Modifiers aModifiers)
+ : InputData(PANGESTURE_INPUT, aTimeStamp, aModifiers),
+ mType(aType),
+ mPanStartPoint(aPanStartPoint),
+ mPanDisplacement(aPanDisplacement),
+ mLineOrPageDeltaX(0),
+ mLineOrPageDeltaY(0),
+ mUserDeltaMultiplierX(1.0),
+ mUserDeltaMultiplierY(1.0),
+ mHandledByAPZ(false),
+ mOverscrollBehaviorAllowsSwipe(false),
+ mSimulateMomentum(false),
+ mIsNoLineOrPageDelta(true) {
+ mMayTriggerSwipe = SwipeTracker::CanTriggerSwipe(*this);
+}
+
+PanGestureInput::PanGestureInput(PanGestureType aType, TimeStamp aTimeStamp,
+ const ScreenPoint& aPanStartPoint,
+ const ScreenPoint& aPanDisplacement,
+ Modifiers aModifiers,
+ IsEligibleForSwipe aIsEligibleForSwipe)
+ : PanGestureInput(aType, aTimeStamp, aPanStartPoint, aPanDisplacement,
+ aModifiers) {
+ mMayTriggerSwipe &= bool(aIsEligibleForSwipe);
+}
+
+void PanGestureInput::SetLineOrPageDeltas(int32_t aLineOrPageDeltaX,
+ int32_t aLineOrPageDeltaY) {
+ mLineOrPageDeltaX = aLineOrPageDeltaX;
+ mLineOrPageDeltaY = aLineOrPageDeltaY;
+ mIsNoLineOrPageDelta = false;
+}
+
+bool PanGestureInput::IsMomentum() const {
+ switch (mType) {
+ case PanGestureInput::PANGESTURE_MOMENTUMSTART:
+ case PanGestureInput::PANGESTURE_MOMENTUMPAN:
+ case PanGestureInput::PANGESTURE_MOMENTUMEND:
+ return true;
+ default:
+ return false;
+ }
+}
+
+WidgetWheelEvent PanGestureInput::ToWidgetEvent(nsIWidget* aWidget) const {
+ WidgetWheelEvent wheelEvent(true, eWheel, aWidget);
+ wheelEvent.mModifiers = this->modifiers;
+ wheelEvent.mTimeStamp = mTimeStamp;
+ wheelEvent.mLayersId = mLayersId;
+ wheelEvent.mRefPoint = RoundedToInt(ViewAs<LayoutDevicePixel>(
+ mPanStartPoint,
+ PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
+ wheelEvent.mButtons = 0;
+ wheelEvent.mMayHaveMomentum = true; // pan inputs may have momentum
+ wheelEvent.mIsMomentum = IsMomentum();
+ wheelEvent.mLineOrPageDeltaX = mLineOrPageDeltaX;
+ wheelEvent.mLineOrPageDeltaY = mLineOrPageDeltaY;
+ wheelEvent.mDeltaX = mPanDisplacement.x;
+ wheelEvent.mDeltaY = mPanDisplacement.y;
+ wheelEvent.mFlags.mHandledByAPZ = mHandledByAPZ;
+ wheelEvent.mFocusSequenceNumber = mFocusSequenceNumber;
+ wheelEvent.mIsNoLineOrPageDelta = mIsNoLineOrPageDelta;
+ if (mDeltaType == PanGestureInput::PANDELTA_PAGE) {
+ // widget/gtk is currently the only consumer that uses delta type
+ // PANDELTA_PAGE
+ // Emulate legacy widget/gtk behavior
+ wheelEvent.mDeltaMode = WheelEvent_Binding::DOM_DELTA_LINE;
+ wheelEvent.mScrollType = WidgetWheelEvent::SCROLL_ASYNCHRONOUSLY;
+ wheelEvent.mDeltaX *= 3;
+ wheelEvent.mDeltaY *= 3;
+ } else {
+ wheelEvent.mDeltaMode = WheelEvent_Binding::DOM_DELTA_PIXEL;
+ }
+ return wheelEvent;
+}
+
+bool PanGestureInput::TransformToLocal(
+ const ScreenToParentLayerMatrix4x4& aTransform) {
+ Maybe<ParentLayerPoint> panStartPoint =
+ UntransformBy(aTransform, mPanStartPoint);
+ if (!panStartPoint) {
+ return false;
+ }
+ mLocalPanStartPoint = *panStartPoint;
+
+ if (mDeltaType == PanGestureInput::PANDELTA_PAGE) {
+ // Skip transforming the pan displacement because we want
+ // raw page proportion counts.
+ mLocalPanDisplacement = ViewAs<ParentLayerPixel>(
+ mPanDisplacement, PixelCastJustification::DeltaIsPageProportion);
+ return true;
+ }
+
+ Maybe<ParentLayerPoint> panDisplacement =
+ UntransformVector(aTransform, mPanDisplacement, mPanStartPoint);
+ if (!panDisplacement) {
+ return false;
+ }
+ mLocalPanDisplacement = *panDisplacement;
+ return true;
+}
+
+ScreenPoint PanGestureInput::UserMultipliedPanDisplacement() const {
+ return ScreenPoint(mPanDisplacement.x * mUserDeltaMultiplierX,
+ mPanDisplacement.y * mUserDeltaMultiplierY);
+}
+
+ParentLayerPoint PanGestureInput::UserMultipliedLocalPanDisplacement() const {
+ return ParentLayerPoint(mLocalPanDisplacement.x * mUserDeltaMultiplierX,
+ mLocalPanDisplacement.y * mUserDeltaMultiplierY);
+}
+
+static int32_t TakeLargestInt(gfx::Coord* aCoord) {
+ int32_t result(aCoord->value); // truncate towards zero
+ aCoord->value -= result;
+ return result;
+}
+
+/* static */ gfx::IntPoint PanGestureInput::GetIntegerDeltaForEvent(
+ bool aIsStart, float x, float y) {
+ static gfx::Point sAccumulator(0.0f, 0.0f);
+ if (aIsStart) {
+ sAccumulator = gfx::Point(0.0f, 0.0f);
+ }
+ sAccumulator.x += x;
+ sAccumulator.y += y;
+ return gfx::IntPoint(TakeLargestInt(&sAccumulator.x),
+ TakeLargestInt(&sAccumulator.y));
+}
+
+PinchGestureInput::PinchGestureInput()
+ : InputData(PINCHGESTURE_INPUT),
+ mType(PINCHGESTURE_START),
+ mSource(UNKNOWN),
+ mHandledByAPZ(false) {}
+
+PinchGestureInput::PinchGestureInput(
+ PinchGestureType aType, PinchGestureSource aSource, TimeStamp aTimeStamp,
+ const ExternalPoint& aScreenOffset, const ScreenPoint& aFocusPoint,
+ ScreenCoord aCurrentSpan, ScreenCoord aPreviousSpan, Modifiers aModifiers)
+ : InputData(PINCHGESTURE_INPUT, aTimeStamp, aModifiers),
+ mType(aType),
+ mSource(aSource),
+ mFocusPoint(aFocusPoint),
+ mScreenOffset(aScreenOffset),
+ mCurrentSpan(aCurrentSpan),
+ mPreviousSpan(aPreviousSpan),
+ mLineOrPageDeltaY(0),
+ mHandledByAPZ(false) {}
+
+bool PinchGestureInput::TransformToLocal(
+ const ScreenToParentLayerMatrix4x4& aTransform) {
+ Maybe<ParentLayerPoint> point = UntransformBy(aTransform, mFocusPoint);
+ if (!point) {
+ return false;
+ }
+ mLocalFocusPoint = *point;
+ return true;
+}
+
+WidgetWheelEvent PinchGestureInput::ToWidgetEvent(nsIWidget* aWidget) const {
+ WidgetWheelEvent wheelEvent(true, eWheel, aWidget);
+ wheelEvent.mModifiers = this->modifiers | MODIFIER_CONTROL;
+ wheelEvent.mTimeStamp = mTimeStamp;
+ wheelEvent.mLayersId = mLayersId;
+ wheelEvent.mRefPoint = RoundedToInt(ViewAs<LayoutDevicePixel>(
+ mFocusPoint,
+ PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
+ wheelEvent.mButtons = 0;
+ wheelEvent.mFlags.mHandledByAPZ = mHandledByAPZ;
+ wheelEvent.mDeltaMode = WheelEvent_Binding::DOM_DELTA_PIXEL;
+
+ wheelEvent.mDeltaY = ComputeDeltaY(aWidget);
+
+ wheelEvent.mLineOrPageDeltaY = mLineOrPageDeltaY;
+
+ MOZ_ASSERT(mType == PINCHGESTURE_END || wheelEvent.mDeltaY != 0.0);
+
+ return wheelEvent;
+}
+
+double PinchGestureInput::ComputeDeltaY(nsIWidget* aWidget) const {
+#if defined(OS_MACOSX)
+ // This converts the pinch gesture value to a fake wheel event that has the
+ // control key pressed so that pages can implement custom pinch gesture
+ // handling. It may seem strange that this doesn't use a wheel event with
+ // the deltaZ property set, but this matches Chrome's behavior as described
+ // at https://code.google.com/p/chromium/issues/detail?id=289887
+ //
+ // The intent of the formula below is to produce numbers similar to Chrome's
+ // implementation of this feature. Chrome implements deltaY using the formula
+ // "-100 * log(1 + [event magnification])" which is unfortunately incorrect.
+ // All deltas for a single pinch gesture should sum to 0 if the start and end
+ // of a pinch gesture end up in the same place. This doesn't happen in Chrome
+ // because they followed Apple's misleading documentation, which implies that
+ // "1 + [event magnification]" is the scale factor. The scale factor is
+ // instead "pow(ratio, [event magnification])" so "[event magnification]" is
+ // already in log space.
+ //
+ // The multiplication by the backing scale factor below counteracts the
+ // division by the backing scale factor in WheelEvent.
+
+ // We want to set deltaY to |-100.0 * M * GetDefaultScaleInternal()| where M
+ // is [event magnification] but [event magnification] is only available in the
+ // macOS widget code so we have to reverse engineer from mCurrentSpan and
+ // mPreviousSpan (which are derived from [event magnification]) to get it.
+ // Specifically, we know |mCurrentSpan == 100.0| and |mPreviousSpan == 100.0 *
+ // (1.0 - M)|. We can calculate deltaY by solving the mPreviousSpan equation
+ // for M in terms of mPreviousSpan and plugging that into to the formula for
+ // deltaY.
+ return (mPreviousSpan - 100.0) *
+ (aWidget ? aWidget->GetDefaultScaleInternal() : 1.f);
+#else
+ // This calculation is based on what the Windows and Linux widget code does.
+ // Specifically, it creates a PinchGestureInput with |mCurrentSpan == 100.0 *
+ // currentScale| and |mPreviousSpan == 100.0 * lastScale| where currentScale
+ // is the scale from the current OS event and lastScale is the scale when the
+ // previous OS event happened. On macOS [event magnification] is a relative
+ // change in scale factor, ie if the scale factor changed from 1 to 1.1 it
+ // will be 0.1, similarly if it changed from 1 to 0.9 it will be -0.1. To
+ // calculate the relative scale change on Windows we would calculate |M =
+ // currentScale - lastScale = (mCurrentSpan-mPreviousSpan)/100| and use the
+ // same formula as the macOS code
+ // (|-100.0 * M * GetDefaultScaleInternal()|).
+
+ return (mPreviousSpan - mCurrentSpan) *
+ (aWidget ? aWidget->GetDefaultScaleInternal() : 1.f);
+#endif
+}
+
+bool PinchGestureInput::SetLineOrPageDeltaY(nsIWidget* aWidget) {
+ double deltaY = ComputeDeltaY(aWidget);
+ if (deltaY == 0 && mType != PINCHGESTURE_END) {
+ return false;
+ }
+ gfx::IntPoint lineOrPageDelta = PinchGestureInput::GetIntegerDeltaForEvent(
+ (mType == PINCHGESTURE_START), 0, deltaY);
+ mLineOrPageDeltaY = lineOrPageDelta.y;
+ if (mLineOrPageDeltaY == 0) {
+ // For PINCHGESTURE_SCALE events, don't dispatch them. Note that the delta
+ // isn't lost; it remains in the accumulator in GetIntegerDeltaForEvent().
+ if (mType == PINCHGESTURE_SCALE) {
+ return false;
+ }
+ // On Windows, drop PINCHGESTURE_START as well (the Windows widget code will
+ // defer the START event until we accumulate enough delta).
+ // The Linux widget code doesn't support this, so instead set the event's
+ // mLineOrPageDeltaY to the smallest nonzero amount in the relevant
+ // direction.
+ if (mType == PINCHGESTURE_START) {
+#ifdef XP_WIN
+ return false;
+#else
+ mLineOrPageDeltaY = (deltaY >= 0) ? 1 : -1;
+#endif
+ }
+ // For PINCHGESTURE_END events, not dispatching a DOMMouseScroll for them is
+ // fine.
+ }
+ return true;
+}
+
+/* static */ gfx::IntPoint PinchGestureInput::GetIntegerDeltaForEvent(
+ bool aIsStart, float x, float y) {
+ static gfx::Point sAccumulator(0.0f, 0.0f);
+ if (aIsStart) {
+ sAccumulator = gfx::Point(0.0f, 0.0f);
+ }
+ sAccumulator.x += x;
+ sAccumulator.y += y;
+ return gfx::IntPoint(TakeLargestInt(&sAccumulator.x),
+ TakeLargestInt(&sAccumulator.y));
+}
+
+TapGestureInput::TapGestureInput()
+ : InputData(TAPGESTURE_INPUT), mType(TAPGESTURE_LONG) {}
+
+TapGestureInput::TapGestureInput(TapGestureType aType, TimeStamp aTimeStamp,
+ const ScreenIntPoint& aPoint,
+ Modifiers aModifiers)
+ : InputData(TAPGESTURE_INPUT, aTimeStamp, aModifiers),
+ mType(aType),
+ mPoint(aPoint) {}
+
+TapGestureInput::TapGestureInput(TapGestureType aType, TimeStamp aTimeStamp,
+ const ParentLayerPoint& aLocalPoint,
+ Modifiers aModifiers)
+ : InputData(TAPGESTURE_INPUT, aTimeStamp, aModifiers),
+ mType(aType),
+ mLocalPoint(aLocalPoint) {}
+
+bool TapGestureInput::TransformToLocal(
+ const ScreenToParentLayerMatrix4x4& aTransform) {
+ Maybe<ParentLayerIntPoint> point = UntransformBy(aTransform, mPoint);
+ if (!point) {
+ return false;
+ }
+ mLocalPoint = *point;
+ return true;
+}
+
+WidgetSimpleGestureEvent TapGestureInput::ToWidgetEvent(
+ nsIWidget* aWidget) const {
+ WidgetSimpleGestureEvent event(true, eTapGesture, aWidget);
+
+ event.mTimeStamp = mTimeStamp;
+ event.mLayersId = mLayersId;
+ event.mRefPoint = ViewAs<LayoutDevicePixel>(
+ mPoint,
+ PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent);
+ event.mButtons = 0;
+ event.mClickCount = 1;
+ event.mModifiers = modifiers;
+
+ return event;
+}
+
+ScrollWheelInput::ScrollWheelInput()
+ : InputData(SCROLLWHEEL_INPUT),
+ mDeltaType(SCROLLDELTA_LINE),
+ mScrollMode(SCROLLMODE_INSTANT),
+ mHandledByAPZ(false),
+ mDeltaX(0.0),
+ mDeltaY(0.0),
+ mLineOrPageDeltaX(0),
+ mLineOrPageDeltaY(0),
+ mScrollSeriesNumber(0),
+ mUserDeltaMultiplierX(1.0),
+ mUserDeltaMultiplierY(1.0),
+ mMayHaveMomentum(false),
+ mIsMomentum(false),
+ mAPZAction(APZWheelAction::Scroll) {}
+
+ScrollWheelInput::ScrollWheelInput(
+ TimeStamp aTimeStamp, Modifiers aModifiers, ScrollMode aScrollMode,
+ ScrollDeltaType aDeltaType, const ScreenPoint& aOrigin, double aDeltaX,
+ double aDeltaY, bool aAllowToOverrideSystemScrollSpeed,
+ WheelDeltaAdjustmentStrategy aWheelDeltaAdjustmentStrategy)
+ : InputData(SCROLLWHEEL_INPUT, aTimeStamp, aModifiers),
+ mDeltaType(aDeltaType),
+ mScrollMode(aScrollMode),
+ mOrigin(aOrigin),
+ mHandledByAPZ(false),
+ mDeltaX(aDeltaX),
+ mDeltaY(aDeltaY),
+ mLineOrPageDeltaX(0),
+ mLineOrPageDeltaY(0),
+ mScrollSeriesNumber(0),
+ mUserDeltaMultiplierX(1.0),
+ mUserDeltaMultiplierY(1.0),
+ mMayHaveMomentum(false),
+ mIsMomentum(false),
+ mAllowToOverrideSystemScrollSpeed(aAllowToOverrideSystemScrollSpeed),
+ mWheelDeltaAdjustmentStrategy(aWheelDeltaAdjustmentStrategy),
+ mAPZAction(APZWheelAction::Scroll) {}
+
+ScrollWheelInput::ScrollWheelInput(const WidgetWheelEvent& aWheelEvent)
+ : InputData(SCROLLWHEEL_INPUT, aWheelEvent.mTimeStamp,
+ aWheelEvent.mModifiers),
+ mDeltaType(DeltaTypeForDeltaMode(aWheelEvent.mDeltaMode)),
+ mScrollMode(SCROLLMODE_INSTANT),
+ mHandledByAPZ(aWheelEvent.mFlags.mHandledByAPZ),
+ mDeltaX(aWheelEvent.mDeltaX),
+ mDeltaY(aWheelEvent.mDeltaY),
+ mWheelTicksX(aWheelEvent.mWheelTicksX),
+ mWheelTicksY(aWheelEvent.mWheelTicksX),
+ mLineOrPageDeltaX(aWheelEvent.mLineOrPageDeltaX),
+ mLineOrPageDeltaY(aWheelEvent.mLineOrPageDeltaY),
+ mScrollSeriesNumber(0),
+ mUserDeltaMultiplierX(1.0),
+ mUserDeltaMultiplierY(1.0),
+ mMayHaveMomentum(aWheelEvent.mMayHaveMomentum),
+ mIsMomentum(aWheelEvent.mIsMomentum),
+ mAllowToOverrideSystemScrollSpeed(
+ aWheelEvent.mAllowToOverrideSystemScrollSpeed),
+ mWheelDeltaAdjustmentStrategy(WheelDeltaAdjustmentStrategy::eNone),
+ mAPZAction(APZWheelAction::Scroll) {
+ mOrigin = ScreenPoint(ViewAs<ScreenPixel>(
+ aWheelEvent.mRefPoint,
+ PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
+}
+
+ScrollWheelInput::ScrollDeltaType ScrollWheelInput::DeltaTypeForDeltaMode(
+ uint32_t aDeltaMode) {
+ switch (aDeltaMode) {
+ case WheelEvent_Binding::DOM_DELTA_LINE:
+ return SCROLLDELTA_LINE;
+ case WheelEvent_Binding::DOM_DELTA_PAGE:
+ return SCROLLDELTA_PAGE;
+ case WheelEvent_Binding::DOM_DELTA_PIXEL:
+ return SCROLLDELTA_PIXEL;
+ default:
+ MOZ_CRASH();
+ }
+ return SCROLLDELTA_LINE;
+}
+
+uint32_t ScrollWheelInput::DeltaModeForDeltaType(ScrollDeltaType aDeltaType) {
+ switch (aDeltaType) {
+ case ScrollWheelInput::SCROLLDELTA_LINE:
+ return WheelEvent_Binding::DOM_DELTA_LINE;
+ case ScrollWheelInput::SCROLLDELTA_PAGE:
+ return WheelEvent_Binding::DOM_DELTA_PAGE;
+ case ScrollWheelInput::SCROLLDELTA_PIXEL:
+ default:
+ return WheelEvent_Binding::DOM_DELTA_PIXEL;
+ }
+}
+
+ScrollUnit ScrollWheelInput::ScrollUnitForDeltaType(
+ ScrollDeltaType aDeltaType) {
+ switch (aDeltaType) {
+ case SCROLLDELTA_LINE:
+ return ScrollUnit::LINES;
+ case SCROLLDELTA_PAGE:
+ return ScrollUnit::PAGES;
+ case SCROLLDELTA_PIXEL:
+ return ScrollUnit::DEVICE_PIXELS;
+ default:
+ MOZ_CRASH();
+ }
+ return ScrollUnit::LINES;
+}
+
+WidgetWheelEvent ScrollWheelInput::ToWidgetEvent(nsIWidget* aWidget) const {
+ WidgetWheelEvent wheelEvent(true, eWheel, aWidget);
+ wheelEvent.mModifiers = this->modifiers;
+ wheelEvent.mTimeStamp = mTimeStamp;
+ wheelEvent.mLayersId = mLayersId;
+ wheelEvent.mRefPoint = RoundedToInt(ViewAs<LayoutDevicePixel>(
+ mOrigin,
+ PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent));
+ wheelEvent.mButtons = 0;
+ wheelEvent.mDeltaMode = DeltaModeForDeltaType(mDeltaType);
+ wheelEvent.mMayHaveMomentum = mMayHaveMomentum;
+ wheelEvent.mIsMomentum = mIsMomentum;
+ wheelEvent.mDeltaX = mDeltaX;
+ wheelEvent.mDeltaY = mDeltaY;
+ wheelEvent.mWheelTicksX = mWheelTicksX;
+ wheelEvent.mWheelTicksY = mWheelTicksY;
+ wheelEvent.mLineOrPageDeltaX = mLineOrPageDeltaX;
+ wheelEvent.mLineOrPageDeltaY = mLineOrPageDeltaY;
+ wheelEvent.mAllowToOverrideSystemScrollSpeed =
+ mAllowToOverrideSystemScrollSpeed;
+ wheelEvent.mFlags.mHandledByAPZ = mHandledByAPZ;
+ wheelEvent.mFocusSequenceNumber = mFocusSequenceNumber;
+ return wheelEvent;
+}
+
+bool ScrollWheelInput::TransformToLocal(
+ const ScreenToParentLayerMatrix4x4& aTransform) {
+ Maybe<ParentLayerPoint> point = UntransformBy(aTransform, mOrigin);
+ if (!point) {
+ return false;
+ }
+ mLocalOrigin = *point;
+ return true;
+}
+
+bool ScrollWheelInput::IsCustomizedByUserPrefs() const {
+ return mUserDeltaMultiplierX != 1.0 || mUserDeltaMultiplierY != 1.0;
+}
+
+KeyboardInput::KeyboardInput(const WidgetKeyboardEvent& aEvent)
+ : InputData(KEYBOARD_INPUT, aEvent.mTimeStamp, aEvent.mModifiers),
+ mKeyCode(aEvent.mKeyCode),
+ mCharCode(aEvent.mCharCode),
+ mHandledByAPZ(false) {
+ switch (aEvent.mMessage) {
+ case eKeyPress: {
+ mType = KeyboardInput::KEY_PRESS;
+ break;
+ }
+ case eKeyUp: {
+ mType = KeyboardInput::KEY_UP;
+ break;
+ }
+ case eKeyDown: {
+ mType = KeyboardInput::KEY_DOWN;
+ break;
+ }
+ default:
+ mType = KeyboardInput::KEY_OTHER;
+ break;
+ }
+
+ aEvent.GetShortcutKeyCandidates(mShortcutCandidates);
+}
+
+KeyboardInput::KeyboardInput()
+ : InputData(KEYBOARD_INPUT),
+ mType(KEY_DOWN),
+ mKeyCode(0),
+ mCharCode(0),
+ mHandledByAPZ(false) {}
+
+} // namespace mozilla