gecko-dev/layout/generic/ScrollAnimationMSDPhysics.cpp

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()));
}