bool
TouchBlockState::UpdateSlopState(const MultiTouchInput& aInput,
bool aApzcCanConsumeEvents)
{
if (aInput.mType == MultiTouchInput::MULTITOUCH_START) {
// this is by definition the first event in this block. If it's the first
// touch, then we enter a slop state.
mInSlop = (aInput.mTouches.Length() == 1);
if (mInSlop) {
mSlopOrigin = aInput.mTouches[0].mScreenPoint;
TBS_LOG("%p entering slop with origin %s\n", this, Stringify(mSlopOrigin).c_str());
}
return false;
}
if (mInSlop) {
ScreenCoord threshold = aApzcCanConsumeEvents
? AsyncPanZoomController::GetTouchStartTolerance()
: ScreenCoord(gfxPrefs::APZTouchMoveTolerance() * APZCTreeManager::GetDPI());
bool stayInSlop = (aInput.mType == MultiTouchInput::MULTITOUCH_MOVE) &&
(aInput.mTouches.Length() == 1) &&
((aInput.mTouches[0].mScreenPoint - mSlopOrigin).Length() < threshold);
if (!stayInSlop) {
// we're out of the slop zone, and will stay out for the remainder of
// this block
TBS_LOG("%p exiting slop\n", this);
mInSlop = false;
}
}
return mInSlop;
}
bool
TouchBlockState::CopyAllowedTouchBehaviorsFrom(const TouchBlockState& aOther)
{
TBS_LOG("%p copying allowed touch behaviours from %p\n", this, &aOther);
MOZ_ASSERT(aOther.mAllowedTouchBehaviorSet);
return SetAllowedTouchBehaviors(aOther.mAllowedTouchBehaviors);
}
TouchBlockState::TouchBlockState(const nsRefPtr<AsyncPanZoomController>& aTargetApzc,
bool aTargetConfirmed)
: CancelableBlockState(aTargetApzc, aTargetConfirmed)
, mAllowedTouchBehaviorSet(false)
, mDuringFastMotion(false)
, mSingleTapOccurred(false)
{
TBS_LOG("Creating %p\n", this);
}
MultiTouchInput
TouchBlockState::RemoveFirstEvent()
{
MOZ_ASSERT(!mEvents.IsEmpty());
TBS_LOG("%p returning first of %d events\n", this, mEvents.Length());
MultiTouchInput event = mEvents[0];
mEvents.RemoveElementAt(0);
return event;
}
bool
TouchBlockState::SetSingleTapOccurred()
{
TBS_LOG("%p attempting to set single-tap occurred; disallowed=%d\n", this, mSingleTapDisallowed);
if (!mSingleTapDisallowed) {
mSingleTapOccurred = true;
return true;
}
return false;
}
void
TouchBlockState::HandleEvents()
{
while (HasEvents()) {
TBS_LOG("%p returning first of %" PRIuSIZE " events\n", this, mEvents.Length());
MultiTouchInput event = mEvents[0];
mEvents.RemoveElementAt(0);
GetTargetApzc()->HandleInputEvent(event, mTransformToApzc);
}
}
void
TouchBlockState::CopyPropertiesFrom(const TouchBlockState& aOther)
{
TBS_LOG("%p copying properties from %p\n", this, &aOther);
if (gfxPrefs::TouchActionEnabled()) {
MOZ_ASSERT(aOther.mAllowedTouchBehaviorSet || aOther.IsContentResponseTimerExpired());
SetAllowedTouchBehaviors(aOther.mAllowedTouchBehaviors);
}
mTransformToApzc = aOther.mTransformToApzc;
}
void
WheelBlockState::HandleEvents()
{
while (HasEvents()) {
TBS_LOG("%p returning first of %lu events\n", this, mEvents.Length());
ScrollWheelInput event = mEvents[0];
mEvents.RemoveElementAt(0);
GetTargetApzc()->HandleInputEvent(event, mTransformToApzc);
}
}
void
TouchBlockState::HandleEvents()
{
while (HasEvents()) {
TBS_LOG("%p returning first of %" PRIuSIZE " events\n", this, mEvents.Length());
MultiTouchInput event = mEvents[0];
mEvents.RemoveElementAt(0);
DispatchEvent(event);
}
}
TouchBlockState::TouchBlockState()
: mAllowedTouchBehaviorSet(false)
, mPreventDefault(false)
, mContentResponded(false)
, mContentResponseTimerExpired(false)
, mSingleTapDisallowed(false)
, mSingleTapOccurred(false)
{
TBS_LOG("Creating %p\n", this);
}
TouchBlockState::TouchBlockState(const RefPtr<AsyncPanZoomController>& aTargetApzc,
bool aTargetConfirmed, TouchCounter& aCounter)
: CancelableBlockState(aTargetApzc, aTargetConfirmed)
, mAllowedTouchBehaviorSet(false)
, mDuringFastFling(false)
, mSingleTapOccurred(false)
, mInSlop(false)
, mTouchCounter(aCounter)
{
TBS_LOG("Creating %p\n", this);
}
bool
TouchBlockState::SetAllowedTouchBehaviors(const nsTArray<TouchBehaviorFlags>& aBehaviors)
{
if (mAllowedTouchBehaviorSet) {
return false;
}
TBS_LOG("%p got allowed touch behaviours for %" PRIuSIZE " points\n", this, aBehaviors.Length());
mAllowedTouchBehaviors.AppendElements(aBehaviors);
mAllowedTouchBehaviorSet = true;
return true;
}
bool
InputBlockState::SetConfirmedTargetApzc(const RefPtr<AsyncPanZoomController>& aTargetApzc)
{
if (mTargetConfirmed) {
return false;
}
mTargetConfirmed = true;
TBS_LOG("%p got confirmed target APZC %p\n", this, mTargetApzc.get());
if (mTargetApzc == aTargetApzc) {
// The confirmed target is the same as the tentative one, so we're done.
return true;
}
TBS_LOG("%p replacing unconfirmed target %p with real target %p\n",
this, mTargetApzc.get(), aTargetApzc.get());
UpdateTargetApzc(aTargetApzc);
return true;
}
bool
CancelableBlockState::SetContentResponse(bool aPreventDefault)
{
if (mContentResponded) {
return false;
}
TBS_LOG("%p got content response %d with timer expired %d\n",
this, aPreventDefault, mContentResponseTimerExpired);
mPreventDefault = aPreventDefault;
mContentResponded = true;
return true;
}
bool
CancelableBlockState::TimeoutContentResponse()
{
if (mContentResponseTimerExpired) {
return false;
}
TBS_LOG("%p got content timer expired with response received %d\n",
this, mContentResponded);
if (!mContentResponded) {
mPreventDefault = false;
}
mContentResponseTimerExpired = true;
return true;
}
bool
PanGestureBlockState::SetContentResponse(bool aPreventDefault)
{
if (aPreventDefault) {
TBS_LOG("%p setting interrupted flag\n", this);
mInterrupted = true;
}
bool stateChanged = CancelableBlockState::SetContentResponse(aPreventDefault);
if (mWaitingForContentResponse) {
mWaitingForContentResponse = false;
stateChanged = true;
}
return stateChanged;
}
bool
WheelBlockState::MaybeTimeout(const ScrollWheelInput& aEvent)
{
MOZ_ASSERT(InTransaction());
if (MaybeTimeout(aEvent.mTimeStamp)) {
return true;
}
if (!mLastMouseMove.IsNull()) {
// If there's a recent mouse movement, we can time out the transaction early.
TimeDuration duration = TimeStamp::Now() - mLastMouseMove;
if (duration.ToMilliseconds() >= gfxPrefs::MouseWheelIgnoreMoveDelayMs()) {
TBS_LOG("%p wheel transaction timed out after mouse move\n", this);
EndTransaction();
return true;
}
}
return false;
}
bool
InputBlockState::SetConfirmedTargetApzc(const nsRefPtr<AsyncPanZoomController>& aTargetApzc)
{
if (mTargetConfirmed) {
return false;
}
mTargetConfirmed = true;
TBS_LOG("%p got confirmed target APZC %p\n", this, mTargetApzc.get());
if (mTargetApzc == aTargetApzc) {
// The confirmed target is the same as the tentative one, so we're done.
return true;
}
// Log enabled by default for now, we will put it in a TBS_LOG eventually
// once this code is more baked
printf_stderr("%p replacing unconfirmed target %p with real target %p\n",
this, mTargetApzc.get(), aTargetApzc.get());
UpdateTargetApzc(aTargetApzc);
return true;
}
bool
WheelBlockState::MaybeTimeout(const TimeStamp& aTimeStamp)
{
MOZ_ASSERT(InTransaction());
// End the transaction if the event occurred > 1.5s after the most recently
// seen wheel event.
TimeDuration duration = aTimeStamp - mLastEventTime;
if (duration.ToMilliseconds() < gfxPrefs::MouseWheelTransactionTimeoutMs()) {
return false;
}
TBS_LOG("%p wheel transaction timed out\n", this);
if (gfxPrefs::MouseScrollTestingEnabled()) {
RefPtr<AsyncPanZoomController> apzc = GetTargetApzc();
apzc->NotifyMozMouseScrollEvent(NS_LITERAL_STRING("MozMouseScrollTransactionTimeout"));
}
EndTransaction();
return true;
}
void
TouchBlockState::DisallowSingleTap()
{
TBS_LOG("%p disallowing single-tap\n", this);
mSingleTapDisallowed = true;
}
void
WheelBlockState::DropEvents()
{
TBS_LOG("%p dropping %lu events\n", this, mEvents.Length());
mEvents.Clear();
}
void
TouchBlockState::DropEvents()
{
TBS_LOG("%p dropping %" PRIuSIZE " events\n", this, mEvents.Length());
mEvents.Clear();
}
void
TouchBlockState::AddEvent(const MultiTouchInput& aEvent)
{
TBS_LOG("%p adding event of type %d\n", this, aEvent.mType);
mEvents.AppendElement(aEvent);
}
void
TouchBlockState::SetSingleTapOccurred()
{
TBS_LOG("%p setting single-tap-occurred flag\n", this);
mSingleTapOccurred = true;
}
void
TouchBlockState::SetDuringFastFling()
{
TBS_LOG("%p setting fast-motion flag\n", this);
mDuringFastFling = true;
}
void
WheelBlockState::EndTransaction()
{
TBS_LOG("%p ending wheel transaction\n", this);
mTransactionEnded = true;
}
