File indexing completed on 2024-04-28 15:24:28

 /*
     Copyright (C) 2004, 2005 Nikolas Zimmermann <wildfox@kde.org>
                   2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
     Copyright (C) 2007 Eric Seidel <eric@webkit.org>
     Copyright (C) 2008 Apple Inc. All Rights Reserved.
 
     This file is part of the WebKit project
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #if ENABLE(SVG) && ENABLE(SVG_ANIMATION)
 #include "SVGAnimateTransformElement.h"
 
 #include "AffineTransform.h"
 #include "RenderObject.h"
 #include "SVGAngle.h"
 #include "SVGElementInstance.h"
 #include "SVGParserUtilities.h"
 #include "SVGSVGElement.h"
 #include "SVGStyledTransformableElement.h"
 #include "SVGTextElement.h"
 #include "SVGTransformList.h"
 #include "SVGUseElement.h"
 
 #include <math.h>
 #include <wtf/MathExtras.h>
 
 using namespace std;
 
 namespace WebCore
 {
 
 SVGAnimateTransformElement::SVGAnimateTransformElement(const QualifiedName &tagName, Document *doc)
     : SVGAnimationElement(tagName, doc)
     , m_type(SVGTransform::SVG_TRANSFORM_UNKNOWN)
     , m_baseIndexInTransformList(0)
 {
 }
 
 SVGAnimateTransformElement::~SVGAnimateTransformElement()
 {
 }
 
 bool SVGAnimateTransformElement::hasValidTarget() const
 {
     SVGElement *targetElement = this->targetElement();
     return SVGAnimationElement::hasValidTarget() && (targetElement->isStyledTransformable() || targetElement->hasTagName(SVGNames::textTag));
 }
 
 void SVGAnimateTransformElement::parseMappedAttribute(MappedAttribute *attr)
 {
     if (attr->name() == SVGNames::typeAttr) {
         if (attr->value() == "translate") {
             m_type = SVGTransform::SVG_TRANSFORM_TRANSLATE;
         } else if (attr->value() == "scale") {
             m_type = SVGTransform::SVG_TRANSFORM_SCALE;
         } else if (attr->value() == "rotate") {
             m_type = SVGTransform::SVG_TRANSFORM_ROTATE;
         } else if (attr->value() == "skewX") {
             m_type = SVGTransform::SVG_TRANSFORM_SKEWX;
         } else if (attr->value() == "skewY") {
             m_type = SVGTransform::SVG_TRANSFORM_SKEWY;
         }
     } else {
         SVGAnimationElement::parseMappedAttribute(attr);
     }
 }
 
 static PassRefPtr<SVGTransformList> transformListFor(SVGElement *element)
 {
     ASSERT(element);
     if (element->isStyledTransformable()) {
         return static_cast<SVGStyledTransformableElement *>(element)->transform();
     }
     if (element->hasTagName(SVGNames::textTag)) {
         return static_cast<SVGTextElement *>(element)->transform();
     }
     return 0;
 }
 
 void SVGAnimateTransformElement::resetToBaseValue(const String &baseValue)
 {
     if (!hasValidTarget()) {
         return;
     }
     if (baseValue.isEmpty()) {
         ExceptionCode ec;
         RefPtr<SVGTransformList> list = transformListFor(targetElement());
         list->clear(ec);
     } else {
         targetElement()->setAttribute(SVGNames::transformAttr, baseValue);
     }
 }
 
 void SVGAnimateTransformElement::calculateAnimatedValue(float percentage, unsigned repeat, SVGSMILElement *resultElement)
 {
     if (!hasValidTarget()) {
         return;
     }
     SVGElement *targetElement = resultElement->targetElement();
     RefPtr<SVGTransformList> transformList = transformListFor(targetElement);
     ASSERT(transformList);
 
     ExceptionCode ec;
     if (!isAdditive()) {
         transformList->clear(ec);
     }
     if (isAccumulated() && repeat) {
         SVGTransform accumulatedTransform = SVGTransformDistance(m_fromTransform, m_toTransform).scaledDistance(repeat).addToSVGTransform(SVGTransform());
         transformList->appendItem(accumulatedTransform, ec);
     }
     SVGTransform transform = SVGTransformDistance(m_fromTransform, m_toTransform).scaledDistance(percentage).addToSVGTransform(m_fromTransform);
     transformList->appendItem(transform, ec);
 }
 
 bool SVGAnimateTransformElement::calculateFromAndToValues(const String &fromString, const String &toString)
 {
     m_fromTransform = parseTransformValue(fromString);
     if (!m_fromTransform.isValid()) {
         return false;
     }
     m_toTransform = parseTransformValue(toString);
     return m_toTransform.isValid();
 }
 
 bool SVGAnimateTransformElement::calculateFromAndByValues(const String &fromString, const String &byString)
 {
 
     m_fromTransform = parseTransformValue(fromString);
     if (!m_fromTransform.isValid()) {
         return false;
     }
     m_toTransform = SVGTransformDistance::addSVGTransforms(m_fromTransform, parseTransformValue(byString));
     return m_toTransform.isValid();
 }
 
 SVGTransform SVGAnimateTransformElement::parseTransformValue(const String &value) const
 {
     if (value.isEmpty()) {
         return SVGTransform(m_type);
     }
     SVGTransform result;
     // FIXME: This is pretty dumb but parseTransformValue() wants those parenthesis.
     String parseString("(" + value + ")");
     const UChar *ptr = parseString.characters();
     SVGTransformable::parseTransformValue(m_type, ptr, ptr + parseString.length(), result); // ignoring return value
     return result;
 }
 
 void SVGAnimateTransformElement::applyResultsToTarget()
 {
     if (!hasValidTarget()) {
         return;
     }
     // We accumulate to the target element transform list so there is not much to do here.
     SVGElement *targetElement = this->targetElement();
     if (targetElement->renderer()) {
         targetElement->renderer()->setNeedsLayout(true);
     }
 
     // ...except in case where we have additional instances in <use> trees.
     HashSet<SVGElementInstance *> *instances = document()->accessSVGExtensions()->instancesForElement(targetElement);
     if (!instances) {
         return;
     }
     RefPtr<SVGTransformList> transformList = transformListFor(targetElement);
     HashSet<SVGElementInstance *>::iterator end = instances->end();
     for (HashSet<SVGElementInstance *>::iterator it = instances->begin(); it != end; ++it) {
         SVGElement *shadowTreeElement = (*it)->shadowTreeElement();
         ASSERT(shadowTreeElement);
         if (shadowTreeElement->isStyledTransformable()) {
             static_cast<SVGStyledTransformableElement *>(shadowTreeElement)->setTransform(transformList.get());
         } else if (shadowTreeElement->hasTagName(SVGNames::textTag)) {
             static_cast<SVGTextElement *>(shadowTreeElement)->setTransform(transformList.get());
         }
         if (shadowTreeElement->renderer()) {
             shadowTreeElement->renderer()->setNeedsLayout(true);
         }
     }
 }
 
 float SVGAnimateTransformElement::calculateDistance(const String &fromString, const String &toString)
 {
     // FIXME: This is not correct in all cases. The spec demands that each component (translate x and y for example)
     // is paced separately. To implement this we need to treat each component as individual animation everywhere.
     SVGTransform from = parseTransformValue(fromString);
     if (!from.isValid()) {
         return -1.f;
     }
     SVGTransform to = parseTransformValue(toString);
     if (!to.isValid() || from.type() != to.type()) {
         return -1.f;
     }
     if (to.type() == SVGTransform::SVG_TRANSFORM_TRANSLATE) {
         FloatSize diff = to.translate() - from.translate();
         return sqrtf(diff.width() * diff.width() + diff.height() * diff.height());
     }
     if (to.type() == SVGTransform::SVG_TRANSFORM_ROTATE) {
         return fabsf(to.angle() - from.angle());
     }
     if (to.type() == SVGTransform::SVG_TRANSFORM_SCALE) {
         FloatSize diff = to.scale() - from.scale();
         return sqrtf(diff.width() * diff.width() + diff.height() * diff.height());
     }
     return -1.f;
 }
 
 }
 
 #endif // ENABLE(SVG)