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

 /*
     Copyright (C) 2004, 2005 Nikolas Zimmermann <wildfox@kde.org>
                   2004, 2005, 2006 Rob Buis <buis@kde.org>
     Copyright (C) 2008 Apple Inc. All rights reserved.
 
     This file is part of the KDE 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 "SVGAnimateElement.h"
 
 #include "ColorDistance.h"
 #include "FloatConversion.h"
 #include "SVGColor.h"
 #include "SVGParserUtilities.h"
 #include <math.h>
 
 using namespace std;
 
 namespace WebCore
 {
 
 SVGAnimateElement::SVGAnimateElement(const QualifiedName &tagName, Document *doc)
     : SVGAnimationElement(tagName, doc)
     , m_propertyType(StringProperty)
     , m_fromNumber(0)
     , m_toNumber(0)
     , m_animatedNumber(numeric_limits<double>::infinity())
 {
 }
 
 SVGAnimateElement::~SVGAnimateElement()
 {
 }
 
 static bool parseNumberValueAndUnit(const String &in, double &value, String &unit)
 {
     // FIXME: These are from top of my head, figure out all property types that can be animated as numbers.
     unsigned unitLength = 0;
     String parse = in.stripWhiteSpace();
     if (parse.endsWith("%")) {
         unitLength = 1;
     } else if (parse.endsWith("px") || parse.endsWith("pt") || parse.endsWith("em")) {
         unitLength = 2;
     } else if (parse.endsWith("deg") || parse.endsWith("rad")) {
         unitLength = 3;
     } else if (parse.endsWith("grad")) {
         unitLength = 4;
     }
     String newUnit = parse.right(unitLength);
     String number = parse.left(parse.length() - unitLength);
     if (!unit.isEmpty() && newUnit != unit || number.isEmpty()) {
         return false;
     }
     UChar last = number[number.length() - 1];
     if (last < '0' || last > '9') {
         return false;
     }
     unit = newUnit;
     bool ok;
     value = number.toDouble(&ok);
     return ok;
 }
 
 SVGAnimateElement::PropertyType SVGAnimateElement::determinePropertyType(const String &attribute) const
 {
     // FIXME: We need a full property table for figuring this out reliably.
     if (hasTagName(SVGNames::animateColorTag)) {
         return ColorProperty;
     }
     if (attribute == "color" || attribute == "fill" || attribute == "stroke") {
         return ColorProperty;
     }
     return NumberProperty;
 }
 
 void SVGAnimateElement::calculateAnimatedValue(float percentage, unsigned repeat, SVGSMILElement *resultElement)
 {
     ASSERT(percentage >= 0.f && percentage <= 1.f);
     ASSERT(resultElement);
     if (hasTagName(SVGNames::setTag)) {
         percentage = 1.f;
     }
     if (!resultElement->hasTagName(SVGNames::animateTag) && !resultElement->hasTagName(SVGNames::animateColorTag)
             && !resultElement->hasTagName(SVGNames::setTag)) {
         return;
     }
     SVGAnimateElement *results = static_cast<SVGAnimateElement *>(resultElement);
     // Can't accumulate over a string property.
     if (results->m_propertyType == StringProperty && m_propertyType != StringProperty) {
         return;
     }
     if (m_propertyType == NumberProperty) {
         // To animation uses contributions from the lower priority animations as the base value.
         if (animationMode() == ToAnimation) {
             m_fromNumber = results->m_animatedNumber;
         }
 
         double number = (m_toNumber - m_fromNumber) * percentage + m_fromNumber;
 
         // FIXME: This is not correct for values animation.
         if (isAccumulated() && repeat) {
             number += m_toNumber * repeat;
         }
         if (isAdditive() && animationMode() != ToAnimation) {
             results->m_animatedNumber += number;
         } else {
             results->m_animatedNumber = number;
         }
         return;
     }
     if (m_propertyType == ColorProperty) {
         if (animationMode() == ToAnimation) {
             m_fromColor = results->m_animatedColor;
         }
         Color color = ColorDistance(m_fromColor, m_toColor).scaledDistance(percentage).addToColorAndClamp(m_fromColor);
         // FIXME: Accumulate colors.
         if (isAdditive() && animationMode() != ToAnimation) {
             results->m_animatedColor = ColorDistance::addColorsAndClamp(results->m_animatedColor, color);
         } else {
             results->m_animatedColor = color;
         }
         return;
     }
     AnimationMode animationMode = this->animationMode();
     ASSERT(animationMode == FromToAnimation || animationMode == ToAnimation || animationMode == ValuesAnimation);
     if ((animationMode == FromToAnimation && percentage > 0.5f) || animationMode == ToAnimation || percentage == 1.0f) {
         results->m_animatedString = m_toString;
     } else {
         results->m_animatedString = m_fromString;
     }
     // Higher priority replace animation overrides any additive results so far.
     results->m_propertyType = StringProperty;
 }
 
 bool SVGAnimateElement::calculateFromAndToValues(const String &fromString, const String &toString)
 {
     // FIXME: Needs more solid way determine target attribute type.
     m_propertyType = determinePropertyType(attributeName());
     if (m_propertyType == ColorProperty) {
         m_fromColor = SVGColor::colorFromRGBColorString(fromString);
         m_toColor = SVGColor::colorFromRGBColorString(toString);
         if (m_fromColor.isValid() && m_toColor.isValid()) {
             return true;
         }
     } else if (m_propertyType == NumberProperty) {
         m_numberUnit = String();
         if (parseNumberValueAndUnit(toString, m_toNumber, m_numberUnit)) {
             // For to-animations the from number is calculated later
             if (animationMode() == ToAnimation || parseNumberValueAndUnit(fromString, m_fromNumber, m_numberUnit)) {
                 return true;
             }
         }
     }
     m_fromString = fromString;
     m_toString = toString;
     m_propertyType = StringProperty;
     return true;
 }
 
 bool SVGAnimateElement::calculateFromAndByValues(const String &fromString, const String &byString)
 {
     ASSERT(!hasTagName(SVGNames::setTag));
     m_propertyType = determinePropertyType(attributeName());
     if (m_propertyType == ColorProperty) {
         m_fromColor = fromString.isEmpty() ? Color() : SVGColor::colorFromRGBColorString(fromString);
         m_toColor = ColorDistance::addColorsAndClamp(m_fromColor, SVGColor::colorFromRGBColorString(byString));
         if (!m_fromColor.isValid() || !m_toColor.isValid()) {
             return false;
         }
     } else {
         m_numberUnit = String();
         m_fromNumber = 0;
         if (!fromString.isEmpty() && !parseNumberValueAndUnit(fromString, m_fromNumber, m_numberUnit)) {
             return false;
         }
         if (!parseNumberValueAndUnit(byString, m_toNumber, m_numberUnit)) {
             return false;
         }
         m_toNumber += m_fromNumber;
     }
     return true;
 }
 
 void SVGAnimateElement::resetToBaseValue(const String &baseString)
 {
     m_animatedString = baseString;
     m_propertyType = determinePropertyType(attributeName());
     if (m_propertyType == ColorProperty) {
         m_animatedColor = baseString.isEmpty() ? Color() : SVGColor::colorFromRGBColorString(baseString);
         if (m_animatedColor.isValid()) {
             return;
         }
     } else if (m_propertyType == NumberProperty) {
         if (baseString.isEmpty()) {
             m_animatedNumber = 0;
             m_numberUnit = String();
             return;
         }
         if (parseNumberValueAndUnit(baseString, m_animatedNumber, m_numberUnit)) {
             return;
         }
     }
     m_propertyType = StringProperty;
 }
 
 void SVGAnimateElement::applyResultsToTarget()
 {
     String valueToApply;
     if (m_propertyType == ColorProperty) {
         valueToApply = m_animatedColor.name();
     } else if (m_propertyType == NumberProperty) {
         valueToApply = String::number(m_animatedNumber) + m_numberUnit;
     } else {
         valueToApply = m_animatedString;
     }
 
     setTargetAttributeAnimatedValue(valueToApply);
 }
 
 float SVGAnimateElement::calculateDistance(const String &fromString, const String &toString)
 {
     m_propertyType = determinePropertyType(attributeName());
     if (m_propertyType == NumberProperty) {
         double from;
         double to;
         String unit;
         if (!parseNumberValueAndUnit(fromString, from, unit)) {
             return -1.f;
         }
         if (!parseNumberValueAndUnit(toString, to, unit)) {
             return -1.f;
         }
         return narrowPrecisionToFloat(fabs(to - from));
     } else if (m_propertyType == ColorProperty) {
         Color from = SVGColor::colorFromRGBColorString(fromString);
         if (!from.isValid()) {
             return -1.f;
         }
         Color to = SVGColor::colorFromRGBColorString(toString);
         if (!to.isValid()) {
             return -1.f;
         }
         return ColorDistance(from, to).distance();
     }
     return -1.f;
 }
 
 }
 
 #endif // ENABLE(SVG)