зеркало из https://github.com/mozilla/gecko-dev.git
111 строки
3.7 KiB
C++
111 строки
3.7 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* 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 "ScrollAnimationMSDPhysics.h"
|
|
#include "gfxPrefs.h"
|
|
|
|
using namespace mozilla;
|
|
|
|
ScrollAnimationMSDPhysics::ScrollAnimationMSDPhysics(const nsPoint& aStartPos)
|
|
: mStartPos(aStartPos)
|
|
, mModelX(0, 0, 0, gfxPrefs::SmoothScrollMSDPhysicsRegularSpringConstant(), 1)
|
|
, mModelY(0, 0, 0, gfxPrefs::SmoothScrollMSDPhysicsRegularSpringConstant(), 1)
|
|
, mIsFirstIteration(true)
|
|
{
|
|
}
|
|
|
|
void
|
|
ScrollAnimationMSDPhysics::Update(const TimeStamp& aTime,
|
|
const nsPoint& aDestination,
|
|
const nsSize& aCurrentVelocity)
|
|
{
|
|
double springConstant = ComputeSpringConstant(aTime);
|
|
|
|
// mLastSimulatedTime is the most recent time that this animation has been
|
|
// "observed" at. We don't want to update back to a state in the past, so we
|
|
// set mStartTime to the more recent of mLastSimulatedTime and aTime.
|
|
// aTime can be in the past if we're processing an input event whose internal
|
|
// timestamp is in the past.
|
|
if (mLastSimulatedTime && aTime < mLastSimulatedTime) {
|
|
mStartTime = mLastSimulatedTime;
|
|
} else {
|
|
mStartTime = aTime;
|
|
}
|
|
|
|
if (!mIsFirstIteration) {
|
|
mStartPos = PositionAt(mStartTime);
|
|
}
|
|
|
|
mLastSimulatedTime = mStartTime;
|
|
mDestination = aDestination;
|
|
mModelX = AxisPhysicsMSDModel(mStartPos.x, aDestination.x,
|
|
aCurrentVelocity.width, springConstant, 1);
|
|
mModelY = AxisPhysicsMSDModel(mStartPos.y, aDestination.y,
|
|
aCurrentVelocity.height, springConstant, 1);
|
|
mIsFirstIteration = false;
|
|
}
|
|
|
|
double
|
|
ScrollAnimationMSDPhysics::ComputeSpringConstant(const TimeStamp& aTime)
|
|
{
|
|
if (!mPreviousEventTime) {
|
|
mPreviousEventTime = aTime;
|
|
mPreviousDelta = TimeDuration();
|
|
return gfxPrefs::SmoothScrollMSDPhysicsMotionBeginSpringConstant();
|
|
}
|
|
|
|
TimeDuration delta = aTime - mPreviousEventTime;
|
|
TimeDuration previousDelta = mPreviousDelta;
|
|
|
|
mPreviousEventTime = aTime;
|
|
mPreviousDelta = delta;
|
|
|
|
double deltaMS = delta.ToMilliseconds();
|
|
if (deltaMS >= gfxPrefs::SmoothScrollMSDPhysicsContinuousMotionMaxDeltaMS()) {
|
|
return gfxPrefs::SmoothScrollMSDPhysicsMotionBeginSpringConstant();
|
|
}
|
|
|
|
if (previousDelta &&
|
|
deltaMS >= gfxPrefs::SmoothScrollMSDPhysicsSlowdownMinDeltaMS() &&
|
|
deltaMS >= previousDelta.ToMilliseconds() * gfxPrefs::SmoothScrollMSDPhysicsSlowdownMinDeltaRatio()) {
|
|
// The rate of events has slowed (the time delta between events has
|
|
// increased) enough that we think that the current scroll motion is coming
|
|
// to a stop. Use a stiffer spring in order to reach the destination more
|
|
// quickly.
|
|
return gfxPrefs::SmoothScrollMSDPhysicsSlowdownSpringConstant();
|
|
}
|
|
|
|
return gfxPrefs::SmoothScrollMSDPhysicsRegularSpringConstant();
|
|
}
|
|
|
|
void
|
|
ScrollAnimationMSDPhysics::SimulateUntil(const TimeStamp& aTime)
|
|
{
|
|
if (!mLastSimulatedTime || aTime < mLastSimulatedTime) {
|
|
return;
|
|
}
|
|
TimeDuration delta = aTime - mLastSimulatedTime;
|
|
mModelX.Simulate(delta);
|
|
mModelY.Simulate(delta);
|
|
mLastSimulatedTime = aTime;
|
|
}
|
|
|
|
nsPoint
|
|
ScrollAnimationMSDPhysics::PositionAt(const TimeStamp& aTime)
|
|
{
|
|
SimulateUntil(aTime);
|
|
return nsPoint(NSToCoordRound(mModelX.GetPosition()),
|
|
NSToCoordRound(mModelY.GetPosition()));
|
|
}
|
|
|
|
nsSize
|
|
ScrollAnimationMSDPhysics::VelocityAt(const TimeStamp& aTime)
|
|
{
|
|
SimulateUntil(aTime);
|
|
return nsSize(NSToCoordRound(mModelX.GetVelocity()),
|
|
NSToCoordRound(mModelY.GetVelocity()));
|
|
}
|