SVGAnimationElement.h [plain text]
#ifndef SVGAnimationElement_h
#define SVGAnimationElement_h
#include "SMILTime.h"
#include "SVGAnimatedBoolean.h"
#include "SVGExternalResourcesRequired.h"
#include "SVGSMILElement.h"
#include "SVGTests.h"
#include "UnitBezier.h"
namespace WebCore {
enum AnimationMode {
NoAnimation,
FromToAnimation,
FromByAnimation,
ToAnimation,
ByAnimation,
ValuesAnimation,
PathAnimation };
enum AnimatedPropertyValueType {
RegularPropertyValue,
CurrentColorValue,
InheritValue
};
enum CalcMode {
CalcModeDiscrete,
CalcModeLinear,
CalcModePaced,
CalcModeSpline
};
class ConditionEventListener;
class TimeContainer;
class SVGAnimatedType;
class SVGAnimationElement : public SVGSMILElement,
public SVGTests,
public SVGExternalResourcesRequired {
public:
float getStartTime() const;
float getCurrentTime() const;
float getSimpleDuration(ExceptionCode&) const;
void beginElement();
void beginElementAt(float offset);
void endElement();
void endElementAt(float offset);
static bool isTargetAttributeCSSProperty(SVGElement*, const QualifiedName&);
virtual bool isAdditive() const override;
bool isAccumulated() const;
AnimationMode animationMode() const { return m_animationMode; }
CalcMode calcMode() const { return m_calcMode; }
enum ShouldApplyAnimation {
DontApplyAnimation,
ApplyCSSAnimation,
ApplyXMLAnimation
};
ShouldApplyAnimation shouldApplyAnimation(SVGElement* targetElement, const QualifiedName& attributeName);
AnimatedPropertyValueType fromPropertyValueType() const { return m_fromPropertyValueType; }
AnimatedPropertyValueType toPropertyValueType() const { return m_toPropertyValueType; }
template<typename AnimatedType>
void adjustForInheritance(AnimatedType (*parseTypeFromString)(SVGAnimationElement*, const String&),
AnimatedPropertyValueType valueType, AnimatedType& animatedType, SVGElement* contextElement)
{
if (valueType != InheritValue)
return;
ASSERT(parseTypeFromString);
String typeString;
adjustForInheritance(contextElement, attributeName(), typeString);
animatedType = (*parseTypeFromString)(this, typeString);
}
template<typename AnimatedType>
bool adjustFromToListValues(const AnimatedType& fromList, const AnimatedType& toList, AnimatedType& animatedList, float percentage, bool resizeAnimatedListIfNeeded = true)
{
unsigned toListSize = toList.size();
if (!toListSize)
return false;
unsigned fromListSize = fromList.size();
if (fromListSize != toListSize && fromListSize) {
if (percentage < 0.5) {
if (animationMode() != ToAnimation)
animatedList = AnimatedType(fromList);
} else
animatedList = AnimatedType(toList);
return false;
}
ASSERT(!fromListSize || fromListSize == toListSize);
if (resizeAnimatedListIfNeeded && animatedList.size() < toListSize)
animatedList.resize(toListSize);
return true;
}
template<typename AnimatedType>
void animateDiscreteType(float percentage, const AnimatedType& fromType, const AnimatedType& toType, AnimatedType& animatedType)
{
if ((animationMode() == FromToAnimation && percentage > 0.5) || animationMode() == ToAnimation || percentage == 1) {
animatedType = AnimatedType(toType);
return;
}
animatedType = AnimatedType(fromType);
}
void animateAdditiveNumber(float percentage, unsigned repeatCount, float fromNumber, float toNumber, float toAtEndOfDurationNumber, float& animatedNumber)
{
float number;
if (calcMode() == CalcModeDiscrete)
number = percentage < 0.5 ? fromNumber : toNumber;
else
number = (toNumber - fromNumber) * percentage + fromNumber;
if (isAccumulated() && repeatCount)
number += toAtEndOfDurationNumber * repeatCount;
if (isAdditive() && animationMode() != ToAnimation)
animatedNumber += number;
else
animatedNumber = number;
}
protected:
SVGAnimationElement(const QualifiedName&, Document&);
void computeCSSPropertyValue(SVGElement*, CSSPropertyID, String& value);
virtual void determinePropertyValueTypes(const String& from, const String& to);
bool isSupportedAttribute(const QualifiedName&);
virtual void parseAttribute(const QualifiedName&, const AtomicString&) override;
virtual void svgAttributeChanged(const QualifiedName&) override;
enum AttributeType {
AttributeTypeCSS,
AttributeTypeXML,
AttributeTypeAuto
};
AttributeType attributeType() const { return m_attributeType; }
String toValue() const;
String byValue() const;
String fromValue() const;
String targetAttributeBaseValue();
virtual void startedActiveInterval() override;
virtual void updateAnimation(float percent, unsigned repeat, SVGSMILElement* resultElement) override;
AnimatedPropertyValueType m_fromPropertyValueType;
AnimatedPropertyValueType m_toPropertyValueType;
virtual void setTargetElement(SVGElement*) override;
virtual void setAttributeName(const QualifiedName&) override;
bool hasInvalidCSSAttributeType() const { return m_hasInvalidCSSAttributeType; }
virtual void updateAnimationMode();
void setAnimationMode(AnimationMode animationMode) { m_animationMode = animationMode; }
void setCalcMode(CalcMode calcMode) { m_calcMode = calcMode; }
private:
virtual void animationAttributeChanged() override;
void setAttributeType(const AtomicString&);
void checkInvalidCSSAttributeType(SVGElement*);
virtual bool calculateToAtEndOfDurationValue(const String& toAtEndOfDurationString) = 0;
virtual bool calculateFromAndToValues(const String& fromString, const String& toString) = 0;
virtual bool calculateFromAndByValues(const String& fromString, const String& byString) = 0;
virtual void calculateAnimatedValue(float percent, unsigned repeatCount, SVGSMILElement* resultElement) = 0;
virtual float calculateDistance(const String& , const String& ) { return -1.f; }
void currentValuesForValuesAnimation(float percent, float& effectivePercent, String& from, String& to);
void calculateKeyTimesForCalcModePaced();
float calculatePercentFromKeyPoints(float percent) const;
void currentValuesFromKeyPoints(float percent, float& effectivePercent, String& from, String& to) const;
float calculatePercentForSpline(float percent, unsigned splineIndex) const;
float calculatePercentForFromTo(float percent) const;
unsigned calculateKeyTimesIndex(float percent) const;
void applyAnimatedValue(ShouldApplyAnimation, SVGElement* targetElement, const QualifiedName& attributeName, SVGAnimatedType*);
void adjustForInheritance(SVGElement* targetElement, const QualifiedName& attributeName, String&);
BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGAnimationElement)
DECLARE_ANIMATED_BOOLEAN(ExternalResourcesRequired, externalResourcesRequired)
END_DECLARE_ANIMATED_PROPERTIES
virtual void synchronizeRequiredFeatures() override { SVGTests::synchronizeRequiredFeatures(this); }
virtual void synchronizeRequiredExtensions() override { SVGTests::synchronizeRequiredExtensions(this); }
virtual void synchronizeSystemLanguage() override { SVGTests::synchronizeSystemLanguage(this); }
void setCalcMode(const AtomicString&);
bool m_animationValid;
AttributeType m_attributeType;
Vector<String> m_values;
Vector<float> m_keyTimes;
Vector<float> m_keyPoints;
Vector<UnitBezier> m_keySplines;
String m_lastValuesAnimationFrom;
String m_lastValuesAnimationTo;
bool m_hasInvalidCSSAttributeType;
CalcMode m_calcMode;
AnimationMode m_animationMode;
};
}
#endif // SVGAnimationElement_h