mirror of https://github.com/roytam1/UXP
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
777 lines
22 KiB
777 lines
22 KiB
/* -*- 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/Touch.h" |
|
#include "nsDebug.h" |
|
#include "nsThreadUtils.h" |
|
#include "mozilla/MouseEvents.h" |
|
#include "mozilla/TouchEvents.h" |
|
#include "UnitTransforms.h" |
|
|
|
namespace mozilla { |
|
|
|
using namespace dom; |
|
|
|
InputData::~InputData() |
|
{ |
|
} |
|
|
|
InputData::InputData(InputType aInputType) |
|
: mInputType(aInputType) |
|
, mTime(0) |
|
, modifiers(0) |
|
{ |
|
} |
|
|
|
InputData::InputData(InputType aInputType, uint32_t aTime, TimeStamp aTimeStamp, |
|
Modifiers aModifiers) |
|
: mInputType(aInputType) |
|
, mTime(aTime) |
|
, mTimeStamp(aTimeStamp) |
|
, 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() |
|
{ |
|
} |
|
|
|
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); |
|
return touch.forget(); |
|
} |
|
|
|
MultiTouchInput::MultiTouchInput(MultiTouchType aType, uint32_t aTime, |
|
TimeStamp aTimeStamp, Modifiers aModifiers) |
|
: InputData(MULTITOUCH_INPUT, aTime, aTimeStamp, aModifiers) |
|
, mType(aType) |
|
, mHandledByAPZ(false) |
|
{ |
|
} |
|
|
|
MultiTouchInput::MultiTouchInput() |
|
: InputData(MULTITOUCH_INPUT) |
|
, mHandledByAPZ(false) |
|
{ |
|
} |
|
|
|
MultiTouchInput::MultiTouchInput(const MultiTouchInput& aOther) |
|
: InputData(MULTITOUCH_INPUT, aOther.mTime, aOther.mTimeStamp, aOther.modifiers) |
|
, mType(aOther.mType) |
|
, mHandledByAPZ(aOther.mHandledByAPZ) |
|
{ |
|
mTouches.AppendElements(aOther.mTouches); |
|
} |
|
|
|
MultiTouchInput::MultiTouchInput(const WidgetTouchEvent& aTouchEvent) |
|
: InputData(MULTITOUCH_INPUT, aTouchEvent.mTime, aTouchEvent.mTimeStamp, |
|
aTouchEvent.mModifiers) |
|
, mHandledByAPZ(aTouchEvent.mFlags.mHandledByAPZ) |
|
{ |
|
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; |
|
} |
|
|
|
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(); |
|
int32_t radiusY = domTouch->RadiusY(); |
|
float rotationAngle = domTouch->RotationAngle(); |
|
float force = domTouch->Force(); |
|
|
|
SingleTouchData data(identifier, |
|
ViewAs<ScreenPixel>(domTouch->mRefPoint, |
|
PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent), |
|
ScreenSize(radiusX, radiusY), |
|
rotationAngle, |
|
force); |
|
|
|
mTouches.AppendElement(data); |
|
} |
|
} |
|
|
|
MultiTouchInput::MultiTouchInput(const WidgetMouseEvent& aMouseEvent) |
|
: InputData(MULTITOUCH_INPUT, aMouseEvent.mTime, aMouseEvent.mTimeStamp, |
|
aMouseEvent.mModifiers) |
|
, mHandledByAPZ(aMouseEvent.mFlags.mHandledByAPZ) |
|
{ |
|
MOZ_ASSERT(NS_IsMainThread(), |
|
"Can only copy from WidgetMouseEvent on main thread"); |
|
switch (aMouseEvent.mMessage) { |
|
case eMouseDown: |
|
mType = MULTITOUCH_START; |
|
break; |
|
case eMouseMove: |
|
mType = MULTITOUCH_MOVE; |
|
break; |
|
case eMouseUp: |
|
mType = MULTITOUCH_END; |
|
break; |
|
// The mouse pointer has been interrupted in an implementation-specific |
|
// manner, such as a synchronous event or action cancelling the touch, or a |
|
// touch point leaving the document window and going into a non-document |
|
// area capable of handling user interactions. |
|
case eMouseExitFromWidget: |
|
mType = MULTITOUCH_CANCEL; |
|
break; |
|
default: |
|
NS_WARNING("Did not assign a type to a MultiTouchInput"); |
|
break; |
|
} |
|
|
|
mTouches.AppendElement(SingleTouchData(0, |
|
ViewAs<ScreenPixel>(aMouseEvent.mRefPoint, |
|
PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent), |
|
ScreenSize(1, 1), |
|
180.0f, |
|
1.0f)); |
|
} |
|
|
|
WidgetTouchEvent |
|
MultiTouchInput::ToWidgetTouchEvent(nsIWidget* aWidget) const |
|
{ |
|
MOZ_ASSERT(NS_IsMainThread(), |
|
"Can only convert To WidgetTouchEvent on main thread"); |
|
|
|
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.mTime = this->mTime; |
|
event.mTimeStamp = this->mTimeStamp; |
|
event.mFlags.mHandledByAPZ = mHandledByAPZ; |
|
|
|
for (size_t i = 0; i < mTouches.Length(); i++) { |
|
*event.mTouches.AppendElement() = mTouches[i].ToNewDOMTouch(); |
|
} |
|
|
|
return event; |
|
} |
|
|
|
WidgetMouseEvent |
|
MultiTouchInput::ToWidgetMouseEvent(nsIWidget* aWidget) const |
|
{ |
|
MOZ_ASSERT(NS_IsMainThread(), |
|
"Can only convert To WidgetMouseEvent on main thread"); |
|
|
|
EventMessage mouseEventMessage = eVoidEvent; |
|
switch (mType) { |
|
case MultiTouchInput::MULTITOUCH_START: |
|
mouseEventMessage = eMouseDown; |
|
break; |
|
case MultiTouchInput::MULTITOUCH_MOVE: |
|
mouseEventMessage = eMouseMove; |
|
break; |
|
case MultiTouchInput::MULTITOUCH_CANCEL: |
|
case MultiTouchInput::MULTITOUCH_END: |
|
mouseEventMessage = eMouseUp; |
|
break; |
|
default: |
|
MOZ_ASSERT_UNREACHABLE("Did not assign a type to WidgetMouseEvent"); |
|
break; |
|
} |
|
|
|
WidgetMouseEvent event(true, mouseEventMessage, aWidget, |
|
WidgetMouseEvent::eReal, WidgetMouseEvent::eNormal); |
|
|
|
const SingleTouchData& firstTouch = mTouches[0]; |
|
event.mRefPoint.x = firstTouch.mScreenPoint.x; |
|
event.mRefPoint.y = firstTouch.mScreenPoint.y; |
|
|
|
event.mTime = mTime; |
|
event.button = WidgetMouseEvent::eLeftButton; |
|
event.inputSource = nsIDOMMouseEvent::MOZ_SOURCE_TOUCH; |
|
event.mModifiers = modifiers; |
|
event.mFlags.mHandledByAPZ = mHandledByAPZ; |
|
|
|
if (mouseEventMessage != eMouseMove) { |
|
event.mClickCount = 1; |
|
} |
|
|
|
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 (size_t i = 0; i < mTouches.Length(); i++) { |
|
Maybe<ParentLayerIntPoint> point = UntransformBy(aTransform, mTouches[i].mScreenPoint); |
|
if (!point) { |
|
return false; |
|
} |
|
mTouches[i].mLocalScreenPoint = *point; |
|
} |
|
return true; |
|
} |
|
|
|
MouseInput::MouseInput() |
|
: InputData(MOUSE_INPUT) |
|
, mType(MOUSE_NONE) |
|
, mButtonType(NONE) |
|
, mInputSource(0) |
|
, mButtons(0) |
|
, mHandledByAPZ(false) |
|
{ |
|
} |
|
|
|
MouseInput::MouseInput(MouseType aType, ButtonType aButtonType, |
|
uint16_t aInputSource, int16_t aButtons, |
|
const ScreenPoint& aPoint, uint32_t aTime, |
|
TimeStamp aTimeStamp, Modifiers aModifiers) |
|
: InputData(MOUSE_INPUT, aTime, aTimeStamp, aModifiers) |
|
, mType(aType) |
|
, mButtonType(aButtonType) |
|
, mInputSource(aInputSource) |
|
, mButtons(aButtons) |
|
, mOrigin(aPoint) |
|
, mHandledByAPZ(false) |
|
{ |
|
} |
|
|
|
MouseInput::MouseInput(const WidgetMouseEventBase& aMouseEvent) |
|
: InputData(MOUSE_INPUT, aMouseEvent.mTime, aMouseEvent.mTimeStamp, |
|
aMouseEvent.mModifiers) |
|
, mType(MOUSE_NONE) |
|
, mButtonType(NONE) |
|
, mInputSource(aMouseEvent.inputSource) |
|
, mButtons(aMouseEvent.buttons) |
|
, mHandledByAPZ(aMouseEvent.mFlags.mHandledByAPZ) |
|
{ |
|
MOZ_ASSERT(NS_IsMainThread(), |
|
"Can only copy from WidgetTouchEvent on main thread"); |
|
|
|
mButtonType = NONE; |
|
|
|
switch (aMouseEvent.button) { |
|
case WidgetMouseEventBase::eLeftButton: |
|
mButtonType = MouseInput::LEFT_BUTTON; |
|
break; |
|
case WidgetMouseEventBase::eMiddleButton: |
|
mButtonType = MouseInput::MIDDLE_BUTTON; |
|
break; |
|
case WidgetMouseEventBase::eRightButton: |
|
mButtonType = MouseInput::RIGHT_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; |
|
default: |
|
MOZ_ASSERT_UNREACHABLE("Mouse event type not supported"); |
|
break; |
|
} |
|
|
|
mOrigin = |
|
ScreenPoint(ViewAs<ScreenPixel>(aMouseEvent.mRefPoint, |
|
PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent)); |
|
} |
|
|
|
bool |
|
MouseInput::IsLeftButton() const |
|
{ |
|
return mButtonType == LEFT_BUTTON; |
|
} |
|
|
|
bool |
|
MouseInput::TransformToLocal(const ScreenToParentLayerMatrix4x4& aTransform) |
|
{ |
|
Maybe<ParentLayerPoint> point = UntransformBy(aTransform, mOrigin); |
|
if (!point) { |
|
return false; |
|
} |
|
mLocalOrigin = *point; |
|
|
|
return true; |
|
} |
|
|
|
WidgetMouseEvent |
|
MouseInput::ToWidgetMouseEvent(nsIWidget* aWidget) const |
|
{ |
|
MOZ_ASSERT(NS_IsMainThread(), |
|
"Can only convert To WidgetTouchEvent on main thread"); |
|
|
|
EventMessage msg = eVoidEvent; |
|
uint32_t clickCount = 0; |
|
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; |
|
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::LEFT_BUTTON: |
|
event.button = WidgetMouseEventBase::eLeftButton; |
|
break; |
|
case MouseInput::MIDDLE_BUTTON: |
|
event.button = WidgetMouseEventBase::eMiddleButton; |
|
break; |
|
case MouseInput::RIGHT_BUTTON: |
|
event.button = WidgetMouseEventBase::eRightButton; |
|
break; |
|
case MouseInput::NONE: |
|
default: |
|
break; |
|
} |
|
|
|
event.buttons = mButtons; |
|
event.mModifiers = modifiers; |
|
event.mTime = mTime; |
|
event.mTimeStamp = mTimeStamp; |
|
event.mFlags.mHandledByAPZ = mHandledByAPZ; |
|
event.mRefPoint = |
|
RoundedToInt(ViewAs<LayoutDevicePixel>(mOrigin, |
|
PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent)); |
|
event.mClickCount = clickCount; |
|
event.inputSource = mInputSource; |
|
event.mIgnoreRootScrollFrame = true; |
|
|
|
return event; |
|
} |
|
|
|
PanGestureInput::PanGestureInput() |
|
: InputData(PANGESTURE_INPUT) |
|
, mLineOrPageDeltaX(0) |
|
, mLineOrPageDeltaY(0) |
|
, mUserDeltaMultiplierX(1.0) |
|
, mUserDeltaMultiplierY(1.0) |
|
, mHandledByAPZ(false) |
|
, mFollowedByMomentum(false) |
|
, mRequiresContentResponseIfCannotScrollHorizontallyInStartDirection(false) |
|
{ |
|
} |
|
|
|
PanGestureInput::PanGestureInput(PanGestureType aType, uint32_t aTime, |
|
TimeStamp aTimeStamp, |
|
const ScreenPoint& aPanStartPoint, |
|
const ScreenPoint& aPanDisplacement, |
|
Modifiers aModifiers) |
|
: InputData(PANGESTURE_INPUT, aTime, aTimeStamp, aModifiers) |
|
, mType(aType) |
|
, mPanStartPoint(aPanStartPoint) |
|
, mPanDisplacement(aPanDisplacement) |
|
, mLineOrPageDeltaX(0) |
|
, mLineOrPageDeltaY(0) |
|
, mUserDeltaMultiplierX(1.0) |
|
, mUserDeltaMultiplierY(1.0) |
|
, mHandledByAPZ(false) |
|
, mFollowedByMomentum(false) |
|
, mRequiresContentResponseIfCannotScrollHorizontallyInStartDirection(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::ToWidgetWheelEvent(nsIWidget* aWidget) const |
|
{ |
|
WidgetWheelEvent wheelEvent(true, eWheel, aWidget); |
|
wheelEvent.mModifiers = this->modifiers; |
|
wheelEvent.mTime = mTime; |
|
wheelEvent.mTimeStamp = mTimeStamp; |
|
wheelEvent.mRefPoint = |
|
RoundedToInt(ViewAs<LayoutDevicePixel>(mPanStartPoint, |
|
PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent)); |
|
wheelEvent.buttons = 0; |
|
wheelEvent.mDeltaMode = nsIDOMWheelEvent::DOM_DELTA_PIXEL; |
|
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; |
|
return wheelEvent; |
|
} |
|
|
|
bool |
|
PanGestureInput::TransformToLocal(const ScreenToParentLayerMatrix4x4& aTransform) |
|
{ |
|
Maybe<ParentLayerPoint> panStartPoint = UntransformBy(aTransform, mPanStartPoint); |
|
if (!panStartPoint) { |
|
return false; |
|
} |
|
mLocalPanStartPoint = *panStartPoint; |
|
|
|
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); |
|
} |
|
|
|
PinchGestureInput::PinchGestureInput() |
|
: InputData(PINCHGESTURE_INPUT) |
|
{ |
|
} |
|
|
|
PinchGestureInput::PinchGestureInput(PinchGestureType aType, uint32_t aTime, |
|
TimeStamp aTimeStamp, |
|
const ParentLayerPoint& aLocalFocusPoint, |
|
ParentLayerCoord aCurrentSpan, |
|
ParentLayerCoord aPreviousSpan, |
|
Modifiers aModifiers) |
|
: InputData(PINCHGESTURE_INPUT, aTime, aTimeStamp, aModifiers) |
|
, mType(aType) |
|
, mLocalFocusPoint(aLocalFocusPoint) |
|
, mCurrentSpan(aCurrentSpan) |
|
, mPreviousSpan(aPreviousSpan) |
|
{ |
|
} |
|
|
|
bool |
|
PinchGestureInput::TransformToLocal(const ScreenToParentLayerMatrix4x4& aTransform) |
|
{ |
|
Maybe<ParentLayerPoint> point = UntransformBy(aTransform, mFocusPoint); |
|
if (!point) { |
|
return false; |
|
} |
|
mLocalFocusPoint = *point; |
|
return true; |
|
} |
|
|
|
TapGestureInput::TapGestureInput() |
|
: InputData(TAPGESTURE_INPUT) |
|
{ |
|
} |
|
|
|
TapGestureInput::TapGestureInput(TapGestureType aType, uint32_t aTime, |
|
TimeStamp aTimeStamp, |
|
const ScreenIntPoint& aPoint, |
|
Modifiers aModifiers) |
|
: InputData(TAPGESTURE_INPUT, aTime, aTimeStamp, aModifiers) |
|
, mType(aType) |
|
, mPoint(aPoint) |
|
{ |
|
} |
|
|
|
TapGestureInput::TapGestureInput(TapGestureType aType, uint32_t aTime, |
|
TimeStamp aTimeStamp, |
|
const ParentLayerPoint& aLocalPoint, |
|
Modifiers aModifiers) |
|
: InputData(TAPGESTURE_INPUT, aTime, 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; |
|
} |
|
|
|
ScrollWheelInput::ScrollWheelInput() |
|
: InputData(SCROLLWHEEL_INPUT) |
|
, mHandledByAPZ(false) |
|
, mLineOrPageDeltaX(0) |
|
, mLineOrPageDeltaY(0) |
|
, mScrollSeriesNumber(0) |
|
, mUserDeltaMultiplierX(1.0) |
|
, mUserDeltaMultiplierY(1.0) |
|
, mMayHaveMomentum(false) |
|
, mIsMomentum(false) |
|
{ |
|
} |
|
|
|
ScrollWheelInput::ScrollWheelInput(uint32_t aTime, TimeStamp aTimeStamp, |
|
Modifiers aModifiers, ScrollMode aScrollMode, |
|
ScrollDeltaType aDeltaType, |
|
const ScreenPoint& aOrigin, double aDeltaX, |
|
double aDeltaY, |
|
bool aAllowToOverrideSystemScrollSpeed) |
|
: InputData(SCROLLWHEEL_INPUT, aTime, 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) |
|
{ |
|
} |
|
|
|
ScrollWheelInput::ScrollWheelInput(const WidgetWheelEvent& aWheelEvent) |
|
: InputData(SCROLLWHEEL_INPUT, aWheelEvent.mTime, aWheelEvent.mTimeStamp, |
|
aWheelEvent.mModifiers) |
|
, mDeltaType(DeltaTypeForDeltaMode(aWheelEvent.mDeltaMode)) |
|
, mScrollMode(SCROLLMODE_INSTANT) |
|
, mHandledByAPZ(aWheelEvent.mFlags.mHandledByAPZ) |
|
, mDeltaX(aWheelEvent.mDeltaX) |
|
, mDeltaY(aWheelEvent.mDeltaY) |
|
, mLineOrPageDeltaX(aWheelEvent.mLineOrPageDeltaX) |
|
, mLineOrPageDeltaY(aWheelEvent.mLineOrPageDeltaY) |
|
, mScrollSeriesNumber(0) |
|
, mUserDeltaMultiplierX(1.0) |
|
, mUserDeltaMultiplierY(1.0) |
|
, mMayHaveMomentum(aWheelEvent.mMayHaveMomentum) |
|
, mIsMomentum(aWheelEvent.mIsMomentum) |
|
, mAllowToOverrideSystemScrollSpeed( |
|
aWheelEvent.mAllowToOverrideSystemScrollSpeed) |
|
{ |
|
mOrigin = |
|
ScreenPoint(ViewAs<ScreenPixel>(aWheelEvent.mRefPoint, |
|
PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent)); |
|
} |
|
|
|
ScrollWheelInput::ScrollDeltaType |
|
ScrollWheelInput::DeltaTypeForDeltaMode(uint32_t aDeltaMode) |
|
{ |
|
switch (aDeltaMode) { |
|
case nsIDOMWheelEvent::DOM_DELTA_LINE: |
|
return SCROLLDELTA_LINE; |
|
case nsIDOMWheelEvent::DOM_DELTA_PAGE: |
|
return SCROLLDELTA_PAGE; |
|
case nsIDOMWheelEvent::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 nsIDOMWheelEvent::DOM_DELTA_LINE; |
|
case ScrollWheelInput::SCROLLDELTA_PAGE: |
|
return nsIDOMWheelEvent::DOM_DELTA_PAGE; |
|
case ScrollWheelInput::SCROLLDELTA_PIXEL: |
|
default: |
|
return nsIDOMWheelEvent::DOM_DELTA_PIXEL; |
|
} |
|
} |
|
|
|
nsIScrollableFrame::ScrollUnit |
|
ScrollWheelInput::ScrollUnitForDeltaType(ScrollDeltaType aDeltaType) |
|
{ |
|
switch (aDeltaType) { |
|
case SCROLLDELTA_LINE: |
|
return nsIScrollableFrame::LINES; |
|
case SCROLLDELTA_PAGE: |
|
return nsIScrollableFrame::PAGES; |
|
case SCROLLDELTA_PIXEL: |
|
return nsIScrollableFrame::DEVICE_PIXELS; |
|
default: |
|
MOZ_CRASH(); |
|
} |
|
return nsIScrollableFrame::LINES; |
|
} |
|
|
|
WidgetWheelEvent |
|
ScrollWheelInput::ToWidgetWheelEvent(nsIWidget* aWidget) const |
|
{ |
|
WidgetWheelEvent wheelEvent(true, eWheel, aWidget); |
|
wheelEvent.mModifiers = this->modifiers; |
|
wheelEvent.mTime = mTime; |
|
wheelEvent.mTimeStamp = mTimeStamp; |
|
wheelEvent.mRefPoint = |
|
RoundedToInt(ViewAs<LayoutDevicePixel>(mOrigin, |
|
PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent)); |
|
wheelEvent.buttons = 0; |
|
wheelEvent.mDeltaMode = DeltaModeForDeltaType(mDeltaType); |
|
wheelEvent.mMayHaveMomentum = mMayHaveMomentum; |
|
wheelEvent.mIsMomentum = mIsMomentum; |
|
wheelEvent.mDeltaX = mDeltaX; |
|
wheelEvent.mDeltaY = mDeltaY; |
|
wheelEvent.mLineOrPageDeltaX = mLineOrPageDeltaX; |
|
wheelEvent.mLineOrPageDeltaY = mLineOrPageDeltaY; |
|
wheelEvent.mAllowToOverrideSystemScrollSpeed = |
|
mAllowToOverrideSystemScrollSpeed; |
|
wheelEvent.mFlags.mHandledByAPZ = mHandledByAPZ; |
|
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; |
|
} |
|
|
|
} // namespace mozilla
|
|
|