SVGAnimateMotionElement.cpp [plain text]
#include "config.h"
#if ENABLE(SVG)
#include "SVGAnimateMotionElement.h"
#include "Attribute.h"
#include "RenderObject.h"
#include "RenderSVGResource.h"
#include "SVGElementInstance.h"
#include "SVGMPathElement.h"
#include "SVGNames.h"
#include "SVGParserUtilities.h"
#include "SVGPathData.h"
#include "SVGPathElement.h"
#include "SVGPathUtilities.h"
#include "SVGTransformList.h"
#include <wtf/MathExtras.h>
#include <wtf/StdLibExtras.h>
namespace WebCore {
using namespace SVGNames;
inline SVGAnimateMotionElement::SVGAnimateMotionElement(const QualifiedName& tagName, Document* document)
: SVGAnimationElement(tagName, document)
, m_hasToPointAtEndOfDuration(false)
{
ASSERT(hasTagName(animateMotionTag));
}
PassRefPtr<SVGAnimateMotionElement> SVGAnimateMotionElement::create(const QualifiedName& tagName, Document* document)
{
return adoptRef(new SVGAnimateMotionElement(tagName, document));
}
bool SVGAnimateMotionElement::hasValidAttributeType()
{
SVGElement* targetElement = this->targetElement();
if (!targetElement)
return false;
if (!targetElement->isStyledTransformable() && !targetElement->hasTagName(SVGNames::textTag))
return false;
if (targetElement->hasTagName(gTag)
|| targetElement->hasTagName(defsTag)
|| targetElement->hasTagName(useTag)
|| targetElement->hasTagName(imageTag)
|| targetElement->hasTagName(switchTag)
|| targetElement->hasTagName(pathTag)
|| targetElement->hasTagName(rectTag)
|| targetElement->hasTagName(circleTag)
|| targetElement->hasTagName(ellipseTag)
|| targetElement->hasTagName(lineTag)
|| targetElement->hasTagName(polylineTag)
|| targetElement->hasTagName(polygonTag)
|| targetElement->hasTagName(textTag)
|| targetElement->hasTagName(clipPathTag)
|| targetElement->hasTagName(maskTag)
|| targetElement->hasTagName(aTag)
|| targetElement->hasTagName(foreignObjectTag)
)
return true;
return false;
}
bool SVGAnimateMotionElement::isSupportedAttribute(const QualifiedName& attrName)
{
DEFINE_STATIC_LOCAL(HashSet<QualifiedName>, supportedAttributes, ());
if (supportedAttributes.isEmpty())
supportedAttributes.add(SVGNames::pathAttr);
return supportedAttributes.contains<QualifiedName, SVGAttributeHashTranslator>(attrName);
}
void SVGAnimateMotionElement::parseAttribute(Attribute* attr)
{
if (!isSupportedAttribute(attr->name())) {
SVGAnimationElement::parseAttribute(attr);
return;
}
if (attr->name() == SVGNames::pathAttr) {
m_path = Path();
buildPathFromString(attr->value(), m_path);
return;
}
ASSERT_NOT_REACHED();
}
SVGAnimateMotionElement::RotateMode SVGAnimateMotionElement::rotateMode() const
{
DEFINE_STATIC_LOCAL(const AtomicString, autoVal, ("auto"));
DEFINE_STATIC_LOCAL(const AtomicString, autoReverse, ("auto-reverse"));
const AtomicString& rotate = getAttribute(SVGNames::rotateAttr);
if (rotate == autoVal)
return RotateAuto;
if (rotate == autoReverse)
return RotateAutoReverse;
return RotateAngle;
}
Path SVGAnimateMotionElement::animationPath() const
{
for (Node* child = firstChild(); child; child = child->nextSibling()) {
if (child->hasTagName(SVGNames::mpathTag)) {
SVGMPathElement* mPath = static_cast<SVGMPathElement*>(child);
SVGPathElement* pathElement = mPath->pathElement();
Path path;
if (pathElement)
updatePathFromGraphicsElement(pathElement, path);
return path;
}
}
if (fastHasAttribute(SVGNames::pathAttr))
return m_path;
return Path();
}
static bool parsePoint(const String& s, FloatPoint& point)
{
if (s.isEmpty())
return false;
const UChar* cur = s.characters();
const UChar* end = cur + s.length();
if (!skipOptionalSVGSpaces(cur, end))
return false;
float x = 0;
if (!parseNumber(cur, end, x))
return false;
float y = 0;
if (!parseNumber(cur, end, y))
return false;
point = FloatPoint(x, y);
return !skipOptionalSVGSpaces(cur, end);
}
void SVGAnimateMotionElement::resetToBaseValue()
{
if (!hasValidAttributeType())
return;
AffineTransform* transform = targetElement()->supplementalTransform();
if (!transform)
return;
transform->makeIdentity();
}
bool SVGAnimateMotionElement::calculateToAtEndOfDurationValue(const String& toAtEndOfDurationString)
{
parsePoint(toAtEndOfDurationString, m_toPointAtEndOfDuration);
m_hasToPointAtEndOfDuration = true;
return true;
}
bool SVGAnimateMotionElement::calculateFromAndToValues(const String& fromString, const String& toString)
{
m_hasToPointAtEndOfDuration = false;
parsePoint(fromString, m_fromPoint);
parsePoint(toString, m_toPoint);
return true;
}
bool SVGAnimateMotionElement::calculateFromAndByValues(const String& fromString, const String& byString)
{
m_hasToPointAtEndOfDuration = false;
if (animationMode() == ByAnimation && !isAdditive())
return false;
parsePoint(fromString, m_fromPoint);
FloatPoint byPoint;
parsePoint(byString, byPoint);
m_toPoint = FloatPoint(m_fromPoint.x() + byPoint.x(), m_fromPoint.y() + byPoint.y());
return true;
}
void SVGAnimateMotionElement::buildTransformForProgress(AffineTransform* transform, float percentage)
{
Path path = animationPath();
ASSERT(!path.isEmpty());
bool ok = false;
float positionOnPath = path.length() * percentage;
FloatPoint position = path.pointAtLength(positionOnPath, ok);
if (!ok)
return;
transform->translate(position.x(), position.y());
RotateMode rotateMode = this->rotateMode();
if (rotateMode != RotateAuto && rotateMode != RotateAutoReverse)
return;
float angle = path.normalAngleAtLength(positionOnPath, ok);
if (rotateMode == RotateAutoReverse)
angle += 180;
transform->rotate(angle);
}
void SVGAnimateMotionElement::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGSMILElement*)
{
SVGElement* targetElement = this->targetElement();
if (!targetElement)
return;
AffineTransform* transform = targetElement->supplementalTransform();
if (!transform)
return;
if (RenderObject* targetRenderer = targetElement->renderer())
targetRenderer->setNeedsTransformUpdate();
if (!isAdditive())
transform->makeIdentity();
if (animationMode() != PathAnimation) {
FloatPoint toPointAtEndOfDuration = m_toPoint;
if (isAccumulated() && repeatCount && m_hasToPointAtEndOfDuration)
toPointAtEndOfDuration = m_toPointAtEndOfDuration;
float animatedX = 0;
animateAdditiveNumber(percentage, repeatCount, m_fromPoint.x(), m_toPoint.x(), toPointAtEndOfDuration.x(), animatedX);
float animatedY = 0;
animateAdditiveNumber(percentage, repeatCount, m_fromPoint.y(), m_toPoint.y(), toPointAtEndOfDuration.y(), animatedY);
transform->translate(animatedX, animatedY);
return;
}
buildTransformForProgress(transform, percentage);
if (isAccumulated() && repeatCount) {
for (unsigned i = 0; i < repeatCount; ++i)
buildTransformForProgress(transform, 1);
}
}
void SVGAnimateMotionElement::applyResultsToTarget()
{
SVGElement* targetElement = this->targetElement();
if (!targetElement)
return;
if (RenderObject* renderer = targetElement->renderer())
RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer);
AffineTransform* t = targetElement->supplementalTransform();
if (!t)
return;
const HashSet<SVGElementInstance*>& instances = targetElement->instancesForElement();
const HashSet<SVGElementInstance*>::const_iterator end = instances.end();
for (HashSet<SVGElementInstance*>::const_iterator it = instances.begin(); it != end; ++it) {
SVGElement* shadowTreeElement = (*it)->shadowTreeElement();
ASSERT(shadowTreeElement);
AffineTransform* transform = shadowTreeElement->supplementalTransform();
if (!transform)
continue;
transform->setMatrix(t->a(), t->b(), t->c(), t->d(), t->e(), t->f());
if (RenderObject* renderer = shadowTreeElement->renderer()) {
renderer->setNeedsTransformUpdate();
RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer);
}
}
}
float SVGAnimateMotionElement::calculateDistance(const String& fromString, const String& toString)
{
FloatPoint from;
FloatPoint to;
if (!parsePoint(fromString, from))
return -1;
if (!parsePoint(toString, to))
return -1;
FloatSize diff = to - from;
return sqrtf(diff.width() * diff.width() + diff.height() * diff.height());
}
}
#endif // ENABLE(SVG)