SVGAnimationElement.h [plain text]
#ifndef SVGAnimationElement_h
#define SVGAnimationElement_h
#if ENABLE(SVG)
#include "ElementTimeControl.h"
#include "Path.h"
#include "SMILTime.h"
#include "SVGAnimatedBoolean.h"
#include "SVGExternalResourcesRequired.h"
#include "SVGSMILElement.h"
#include "SVGStringList.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 ElementTimeControl {
public:
float getStartTime() const;
float getCurrentTime() const;
float getSimpleDuration(ExceptionCode&) const;
virtual void beginElement();
virtual void beginElementAt(float offset);
virtual void endElement();
virtual void endElementAt(float offset);
static bool isTargetAttributeCSSProperty(SVGElement*, const QualifiedName&);
virtual bool isAdditive() const;
bool isAccumulated() const;
AnimationMode animationMode() const;
CalcMode calcMode() const;
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(Attribute*) OVERRIDE;
virtual void svgAttributeChanged(const QualifiedName&) OVERRIDE;
enum AttributeType {
AttributeTypeCSS,
AttributeTypeXML,
AttributeTypeAuto
};
AttributeType attributeType() const;
String toValue() const;
String byValue() const;
String fromValue() const;
String targetAttributeBaseValue();
void setTargetAttributeAnimatedCSSValue(SVGAnimatedType*);
virtual void startedActiveInterval();
virtual void updateAnimation(float percent, unsigned repeat, SVGSMILElement* resultElement);
AnimatedPropertyValueType m_fromPropertyValueType;
AnimatedPropertyValueType m_toPropertyValueType;
private:
virtual void animationAttributeChanged() OVERRIDE;
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; }
virtual Path animationPath() const { return Path(); }
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() { SVGTests::synchronizeRequiredFeatures(this); }
virtual void synchronizeRequiredExtensions() { SVGTests::synchronizeRequiredExtensions(this); }
virtual void synchronizeSystemLanguage() { SVGTests::synchronizeSystemLanguage(this); }
bool m_animationValid;
Vector<String> m_values;
Vector<float> m_keyTimes;
Vector<float> m_keyPoints;
Vector<UnitBezier> m_keySplines;
String m_lastValuesAnimationFrom;
String m_lastValuesAnimationTo;
};
}
#endif // ENABLE(SVG)
#endif // SVGAnimationElement_h