mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-11 02:56:06 +00:00
1067 lines
33 KiB
C++
1067 lines
33 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 "nsSMILAnimationFunction.h"
|
|
|
|
#include "mozilla/dom/SVGAnimationElement.h"
|
|
#include "mozilla/Move.h"
|
|
#include "nsISMILAttr.h"
|
|
#include "nsSMILParserUtils.h"
|
|
#include "nsSMILNullType.h"
|
|
#include "nsSMILTimedElement.h"
|
|
#include "nsAttrValueInlines.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsCOMArray.h"
|
|
#include "nsIContent.h"
|
|
#include "nsAutoPtr.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsReadableUtils.h"
|
|
#include "nsString.h"
|
|
#include <math.h>
|
|
#include <algorithm>
|
|
|
|
using namespace mozilla::dom;
|
|
|
|
//----------------------------------------------------------------------
|
|
// Static members
|
|
|
|
nsAttrValue::EnumTable nsSMILAnimationFunction::sAccumulateTable[] = {
|
|
{"none", false},
|
|
{"sum", true},
|
|
{nullptr, 0}
|
|
};
|
|
|
|
nsAttrValue::EnumTable nsSMILAnimationFunction::sAdditiveTable[] = {
|
|
{"replace", false},
|
|
{"sum", true},
|
|
{nullptr, 0}
|
|
};
|
|
|
|
nsAttrValue::EnumTable nsSMILAnimationFunction::sCalcModeTable[] = {
|
|
{"linear", CALC_LINEAR},
|
|
{"discrete", CALC_DISCRETE},
|
|
{"paced", CALC_PACED},
|
|
{"spline", CALC_SPLINE},
|
|
{nullptr, 0}
|
|
};
|
|
|
|
// Any negative number should be fine as a sentinel here,
|
|
// because valid distances are non-negative.
|
|
#define COMPUTE_DISTANCE_ERROR (-1)
|
|
|
|
//----------------------------------------------------------------------
|
|
// Constructors etc.
|
|
|
|
nsSMILAnimationFunction::nsSMILAnimationFunction()
|
|
: mSampleTime(-1),
|
|
mRepeatIteration(0),
|
|
mBeginTime(INT64_MIN),
|
|
mAnimationElement(nullptr),
|
|
mErrorFlags(0),
|
|
mIsActive(false),
|
|
mIsFrozen(false),
|
|
mLastValue(false),
|
|
mHasChanged(true),
|
|
mValueNeedsReparsingEverySample(false),
|
|
mPrevSampleWasSingleValueAnimation(false),
|
|
mWasSkippedInPrevSample(false)
|
|
{
|
|
}
|
|
|
|
void
|
|
nsSMILAnimationFunction::SetAnimationElement(
|
|
SVGAnimationElement* aAnimationElement)
|
|
{
|
|
mAnimationElement = aAnimationElement;
|
|
}
|
|
|
|
bool
|
|
nsSMILAnimationFunction::SetAttr(nsIAtom* aAttribute, const nsAString& aValue,
|
|
nsAttrValue& aResult, nsresult* aParseResult)
|
|
{
|
|
bool foundMatch = true;
|
|
nsresult parseResult = NS_OK;
|
|
|
|
// The attributes 'by', 'from', 'to', and 'values' may be parsed differently
|
|
// depending on the element & attribute we're animating. So instead of
|
|
// parsing them now we re-parse them at every sample.
|
|
if (aAttribute == nsGkAtoms::by ||
|
|
aAttribute == nsGkAtoms::from ||
|
|
aAttribute == nsGkAtoms::to ||
|
|
aAttribute == nsGkAtoms::values) {
|
|
// We parse to, from, by, values at sample time.
|
|
// XXX Need to flag which attribute has changed and then when we parse it at
|
|
// sample time, report any errors and reset the flag
|
|
mHasChanged = true;
|
|
aResult.SetTo(aValue);
|
|
} else if (aAttribute == nsGkAtoms::accumulate) {
|
|
parseResult = SetAccumulate(aValue, aResult);
|
|
} else if (aAttribute == nsGkAtoms::additive) {
|
|
parseResult = SetAdditive(aValue, aResult);
|
|
} else if (aAttribute == nsGkAtoms::calcMode) {
|
|
parseResult = SetCalcMode(aValue, aResult);
|
|
} else if (aAttribute == nsGkAtoms::keyTimes) {
|
|
parseResult = SetKeyTimes(aValue, aResult);
|
|
} else if (aAttribute == nsGkAtoms::keySplines) {
|
|
parseResult = SetKeySplines(aValue, aResult);
|
|
} else {
|
|
foundMatch = false;
|
|
}
|
|
|
|
if (foundMatch && aParseResult) {
|
|
*aParseResult = parseResult;
|
|
}
|
|
|
|
return foundMatch;
|
|
}
|
|
|
|
bool
|
|
nsSMILAnimationFunction::UnsetAttr(nsIAtom* aAttribute)
|
|
{
|
|
bool foundMatch = true;
|
|
|
|
if (aAttribute == nsGkAtoms::by ||
|
|
aAttribute == nsGkAtoms::from ||
|
|
aAttribute == nsGkAtoms::to ||
|
|
aAttribute == nsGkAtoms::values) {
|
|
mHasChanged = true;
|
|
} else if (aAttribute == nsGkAtoms::accumulate) {
|
|
UnsetAccumulate();
|
|
} else if (aAttribute == nsGkAtoms::additive) {
|
|
UnsetAdditive();
|
|
} else if (aAttribute == nsGkAtoms::calcMode) {
|
|
UnsetCalcMode();
|
|
} else if (aAttribute == nsGkAtoms::keyTimes) {
|
|
UnsetKeyTimes();
|
|
} else if (aAttribute == nsGkAtoms::keySplines) {
|
|
UnsetKeySplines();
|
|
} else {
|
|
foundMatch = false;
|
|
}
|
|
|
|
return foundMatch;
|
|
}
|
|
|
|
void
|
|
nsSMILAnimationFunction::SampleAt(nsSMILTime aSampleTime,
|
|
const nsSMILTimeValue& aSimpleDuration,
|
|
uint32_t aRepeatIteration)
|
|
{
|
|
// * Update mHasChanged ("Might this sample be different from prev one?")
|
|
// Were we previously sampling a fill="freeze" final val? (We're not anymore.)
|
|
mHasChanged |= mLastValue;
|
|
|
|
// Are we sampling at a new point in simple duration? And does that matter?
|
|
mHasChanged |=
|
|
(mSampleTime != aSampleTime || mSimpleDuration != aSimpleDuration) &&
|
|
!IsValueFixedForSimpleDuration();
|
|
|
|
// Are we on a new repeat and accumulating across repeats?
|
|
if (!mErrorFlags) { // (can't call GetAccumulate() if we've had parse errors)
|
|
mHasChanged |= (mRepeatIteration != aRepeatIteration) && GetAccumulate();
|
|
}
|
|
|
|
mSampleTime = aSampleTime;
|
|
mSimpleDuration = aSimpleDuration;
|
|
mRepeatIteration = aRepeatIteration;
|
|
mLastValue = false;
|
|
}
|
|
|
|
void
|
|
nsSMILAnimationFunction::SampleLastValue(uint32_t aRepeatIteration)
|
|
{
|
|
if (mHasChanged || !mLastValue || mRepeatIteration != aRepeatIteration) {
|
|
mHasChanged = true;
|
|
}
|
|
|
|
mRepeatIteration = aRepeatIteration;
|
|
mLastValue = true;
|
|
}
|
|
|
|
void
|
|
nsSMILAnimationFunction::Activate(nsSMILTime aBeginTime)
|
|
{
|
|
mBeginTime = aBeginTime;
|
|
mIsActive = true;
|
|
mIsFrozen = false;
|
|
mHasChanged = true;
|
|
}
|
|
|
|
void
|
|
nsSMILAnimationFunction::Inactivate(bool aIsFrozen)
|
|
{
|
|
mIsActive = false;
|
|
mIsFrozen = aIsFrozen;
|
|
mHasChanged = true;
|
|
}
|
|
|
|
void
|
|
nsSMILAnimationFunction::ComposeResult(const nsISMILAttr& aSMILAttr,
|
|
nsSMILValue& aResult)
|
|
{
|
|
mHasChanged = false;
|
|
mPrevSampleWasSingleValueAnimation = false;
|
|
mWasSkippedInPrevSample = false;
|
|
|
|
// Skip animations that are inactive or in error
|
|
if (!IsActiveOrFrozen() || mErrorFlags != 0)
|
|
return;
|
|
|
|
// Get the animation values
|
|
nsSMILValueArray values;
|
|
nsresult rv = GetValues(aSMILAttr, values);
|
|
if (NS_FAILED(rv))
|
|
return;
|
|
|
|
// Check that we have the right number of keySplines and keyTimes
|
|
CheckValueListDependentAttrs(values.Length());
|
|
if (mErrorFlags != 0)
|
|
return;
|
|
|
|
// If this interval is active, we must have a non-negative mSampleTime
|
|
MOZ_ASSERT(mSampleTime >= 0 || !mIsActive,
|
|
"Negative sample time for active animation");
|
|
MOZ_ASSERT(mSimpleDuration.IsResolved() || mLastValue,
|
|
"Unresolved simple duration for active or frozen animation");
|
|
|
|
// If we want to add but don't have a base value then just fail outright.
|
|
// This can happen when we skipped getting the base value because there's an
|
|
// animation function in the sandwich that should replace it but that function
|
|
// failed unexpectedly.
|
|
bool isAdditive = IsAdditive();
|
|
if (isAdditive && aResult.IsNull())
|
|
return;
|
|
|
|
nsSMILValue result;
|
|
|
|
if (values.Length() == 1 && !IsToAnimation()) {
|
|
|
|
// Single-valued animation
|
|
result = values[0];
|
|
mPrevSampleWasSingleValueAnimation = true;
|
|
|
|
} else if (mLastValue) {
|
|
|
|
// Sampling last value
|
|
const nsSMILValue& last = values[values.Length() - 1];
|
|
result = last;
|
|
|
|
// See comment in AccumulateResult: to-animation does not accumulate
|
|
if (!IsToAnimation() && GetAccumulate() && mRepeatIteration) {
|
|
// If the target attribute type doesn't support addition Add will
|
|
// fail leaving result = last
|
|
result.Add(last, mRepeatIteration);
|
|
}
|
|
|
|
} else {
|
|
|
|
// Interpolation
|
|
if (NS_FAILED(InterpolateResult(values, result, aResult)))
|
|
return;
|
|
|
|
if (NS_FAILED(AccumulateResult(values, result)))
|
|
return;
|
|
}
|
|
|
|
// If additive animation isn't required or isn't supported, set the value.
|
|
if (!isAdditive || NS_FAILED(aResult.SandwichAdd(result))) {
|
|
aResult = Move(result);
|
|
}
|
|
}
|
|
|
|
int8_t
|
|
nsSMILAnimationFunction::CompareTo(const nsSMILAnimationFunction* aOther) const
|
|
{
|
|
NS_ENSURE_TRUE(aOther, 0);
|
|
|
|
NS_ASSERTION(aOther != this, "Trying to compare to self");
|
|
|
|
// Inactive animations sort first
|
|
if (!IsActiveOrFrozen() && aOther->IsActiveOrFrozen())
|
|
return -1;
|
|
|
|
if (IsActiveOrFrozen() && !aOther->IsActiveOrFrozen())
|
|
return 1;
|
|
|
|
// Sort based on begin time
|
|
if (mBeginTime != aOther->GetBeginTime())
|
|
return mBeginTime > aOther->GetBeginTime() ? 1 : -1;
|
|
|
|
// Next sort based on syncbase dependencies: the dependent element sorts after
|
|
// its syncbase
|
|
const nsSMILTimedElement& thisTimedElement =
|
|
mAnimationElement->TimedElement();
|
|
const nsSMILTimedElement& otherTimedElement =
|
|
aOther->mAnimationElement->TimedElement();
|
|
if (thisTimedElement.IsTimeDependent(otherTimedElement))
|
|
return 1;
|
|
if (otherTimedElement.IsTimeDependent(thisTimedElement))
|
|
return -1;
|
|
|
|
// Animations that appear later in the document sort after those earlier in
|
|
// the document
|
|
MOZ_ASSERT(mAnimationElement != aOther->mAnimationElement,
|
|
"Two animations cannot have the same animation content element!");
|
|
|
|
return (nsContentUtils::PositionIsBefore(mAnimationElement, aOther->mAnimationElement))
|
|
? -1 : 1;
|
|
}
|
|
|
|
bool
|
|
nsSMILAnimationFunction::WillReplace() const
|
|
{
|
|
/*
|
|
* In IsAdditive() we don't consider to-animation to be additive as it is
|
|
* a special case that is dealt with differently in the compositing method.
|
|
* Here, however, we return FALSE for to-animation (i.e. it will NOT replace
|
|
* the underlying value) as it builds on the underlying value.
|
|
*/
|
|
return !mErrorFlags && !(IsAdditive() || IsToAnimation());
|
|
}
|
|
|
|
bool
|
|
nsSMILAnimationFunction::HasChanged() const
|
|
{
|
|
return mHasChanged || mValueNeedsReparsingEverySample;
|
|
}
|
|
|
|
bool
|
|
nsSMILAnimationFunction::UpdateCachedTarget(
|
|
const nsSMILTargetIdentifier& aNewTarget)
|
|
{
|
|
if (!mLastTarget.Equals(aNewTarget)) {
|
|
mLastTarget = aNewTarget;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Implementation helpers
|
|
|
|
nsresult
|
|
nsSMILAnimationFunction::InterpolateResult(const nsSMILValueArray& aValues,
|
|
nsSMILValue& aResult,
|
|
nsSMILValue& aBaseValue)
|
|
{
|
|
// Sanity check animation values
|
|
if ((!IsToAnimation() && aValues.Length() < 2) ||
|
|
(IsToAnimation() && aValues.Length() != 1)) {
|
|
NS_ERROR("Unexpected number of values");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
if (IsToAnimation() && aBaseValue.IsNull()) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// Get the normalised progress through the simple duration.
|
|
//
|
|
// If we have an indefinite simple duration, just set the progress to be
|
|
// 0 which will give us the expected behaviour of the animation being fixed at
|
|
// its starting point.
|
|
double simpleProgress = 0.0;
|
|
|
|
if (mSimpleDuration.IsDefinite()) {
|
|
nsSMILTime dur = mSimpleDuration.GetMillis();
|
|
|
|
MOZ_ASSERT(dur >= 0, "Simple duration should not be negative");
|
|
MOZ_ASSERT(mSampleTime >= 0, "Sample time should not be negative");
|
|
|
|
if (mSampleTime >= dur || mSampleTime < 0) {
|
|
NS_ERROR("Animation sampled outside interval");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
if (dur > 0) {
|
|
simpleProgress = (double)mSampleTime / dur;
|
|
} // else leave simpleProgress at 0.0 (e.g. if mSampleTime == dur == 0)
|
|
}
|
|
|
|
nsresult rv = NS_OK;
|
|
nsSMILCalcMode calcMode = GetCalcMode();
|
|
if (calcMode != CALC_DISCRETE) {
|
|
// Get the normalised progress between adjacent values
|
|
const nsSMILValue* from = nullptr;
|
|
const nsSMILValue* to = nullptr;
|
|
// Init to -1 to make sure that if we ever forget to set this, the
|
|
// MOZ_ASSERT that tests that intervalProgress is in range will fail.
|
|
double intervalProgress = -1.f;
|
|
if (IsToAnimation()) {
|
|
from = &aBaseValue;
|
|
to = &aValues[0];
|
|
if (calcMode == CALC_PACED) {
|
|
// Note: key[Times/Splines/Points] are ignored for calcMode="paced"
|
|
intervalProgress = simpleProgress;
|
|
} else {
|
|
double scaledSimpleProgress =
|
|
ScaleSimpleProgress(simpleProgress, calcMode);
|
|
intervalProgress = ScaleIntervalProgress(scaledSimpleProgress, 0);
|
|
}
|
|
} else if (calcMode == CALC_PACED) {
|
|
rv = ComputePacedPosition(aValues, simpleProgress,
|
|
intervalProgress, from, to);
|
|
// Note: If the above call fails, we'll skip the "from->Interpolate"
|
|
// call below, and we'll drop into the CALC_DISCRETE section
|
|
// instead. (as the spec says we should, because our failure was
|
|
// presumably due to the values being non-additive)
|
|
} else { // calcMode == CALC_LINEAR or calcMode == CALC_SPLINE
|
|
double scaledSimpleProgress =
|
|
ScaleSimpleProgress(simpleProgress, calcMode);
|
|
uint32_t index = (uint32_t)floor(scaledSimpleProgress *
|
|
(aValues.Length() - 1));
|
|
from = &aValues[index];
|
|
to = &aValues[index + 1];
|
|
intervalProgress =
|
|
scaledSimpleProgress * (aValues.Length() - 1) - index;
|
|
intervalProgress = ScaleIntervalProgress(intervalProgress, index);
|
|
}
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
MOZ_ASSERT(from, "NULL from-value during interpolation");
|
|
MOZ_ASSERT(to, "NULL to-value during interpolation");
|
|
#if(0)
|
|
// Bogus assertion that keeps firing. intervalProgress is always within
|
|
// this range even when it does fire, usually some critically small value
|
|
// like -6.1679056923618572e-18.
|
|
MOZ_ASSERT(0.0f <= intervalProgress && intervalProgress < 1.0f,
|
|
"Interval progress should be in the range [0, 1)");
|
|
#endif
|
|
rv = from->Interpolate(*to, intervalProgress, aResult);
|
|
}
|
|
}
|
|
|
|
// Discrete-CalcMode case
|
|
// Note: If interpolation failed (isn't supported for this type), the SVG
|
|
// spec says to force discrete mode.
|
|
if (calcMode == CALC_DISCRETE || NS_FAILED(rv)) {
|
|
double scaledSimpleProgress =
|
|
ScaleSimpleProgress(simpleProgress, CALC_DISCRETE);
|
|
|
|
// Floating-point errors can mean that, for example, a sample time of 29s in
|
|
// a 100s duration animation gives us a simple progress of 0.28999999999
|
|
// instead of the 0.29 we'd expect. Normally this isn't a noticeable
|
|
// problem, but when we have sudden jumps in animation values (such as is
|
|
// the case here with discrete animation) we can get unexpected results.
|
|
//
|
|
// To counteract this, before we perform a floor() on the animation
|
|
// progress, we add a tiny fudge factor to push us into the correct interval
|
|
// in cases where floating-point errors might cause us to fall short.
|
|
static const double kFloatingPointFudgeFactor = 1.0e-16;
|
|
if (scaledSimpleProgress + kFloatingPointFudgeFactor <= 1.0) {
|
|
scaledSimpleProgress += kFloatingPointFudgeFactor;
|
|
}
|
|
|
|
if (IsToAnimation()) {
|
|
// We don't follow SMIL 3, 12.6.4, where discrete to animations
|
|
// are the same as <set> animations. Instead, we treat it as a
|
|
// discrete animation with two values (the underlying value and
|
|
// the to="" value), and honor keyTimes="" as well.
|
|
uint32_t index = (uint32_t)floor(scaledSimpleProgress * 2);
|
|
aResult = index == 0 ? aBaseValue : aValues[0];
|
|
} else {
|
|
uint32_t index = (uint32_t)floor(scaledSimpleProgress * aValues.Length());
|
|
aResult = aValues[index];
|
|
}
|
|
rv = NS_OK;
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
nsSMILAnimationFunction::AccumulateResult(const nsSMILValueArray& aValues,
|
|
nsSMILValue& aResult)
|
|
{
|
|
if (!IsToAnimation() && GetAccumulate() && mRepeatIteration) {
|
|
const nsSMILValue& lastValue = aValues[aValues.Length() - 1];
|
|
|
|
// If the target attribute type doesn't support addition, Add will
|
|
// fail and we leave aResult untouched.
|
|
aResult.Add(lastValue, mRepeatIteration);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/*
|
|
* Given the simple progress for a paced animation, this method:
|
|
* - determines which two elements of the values array we're in between
|
|
* (returned as aFrom and aTo)
|
|
* - determines where we are between them
|
|
* (returned as aIntervalProgress)
|
|
*
|
|
* Returns NS_OK, or NS_ERROR_FAILURE if our values don't support distance
|
|
* computation.
|
|
*/
|
|
nsresult
|
|
nsSMILAnimationFunction::ComputePacedPosition(const nsSMILValueArray& aValues,
|
|
double aSimpleProgress,
|
|
double& aIntervalProgress,
|
|
const nsSMILValue*& aFrom,
|
|
const nsSMILValue*& aTo)
|
|
{
|
|
NS_ASSERTION(0.0f <= aSimpleProgress && aSimpleProgress < 1.0f,
|
|
"aSimpleProgress is out of bounds");
|
|
NS_ASSERTION(GetCalcMode() == CALC_PACED,
|
|
"Calling paced-specific function, but not in paced mode");
|
|
MOZ_ASSERT(aValues.Length() >= 2, "Unexpected number of values");
|
|
|
|
// Trivial case: If we have just 2 values, then there's only one interval
|
|
// for us to traverse, and our progress across that interval is the exact
|
|
// same as our overall progress.
|
|
if (aValues.Length() == 2) {
|
|
aIntervalProgress = aSimpleProgress;
|
|
aFrom = &aValues[0];
|
|
aTo = &aValues[1];
|
|
return NS_OK;
|
|
}
|
|
|
|
double totalDistance = ComputePacedTotalDistance(aValues);
|
|
if (totalDistance == COMPUTE_DISTANCE_ERROR)
|
|
return NS_ERROR_FAILURE;
|
|
|
|
// If we have 0 total distance, then it's unclear where our "paced" position
|
|
// should be. We can just fail, which drops us into discrete animation mode.
|
|
// (That's fine, since our values are apparently indistinguishable anyway.)
|
|
if (totalDistance == 0.0) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// total distance we should have moved at this point in time.
|
|
// (called 'remainingDist' due to how it's used in loop below)
|
|
double remainingDist = aSimpleProgress * totalDistance;
|
|
|
|
// Must be satisfied, because totalDistance is a sum of (non-negative)
|
|
// distances, and aSimpleProgress is non-negative
|
|
NS_ASSERTION(remainingDist >= 0, "distance values must be non-negative");
|
|
|
|
// Find where remainingDist puts us in the list of values
|
|
// Note: We could optimize this next loop by caching the
|
|
// interval-distances in an array, but maybe that's excessive.
|
|
for (uint32_t i = 0; i < aValues.Length() - 1; i++) {
|
|
// Note: The following assertion is valid because remainingDist should
|
|
// start out non-negative, and this loop never shaves off more than its
|
|
// current value.
|
|
NS_ASSERTION(remainingDist >= 0, "distance values must be non-negative");
|
|
|
|
double curIntervalDist;
|
|
|
|
#ifdef DEBUG
|
|
nsresult rv =
|
|
#endif
|
|
aValues[i].ComputeDistance(aValues[i+1], curIntervalDist);
|
|
MOZ_ASSERT(NS_SUCCEEDED(rv),
|
|
"If we got through ComputePacedTotalDistance, we should "
|
|
"be able to recompute each sub-distance without errors");
|
|
|
|
NS_ASSERTION(curIntervalDist >= 0, "distance values must be non-negative");
|
|
// Clamp distance value at 0, just in case ComputeDistance is evil.
|
|
curIntervalDist = std::max(curIntervalDist, 0.0);
|
|
|
|
if (remainingDist >= curIntervalDist) {
|
|
remainingDist -= curIntervalDist;
|
|
} else {
|
|
// NOTE: If we get here, then curIntervalDist necessarily is not 0. Why?
|
|
// Because this clause is only hit when remainingDist < curIntervalDist,
|
|
// and if curIntervalDist were 0, that would mean remainingDist would
|
|
// have to be < 0. But that can't happen, because remainingDist (as
|
|
// a distance) is non-negative by definition.
|
|
NS_ASSERTION(curIntervalDist != 0,
|
|
"We should never get here with this set to 0...");
|
|
|
|
// We found the right spot -- an interpolated position between
|
|
// values i and i+1.
|
|
aFrom = &aValues[i];
|
|
aTo = &aValues[i+1];
|
|
aIntervalProgress = remainingDist / curIntervalDist;
|
|
return NS_OK;
|
|
}
|
|
}
|
|
|
|
NS_NOTREACHED("shouldn't complete loop & get here -- if we do, "
|
|
"then aSimpleProgress was probably out of bounds");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
/*
|
|
* Computes the total distance to be travelled by a paced animation.
|
|
*
|
|
* Returns the total distance, or returns COMPUTE_DISTANCE_ERROR if
|
|
* our values don't support distance computation.
|
|
*/
|
|
double
|
|
nsSMILAnimationFunction::ComputePacedTotalDistance(
|
|
const nsSMILValueArray& aValues) const
|
|
{
|
|
NS_ASSERTION(GetCalcMode() == CALC_PACED,
|
|
"Calling paced-specific function, but not in paced mode");
|
|
|
|
double totalDistance = 0.0;
|
|
for (uint32_t i = 0; i < aValues.Length() - 1; i++) {
|
|
double tmpDist;
|
|
nsresult rv = aValues[i].ComputeDistance(aValues[i+1], tmpDist);
|
|
if (NS_FAILED(rv)) {
|
|
return COMPUTE_DISTANCE_ERROR;
|
|
}
|
|
|
|
// Clamp distance value to 0, just in case we have an evil ComputeDistance
|
|
// implementation somewhere
|
|
MOZ_ASSERT(tmpDist >= 0.0f, "distance values must be non-negative");
|
|
tmpDist = std::max(tmpDist, 0.0);
|
|
|
|
totalDistance += tmpDist;
|
|
}
|
|
|
|
return totalDistance;
|
|
}
|
|
|
|
double
|
|
nsSMILAnimationFunction::ScaleSimpleProgress(double aProgress,
|
|
nsSMILCalcMode aCalcMode)
|
|
{
|
|
if (!HasAttr(nsGkAtoms::keyTimes))
|
|
return aProgress;
|
|
|
|
uint32_t numTimes = mKeyTimes.Length();
|
|
|
|
if (numTimes < 2)
|
|
return aProgress;
|
|
|
|
uint32_t i = 0;
|
|
for (; i < numTimes - 2 && aProgress >= mKeyTimes[i+1]; ++i) { }
|
|
|
|
if (aCalcMode == CALC_DISCRETE) {
|
|
// discrete calcMode behaviour differs in that each keyTime defines the time
|
|
// from when the corresponding value is set, and therefore the last value
|
|
// needn't be 1. So check if we're in the last 'interval', that is, the
|
|
// space between the final value and 1.0.
|
|
if (aProgress >= mKeyTimes[i+1]) {
|
|
MOZ_ASSERT(i == numTimes - 2,
|
|
"aProgress is not in range of the current interval, yet the "
|
|
"current interval is not the last bounded interval either.");
|
|
++i;
|
|
}
|
|
return (double)i / numTimes;
|
|
}
|
|
|
|
double& intervalStart = mKeyTimes[i];
|
|
double& intervalEnd = mKeyTimes[i+1];
|
|
|
|
double intervalLength = intervalEnd - intervalStart;
|
|
if (intervalLength <= 0.0)
|
|
return intervalStart;
|
|
|
|
return (i + (aProgress - intervalStart) / intervalLength) /
|
|
double(numTimes - 1);
|
|
}
|
|
|
|
double
|
|
nsSMILAnimationFunction::ScaleIntervalProgress(double aProgress,
|
|
uint32_t aIntervalIndex)
|
|
{
|
|
if (GetCalcMode() != CALC_SPLINE)
|
|
return aProgress;
|
|
|
|
if (!HasAttr(nsGkAtoms::keySplines))
|
|
return aProgress;
|
|
|
|
MOZ_ASSERT(aIntervalIndex < mKeySplines.Length(),
|
|
"Invalid interval index");
|
|
|
|
nsSMILKeySpline const &spline = mKeySplines[aIntervalIndex];
|
|
return spline.GetSplineValue(aProgress);
|
|
}
|
|
|
|
bool
|
|
nsSMILAnimationFunction::HasAttr(nsIAtom* aAttName) const
|
|
{
|
|
return mAnimationElement->HasAnimAttr(aAttName);
|
|
}
|
|
|
|
const nsAttrValue*
|
|
nsSMILAnimationFunction::GetAttr(nsIAtom* aAttName) const
|
|
{
|
|
return mAnimationElement->GetAnimAttr(aAttName);
|
|
}
|
|
|
|
bool
|
|
nsSMILAnimationFunction::GetAttr(nsIAtom* aAttName, nsAString& aResult) const
|
|
{
|
|
return mAnimationElement->GetAnimAttr(aAttName, aResult);
|
|
}
|
|
|
|
/*
|
|
* A utility function to make querying an attribute that corresponds to an
|
|
* nsSMILValue a little neater.
|
|
*
|
|
* @param aAttName The attribute name (in the global namespace).
|
|
* @param aSMILAttr The SMIL attribute to perform the parsing.
|
|
* @param[out] aResult The resulting nsSMILValue.
|
|
* @param[out] aPreventCachingOfSandwich
|
|
* If |aResult| contains dependencies on its context that
|
|
* should prevent the result of the animation sandwich from
|
|
* being cached and reused in future samples (as reported
|
|
* by nsISMILAttr::ValueFromString), then this outparam
|
|
* will be set to true. Otherwise it is left unmodified.
|
|
*
|
|
* Returns false if a parse error occurred, otherwise returns true.
|
|
*/
|
|
bool
|
|
nsSMILAnimationFunction::ParseAttr(nsIAtom* aAttName,
|
|
const nsISMILAttr& aSMILAttr,
|
|
nsSMILValue& aResult,
|
|
bool& aPreventCachingOfSandwich) const
|
|
{
|
|
nsAutoString attValue;
|
|
if (GetAttr(aAttName, attValue)) {
|
|
bool preventCachingOfSandwich = false;
|
|
nsresult rv = aSMILAttr.ValueFromString(attValue, mAnimationElement,
|
|
aResult, preventCachingOfSandwich);
|
|
if (NS_FAILED(rv))
|
|
return false;
|
|
|
|
if (preventCachingOfSandwich) {
|
|
aPreventCachingOfSandwich = true;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* SMILANIM specifies the following rules for animation function values:
|
|
*
|
|
* (1) if values is set, it overrides everything
|
|
* (2) for from/to/by animation at least to or by must be specified, from on its
|
|
* own (or nothing) is an error--which we will ignore
|
|
* (3) if both by and to are specified only to will be used, by will be ignored
|
|
* (4) if by is specified without from (by animation), forces additive behaviour
|
|
* (5) if to is specified without from (to animation), special care needs to be
|
|
* taken when compositing animation as such animations are composited last.
|
|
*
|
|
* This helper method applies these rules to fill in the values list and to set
|
|
* some internal state.
|
|
*/
|
|
nsresult
|
|
nsSMILAnimationFunction::GetValues(const nsISMILAttr& aSMILAttr,
|
|
nsSMILValueArray& aResult)
|
|
{
|
|
if (!mAnimationElement)
|
|
return NS_ERROR_FAILURE;
|
|
|
|
mValueNeedsReparsingEverySample = false;
|
|
nsSMILValueArray result;
|
|
|
|
// If "values" is set, use it
|
|
if (HasAttr(nsGkAtoms::values)) {
|
|
nsAutoString attValue;
|
|
GetAttr(nsGkAtoms::values, attValue);
|
|
bool preventCachingOfSandwich = false;
|
|
if (!nsSMILParserUtils::ParseValues(attValue, mAnimationElement,
|
|
aSMILAttr, result,
|
|
preventCachingOfSandwich)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
if (preventCachingOfSandwich) {
|
|
mValueNeedsReparsingEverySample = true;
|
|
}
|
|
// Else try to/from/by
|
|
} else {
|
|
bool preventCachingOfSandwich = false;
|
|
bool parseOk = true;
|
|
nsSMILValue to, from, by;
|
|
parseOk &= ParseAttr(nsGkAtoms::to, aSMILAttr, to,
|
|
preventCachingOfSandwich);
|
|
parseOk &= ParseAttr(nsGkAtoms::from, aSMILAttr, from,
|
|
preventCachingOfSandwich);
|
|
parseOk &= ParseAttr(nsGkAtoms::by, aSMILAttr, by,
|
|
preventCachingOfSandwich);
|
|
|
|
if (preventCachingOfSandwich) {
|
|
mValueNeedsReparsingEverySample = true;
|
|
}
|
|
|
|
if (!parseOk || !result.SetCapacity(2, mozilla::fallible)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// AppendElement() below must succeed, because SetCapacity() succeeded.
|
|
if (!to.IsNull()) {
|
|
if (!from.IsNull()) {
|
|
MOZ_ALWAYS_TRUE(result.AppendElement(from, mozilla::fallible));
|
|
MOZ_ALWAYS_TRUE(result.AppendElement(to, mozilla::fallible));
|
|
} else {
|
|
MOZ_ALWAYS_TRUE(result.AppendElement(to, mozilla::fallible));
|
|
}
|
|
} else if (!by.IsNull()) {
|
|
nsSMILValue effectiveFrom(by.mType);
|
|
if (!from.IsNull())
|
|
effectiveFrom = from;
|
|
// Set values to 'from; from + by'
|
|
MOZ_ALWAYS_TRUE(result.AppendElement(effectiveFrom, mozilla::fallible));
|
|
nsSMILValue effectiveTo(effectiveFrom);
|
|
if (!effectiveTo.IsNull() && NS_SUCCEEDED(effectiveTo.Add(by))) {
|
|
MOZ_ALWAYS_TRUE(result.AppendElement(effectiveTo, mozilla::fallible));
|
|
} else {
|
|
// Using by-animation with non-additive type or bad base-value
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
} else {
|
|
// No values, no to, no by -- call it a day
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
}
|
|
|
|
result.SwapElements(aResult);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsSMILAnimationFunction::CheckValueListDependentAttrs(uint32_t aNumValues)
|
|
{
|
|
CheckKeyTimes(aNumValues);
|
|
CheckKeySplines(aNumValues);
|
|
}
|
|
|
|
/**
|
|
* Performs checks for the keyTimes attribute required by the SMIL spec but
|
|
* which depend on other attributes and therefore needs to be updated as
|
|
* dependent attributes are set.
|
|
*/
|
|
void
|
|
nsSMILAnimationFunction::CheckKeyTimes(uint32_t aNumValues)
|
|
{
|
|
if (!HasAttr(nsGkAtoms::keyTimes))
|
|
return;
|
|
|
|
nsSMILCalcMode calcMode = GetCalcMode();
|
|
|
|
// attribute is ignored for calcMode = paced
|
|
if (calcMode == CALC_PACED) {
|
|
SetKeyTimesErrorFlag(false);
|
|
return;
|
|
}
|
|
|
|
uint32_t numKeyTimes = mKeyTimes.Length();
|
|
if (numKeyTimes < 1) {
|
|
// keyTimes isn't set or failed preliminary checks
|
|
SetKeyTimesErrorFlag(true);
|
|
return;
|
|
}
|
|
|
|
// no. keyTimes == no. values
|
|
// For to-animation the number of values is considered to be 2.
|
|
bool matchingNumOfValues =
|
|
numKeyTimes == (IsToAnimation() ? 2 : aNumValues);
|
|
if (!matchingNumOfValues) {
|
|
SetKeyTimesErrorFlag(true);
|
|
return;
|
|
}
|
|
|
|
// first value must be 0
|
|
if (mKeyTimes[0] != 0.0) {
|
|
SetKeyTimesErrorFlag(true);
|
|
return;
|
|
}
|
|
|
|
// last value must be 1 for linear or spline calcModes
|
|
if (calcMode != CALC_DISCRETE && numKeyTimes > 1 &&
|
|
mKeyTimes[numKeyTimes - 1] != 1.0) {
|
|
SetKeyTimesErrorFlag(true);
|
|
return;
|
|
}
|
|
|
|
SetKeyTimesErrorFlag(false);
|
|
}
|
|
|
|
void
|
|
nsSMILAnimationFunction::CheckKeySplines(uint32_t aNumValues)
|
|
{
|
|
// attribute is ignored if calc mode is not spline
|
|
if (GetCalcMode() != CALC_SPLINE) {
|
|
SetKeySplinesErrorFlag(false);
|
|
return;
|
|
}
|
|
|
|
// calc mode is spline but the attribute is not set
|
|
if (!HasAttr(nsGkAtoms::keySplines)) {
|
|
SetKeySplinesErrorFlag(false);
|
|
return;
|
|
}
|
|
|
|
if (mKeySplines.Length() < 1) {
|
|
// keyTimes isn't set or failed preliminary checks
|
|
SetKeySplinesErrorFlag(true);
|
|
return;
|
|
}
|
|
|
|
// ignore splines if there's only one value
|
|
if (aNumValues == 1 && !IsToAnimation()) {
|
|
SetKeySplinesErrorFlag(false);
|
|
return;
|
|
}
|
|
|
|
// no. keySpline specs == no. values - 1
|
|
uint32_t splineSpecs = mKeySplines.Length();
|
|
if ((splineSpecs != aNumValues - 1 && !IsToAnimation()) ||
|
|
(IsToAnimation() && splineSpecs != 1)) {
|
|
SetKeySplinesErrorFlag(true);
|
|
return;
|
|
}
|
|
|
|
SetKeySplinesErrorFlag(false);
|
|
}
|
|
|
|
bool
|
|
nsSMILAnimationFunction::IsValueFixedForSimpleDuration() const
|
|
{
|
|
return mSimpleDuration.IsIndefinite() ||
|
|
(!mHasChanged && mPrevSampleWasSingleValueAnimation);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Property getters
|
|
|
|
bool
|
|
nsSMILAnimationFunction::GetAccumulate() const
|
|
{
|
|
const nsAttrValue* value = GetAttr(nsGkAtoms::accumulate);
|
|
if (!value)
|
|
return false;
|
|
|
|
return value->GetEnumValue();
|
|
}
|
|
|
|
bool
|
|
nsSMILAnimationFunction::GetAdditive() const
|
|
{
|
|
const nsAttrValue* value = GetAttr(nsGkAtoms::additive);
|
|
if (!value)
|
|
return false;
|
|
|
|
return value->GetEnumValue();
|
|
}
|
|
|
|
nsSMILAnimationFunction::nsSMILCalcMode
|
|
nsSMILAnimationFunction::GetCalcMode() const
|
|
{
|
|
const nsAttrValue* value = GetAttr(nsGkAtoms::calcMode);
|
|
if (!value)
|
|
return CALC_LINEAR;
|
|
|
|
return nsSMILCalcMode(value->GetEnumValue());
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Property setters / un-setters:
|
|
|
|
nsresult
|
|
nsSMILAnimationFunction::SetAccumulate(const nsAString& aAccumulate,
|
|
nsAttrValue& aResult)
|
|
{
|
|
mHasChanged = true;
|
|
bool parseResult =
|
|
aResult.ParseEnumValue(aAccumulate, sAccumulateTable, true);
|
|
SetAccumulateErrorFlag(!parseResult);
|
|
return parseResult ? NS_OK : NS_ERROR_FAILURE;
|
|
}
|
|
|
|
void
|
|
nsSMILAnimationFunction::UnsetAccumulate()
|
|
{
|
|
SetAccumulateErrorFlag(false);
|
|
mHasChanged = true;
|
|
}
|
|
|
|
nsresult
|
|
nsSMILAnimationFunction::SetAdditive(const nsAString& aAdditive,
|
|
nsAttrValue& aResult)
|
|
{
|
|
mHasChanged = true;
|
|
bool parseResult
|
|
= aResult.ParseEnumValue(aAdditive, sAdditiveTable, true);
|
|
SetAdditiveErrorFlag(!parseResult);
|
|
return parseResult ? NS_OK : NS_ERROR_FAILURE;
|
|
}
|
|
|
|
void
|
|
nsSMILAnimationFunction::UnsetAdditive()
|
|
{
|
|
SetAdditiveErrorFlag(false);
|
|
mHasChanged = true;
|
|
}
|
|
|
|
nsresult
|
|
nsSMILAnimationFunction::SetCalcMode(const nsAString& aCalcMode,
|
|
nsAttrValue& aResult)
|
|
{
|
|
mHasChanged = true;
|
|
bool parseResult
|
|
= aResult.ParseEnumValue(aCalcMode, sCalcModeTable, true);
|
|
SetCalcModeErrorFlag(!parseResult);
|
|
return parseResult ? NS_OK : NS_ERROR_FAILURE;
|
|
}
|
|
|
|
void
|
|
nsSMILAnimationFunction::UnsetCalcMode()
|
|
{
|
|
SetCalcModeErrorFlag(false);
|
|
mHasChanged = true;
|
|
}
|
|
|
|
nsresult
|
|
nsSMILAnimationFunction::SetKeySplines(const nsAString& aKeySplines,
|
|
nsAttrValue& aResult)
|
|
{
|
|
mKeySplines.Clear();
|
|
aResult.SetTo(aKeySplines);
|
|
|
|
mHasChanged = true;
|
|
|
|
if (!nsSMILParserUtils::ParseKeySplines(aKeySplines, mKeySplines)) {
|
|
mKeySplines.Clear();
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsSMILAnimationFunction::UnsetKeySplines()
|
|
{
|
|
mKeySplines.Clear();
|
|
SetKeySplinesErrorFlag(false);
|
|
mHasChanged = true;
|
|
}
|
|
|
|
nsresult
|
|
nsSMILAnimationFunction::SetKeyTimes(const nsAString& aKeyTimes,
|
|
nsAttrValue& aResult)
|
|
{
|
|
mKeyTimes.Clear();
|
|
aResult.SetTo(aKeyTimes);
|
|
|
|
mHasChanged = true;
|
|
|
|
if (!nsSMILParserUtils::ParseSemicolonDelimitedProgressList(aKeyTimes, true,
|
|
mKeyTimes)) {
|
|
mKeyTimes.Clear();
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsSMILAnimationFunction::UnsetKeyTimes()
|
|
{
|
|
mKeyTimes.Clear();
|
|
SetKeyTimesErrorFlag(false);
|
|
mHasChanged = true;
|
|
}
|