third_party/WebKit/Source/core/svg/SVGLength.cpp

   1 /*
   2  * Copyright (C) 2004, 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
   3  * Copyright (C) 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
   4  * Copyright (C) 2007 Apple Inc. All rights reserved.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public License
  17  * along with this library; see the file COPYING.LIB.  If not, write to
  18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  */
  21
  22 #include "config.h"
  23
  24 #include "core/svg/SVGLength.h"
  25
  26 #include "bindings/core/v8/ExceptionState.h"
  27 #include "core/SVGNames.h"
  28 #include "core/css/CSSPrimitiveValue.h"
  29 #include "core/dom/ExceptionCode.h"
  30 #include "core/svg/SVGAnimationElement.h"
  31 #include "core/svg/SVGParserUtilities.h"
  32 #include "platform/animation/AnimationUtilities.h"
  33 #include "wtf/MathExtras.h"
  34 #include "wtf/text/WTFString.h"
  35
  36 namespace blink {
  37
  38 namespace {
  39
  40 inline const char* lengthTypeToString(SVGLengthType type)
  41 {
  42     switch (type) {
  43     case LengthTypeUnknown:
  44     case LengthTypeNumber:
  45         return "";
  46     case LengthTypePercentage:
  47         return "%";
  48     case LengthTypeEMS:
  49         return "em";
  50     case LengthTypeEXS:
  51         return "ex";
  52     case LengthTypePX:
  53         return "px";
  54     case LengthTypeCM:
  55         return "cm";
  56     case LengthTypeMM:
  57         return "mm";
  58     case LengthTypeIN:
  59         return "in";
  60     case LengthTypePT:
  61         return "pt";
  62     case LengthTypePC:
  63         return "pc";
  64     case LengthTypeREMS:
  65         return "rem";
  66     case LengthTypeCHS:
  67         return "ch";
  68     }
  69
  70     ASSERT_NOT_REACHED();
  71     return "";
  72 }
  73
  74 template<typename CharType>
  75 SVGLengthType stringToLengthType(const CharType*& ptr, const CharType* end)
  76 {
  77     if (ptr == end)
  78         return LengthTypeNumber;
  79
  80     SVGLengthType type = LengthTypeUnknown;
  81     const CharType firstChar = *ptr++;
  82
  83     if (firstChar == '%') {
  84         type = LengthTypePercentage;
  85     } else if (isHTMLSpace<CharType>(firstChar)) {
  86         type = LengthTypeNumber;
  87     } else if (ptr < end) {
  88         const CharType secondChar = *ptr++;
  89
  90         if (firstChar == 'p') {
  91             if (secondChar == 'x')
  92                 type = LengthTypePX;
  93             if (secondChar == 't')
  94                 type = LengthTypePT;
  95             if (secondChar == 'c')
  96                 type = LengthTypePC;
  97         } else if (firstChar == 'e') {
  98             if (secondChar == 'm')
  99                 type = LengthTypeEMS;
 100             if (secondChar == 'x')
 101                 type = LengthTypeEXS;
 102         } else if (firstChar == 'r') {
 103             if (secondChar == 'e' && ptr < end) {
 104                 const CharType thirdChar = *ptr++;
 105                 if (thirdChar == 'm')
 106                     type = LengthTypeREMS;
 107             }
 108         } else if (firstChar == 'c') {
 109             if (secondChar == 'h')
 110                 type = LengthTypeCHS;
 111             if (secondChar == 'm')
 112                 type = LengthTypeCM;
 113         } else if (firstChar == 'm' && secondChar == 'm') {
 114             type = LengthTypeMM;
 115         } else if (firstChar == 'i' && secondChar == 'n') {
 116             type = LengthTypeIN;
 117         } else if (isHTMLSpace<CharType>(firstChar) && isHTMLSpace<CharType>(secondChar)) {
 118             type = LengthTypeNumber;
 119         }
 120     }
 121
 122     if (!skipOptionalSVGSpaces(ptr, end))
 123         return type;
 124
 125     return LengthTypeUnknown;
 126 }
 127
 128 } // namespace
 129
 130 SVGLength::SVGLength(SVGLengthMode mode)
 131     : SVGPropertyBase(classType())
 132     , m_valueInSpecifiedUnits(0)
 133     , m_unitMode(static_cast<unsigned>(mode))
 134     , m_unitType(LengthTypeNumber)
 135 {
 136     ASSERT(unitMode() == mode);
 137 }
 138
 139 SVGLength::SVGLength(const SVGLength& o)
 140     : SVGPropertyBase(classType())
 141     , m_valueInSpecifiedUnits(o.m_valueInSpecifiedUnits)
 142     , m_unitMode(o.m_unitMode)
 143     , m_unitType(o.m_unitType)
 144 {
 145 }
 146
 147 PassRefPtrWillBeRawPtr<SVGLength> SVGLength::clone() const
 148 {
 149     return adoptRefWillBeNoop(new SVGLength(*this));
 150 }
 151
 152 PassRefPtrWillBeRawPtr<SVGPropertyBase> SVGLength::cloneForAnimation(const String& value) const
 153 {
 154     RefPtrWillBeRawPtr<SVGLength> length = create();
 155
 156     length->m_unitMode = m_unitMode;
 157     length->m_unitType = m_unitType;
 158
 159     TrackExceptionState exceptionState;
 160     length->setValueAsString(value, exceptionState);
 161     if (exceptionState.hadException()) {
 162         length->m_unitType = LengthTypeNumber;
 163         length->m_valueInSpecifiedUnits = 0;
 164     }
 165
 166     return length.release();
 167 }
 168
 169 bool SVGLength::operator==(const SVGLength& other) const
 170 {
 171     return m_unitMode == other.m_unitMode
 172         && m_unitType == other.m_unitType
 173         && m_valueInSpecifiedUnits == other.m_valueInSpecifiedUnits;
 174 }
 175
 176 float SVGLength::value(const SVGLengthContext& context) const
 177 {
 178     return context.convertValueToUserUnits(m_valueInSpecifiedUnits, unitMode(), unitType());
 179 }
 180
 181 void SVGLength::setValue(float value, const SVGLengthContext& context)
 182 {
 183     m_valueInSpecifiedUnits = context.convertValueFromUserUnits(value, unitMode(), unitType());
 184 }
 185
 186 void SVGLength::setUnitType(SVGLengthType type)
 187 {
 188     ASSERT(type != LengthTypeUnknown && type <= LengthTypeCHS);
 189     m_unitType = type;
 190 }
 191
 192 float SVGLength::valueAsPercentage() const
 193 {
 194     // LengthTypePercentage is represented with 100% = 100.0. Good for accuracy but could eventually be changed.
 195     if (m_unitType == LengthTypePercentage) {
 196         // Note: This division is a source of floating point inaccuracy.
 197         return m_valueInSpecifiedUnits / 100;
 198     }
 199
 200     return m_valueInSpecifiedUnits;
 201 }
 202
 203 float SVGLength::valueAsPercentage100() const
 204 {
 205     // LengthTypePercentage is represented with 100% = 100.0. Good for accuracy but could eventually be changed.
 206     if (m_unitType == LengthTypePercentage)
 207         return m_valueInSpecifiedUnits;
 208
 209     return m_valueInSpecifiedUnits * 100;
 210 }
 211
 212 float SVGLength::scaleByPercentage(float input) const
 213 {
 214     float result = input * m_valueInSpecifiedUnits;
 215     if (m_unitType == LengthTypePercentage) {
 216         // Delaying division by 100 as long as possible since it introduces floating point errors.
 217         result = result / 100;
 218     }
 219     return result;
 220 }
 221
 222 template<typename CharType>
 223 static bool parseValueInternal(const String& string, float& convertedNumber, SVGLengthType& type)
 224 {
 225     const CharType* ptr = string.getCharacters<CharType>();
 226     const CharType* end = ptr + string.length();
 227
 228     if (!parseNumber(ptr, end, convertedNumber, AllowLeadingWhitespace))
 229         return false;
 230
 231     type = stringToLengthType(ptr, end);
 232     ASSERT(ptr <= end);
 233     if (type == LengthTypeUnknown)
 234         return false;
 235
 236     return true;
 237 }
 238
 239 void SVGLength::setValueAsString(const String& string, ExceptionState& exceptionState)
 240 {
 241     if (string.isEmpty()) {
 242         m_unitType = LengthTypeNumber;
 243         m_valueInSpecifiedUnits = 0;
 244         return;
 245     }
 246
 247     float convertedNumber = 0;
 248     SVGLengthType type = LengthTypeUnknown;
 249
 250     bool success = string.is8Bit() ?
 251         parseValueInternal<LChar>(string, convertedNumber, type) :
 252         parseValueInternal<UChar>(string, convertedNumber, type);
 253
 254     if (!success) {
 255         exceptionState.throwDOMException(SyntaxError, "The value provided ('" + string + "') is invalid.");
 256         return;
 257     }
 258
 259     m_unitType = type;
 260     m_valueInSpecifiedUnits = convertedNumber;
 261 }
 262
 263 String SVGLength::valueAsString() const
 264 {
 265     return String::number(m_valueInSpecifiedUnits) + lengthTypeToString(unitType());
 266 }
 267
 268 void SVGLength::newValueSpecifiedUnits(SVGLengthType type, float value)
 269 {
 270     setUnitType(type);
 271     m_valueInSpecifiedUnits = value;
 272 }
 273
 274 void SVGLength::convertToSpecifiedUnits(SVGLengthType type, const SVGLengthContext& context)
 275 {
 276     ASSERT(type != LengthTypeUnknown && type <= LengthTypeCHS);
 277
 278     float valueInUserUnits = value(context);
 279     m_unitType = type;
 280     setValue(valueInUserUnits, context);
 281 }
 282
 283 SVGLengthMode SVGLength::lengthModeForAnimatedLengthAttribute(const QualifiedName& attrName)
 284 {
 285     typedef HashMap<QualifiedName, SVGLengthMode> LengthModeForLengthAttributeMap;
 286     DEFINE_STATIC_LOCAL(LengthModeForLengthAttributeMap, s_lengthModeMap, ());
 287
 288     if (s_lengthModeMap.isEmpty()) {
 289         s_lengthModeMap.set(SVGNames::xAttr, SVGLengthMode::Width);
 290         s_lengthModeMap.set(SVGNames::yAttr, SVGLengthMode::Height);
 291         s_lengthModeMap.set(SVGNames::cxAttr, SVGLengthMode::Width);
 292         s_lengthModeMap.set(SVGNames::cyAttr, SVGLengthMode::Height);
 293         s_lengthModeMap.set(SVGNames::dxAttr, SVGLengthMode::Width);
 294         s_lengthModeMap.set(SVGNames::dyAttr, SVGLengthMode::Height);
 295         s_lengthModeMap.set(SVGNames::fxAttr, SVGLengthMode::Width);
 296         s_lengthModeMap.set(SVGNames::fyAttr, SVGLengthMode::Height);
 297         s_lengthModeMap.set(SVGNames::rAttr, SVGLengthMode::Other);
 298         s_lengthModeMap.set(SVGNames::rxAttr, SVGLengthMode::Width);
 299         s_lengthModeMap.set(SVGNames::ryAttr, SVGLengthMode::Height);
 300         s_lengthModeMap.set(SVGNames::widthAttr, SVGLengthMode::Width);
 301         s_lengthModeMap.set(SVGNames::heightAttr, SVGLengthMode::Height);
 302         s_lengthModeMap.set(SVGNames::x1Attr, SVGLengthMode::Width);
 303         s_lengthModeMap.set(SVGNames::x2Attr, SVGLengthMode::Width);
 304         s_lengthModeMap.set(SVGNames::y1Attr, SVGLengthMode::Height);
 305         s_lengthModeMap.set(SVGNames::y2Attr, SVGLengthMode::Height);
 306         s_lengthModeMap.set(SVGNames::refXAttr, SVGLengthMode::Width);
 307         s_lengthModeMap.set(SVGNames::refYAttr, SVGLengthMode::Height);
 308         s_lengthModeMap.set(SVGNames::markerWidthAttr, SVGLengthMode::Width);
 309         s_lengthModeMap.set(SVGNames::markerHeightAttr, SVGLengthMode::Height);
 310         s_lengthModeMap.set(SVGNames::textLengthAttr, SVGLengthMode::Width);
 311         s_lengthModeMap.set(SVGNames::startOffsetAttr, SVGLengthMode::Width);
 312     }
 313
 314     if (s_lengthModeMap.contains(attrName))
 315         return s_lengthModeMap.get(attrName);
 316
 317     return SVGLengthMode::Other;
 318 }
 319
 320 PassRefPtrWillBeRawPtr<SVGLength> SVGLength::blend(PassRefPtrWillBeRawPtr<SVGLength> passFrom, float progress) const
 321 {
 322     RefPtrWillBeRawPtr<SVGLength> from = passFrom;
 323
 324     SVGLengthType toType = unitType();
 325     SVGLengthType fromType = from->unitType();
 326     if ((from->isZero() && isZero())
 327         || fromType == LengthTypeUnknown
 328         || toType == LengthTypeUnknown
 329         || (!from->isZero() && fromType != LengthTypePercentage && toType == LengthTypePercentage)
 330         || (!isZero() && fromType == LengthTypePercentage && toType != LengthTypePercentage)
 331         || (!from->isZero() && !isZero() && (fromType == LengthTypeEMS || fromType == LengthTypeEXS || fromType == LengthTypeREMS || fromType == LengthTypeCHS) && fromType != toType))
 332         return clone();
 333
 334     RefPtrWillBeRawPtr<SVGLength> length = create();
 335
 336     if (fromType == LengthTypePercentage || toType == LengthTypePercentage) {
 337         float fromPercent = from->valueAsPercentage100();
 338         float toPercent = valueAsPercentage100();
 339         length->newValueSpecifiedUnits(LengthTypePercentage, blink::blend(fromPercent, toPercent, progress));
 340         return length;
 341     }
 342
 343     if (fromType == toType || from->isZero() || isZero() || fromType == LengthTypeEMS || fromType == LengthTypeEXS || fromType == LengthTypeREMS || fromType == LengthTypeCHS) {
 344         float fromValue = from->valueInSpecifiedUnits();
 345         float toValue = valueInSpecifiedUnits();
 346         if (isZero())
 347             length->newValueSpecifiedUnits(fromType, blink::blend(fromValue, toValue, progress));
 348         else
 349             length->newValueSpecifiedUnits(toType, blink::blend(fromValue, toValue, progress));
 350         return length;
 351     }
 352
 353     ASSERT(!isRelative());
 354     ASSERT(!from->isRelative());
 355
 356     SVGLengthContext nonRelativeLengthContext(0);
 357     float fromValueInUserUnits = nonRelativeLengthContext.convertValueToUserUnits(from->valueInSpecifiedUnits(), from->unitMode(), fromType);
 358     float fromValue = nonRelativeLengthContext.convertValueFromUserUnits(fromValueInUserUnits, unitMode(), toType);
 359
 360     float toValue = valueInSpecifiedUnits();
 361     length->newValueSpecifiedUnits(toType, blink::blend(fromValue, toValue, progress));
 362     return length;
 363 }
 364
 365 void SVGLength::add(PassRefPtrWillBeRawPtr<SVGPropertyBase> other, SVGElement* contextElement)
 366 {
 367     SVGLengthContext lengthContext(contextElement);
 368     setValue(value(lengthContext) + toSVGLength(other)->value(lengthContext), lengthContext);
 369 }
 370
 371 void SVGLength::calculateAnimatedValue(SVGAnimationElement* animationElement, float percentage, unsigned repeatCount, PassRefPtrWillBeRawPtr<SVGPropertyBase> fromValue, PassRefPtrWillBeRawPtr<SVGPropertyBase> toValue, PassRefPtrWillBeRawPtr<SVGPropertyBase> toAtEndOfDurationValue, SVGElement* contextElement)
 372 {
 373     RefPtrWillBeRawPtr<SVGLength> fromLength = toSVGLength(fromValue);
 374     RefPtrWillBeRawPtr<SVGLength> toLength = toSVGLength(toValue);
 375     RefPtrWillBeRawPtr<SVGLength> toAtEndOfDurationLength = toSVGLength(toAtEndOfDurationValue);
 376
 377     SVGLengthContext lengthContext(contextElement);
 378     float animatedNumber = value(lengthContext);
 379     animationElement->animateAdditiveNumber(percentage, repeatCount, fromLength->value(lengthContext), toLength->value(lengthContext), toAtEndOfDurationLength->value(lengthContext), animatedNumber);
 380
 381     ASSERT(unitMode() == lengthModeForAnimatedLengthAttribute(animationElement->attributeName()));
 382     m_unitType = percentage < 0.5 ? fromLength->unitType() : toLength->unitType();
 383     setValue(animatedNumber, lengthContext);
 384 }
 385
 386 float SVGLength::calculateDistance(PassRefPtrWillBeRawPtr<SVGPropertyBase> toValue, SVGElement* contextElement)
 387 {
 388     SVGLengthContext lengthContext(contextElement);
 389     RefPtrWillBeRawPtr<SVGLength> toLength = toSVGLength(toValue);
 390
 391     return fabsf(toLength->value(lengthContext) - value(lengthContext));
 392 }
 393
 394 }