Source/WebCore/svg/SVGTransformable.cpp

   1 /*
   2  * Copyright (C) 2004, 2005, 2008 Nikolas Zimmermann <zimmermann@kde.org>
   3  * Copyright (C) 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
   4  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
   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 #include "SVGTransformable.h"
  24
  25 #include "AffineTransform.h"
  26 #include "FloatConversion.h"
  27 #include "SVGElement.h"
  28 #include "SVGNames.h"
  29 #include "SVGParserUtilities.h"
  30 #include "SVGTransformList.h"
  31 #include <wtf/text/StringView.h>
  32
  33 namespace WebCore {
  34
  35 static int parseTransformParamList(const UChar*& ptr, const UChar* end, float* values, int required, int optional)
  36 {
  37     int optionalParams = 0, requiredParams = 0;
  38
  39     if (!skipOptionalSVGSpaces(ptr, end) || *ptr != '(')
  40         return -1;
  41
  42     ptr++;
  43
  44     skipOptionalSVGSpaces(ptr, end);
  45
  46     while (requiredParams < required) {
  47         if (ptr >= end || !parseNumber(ptr, end, values[requiredParams], false))
  48             return -1;
  49         requiredParams++;
  50         if (requiredParams < required)
  51             skipOptionalSVGSpacesOrDelimiter(ptr, end);
  52     }
  53     if (!skipOptionalSVGSpaces(ptr, end))
  54         return -1;
  55
  56     bool delimParsed = skipOptionalSVGSpacesOrDelimiter(ptr, end);
  57
  58     if (ptr >= end)
  59         return -1;
  60
  61     if (*ptr == ')') { // skip optionals
  62         ptr++;
  63         if (delimParsed)
  64             return -1;
  65     } else {
  66         while (optionalParams < optional) {
  67             if (ptr >= end || !parseNumber(ptr, end, values[requiredParams + optionalParams], false))
  68                 return -1;
  69             optionalParams++;
  70             if (optionalParams < optional)
  71                 skipOptionalSVGSpacesOrDelimiter(ptr, end);
  72         }
  73
  74         if (!skipOptionalSVGSpaces(ptr, end))
  75             return -1;
  76
  77         delimParsed = skipOptionalSVGSpacesOrDelimiter(ptr, end);
  78
  79         if (ptr >= end || *ptr != ')' || delimParsed)
  80             return -1;
  81         ptr++;
  82     }
  83
  84     return requiredParams + optionalParams;
  85 }
  86
  87 // These should be kept in sync with enum SVGTransformType
  88 static const int requiredValuesForType[] =  {0, 6, 1, 1, 1, 1, 1};
  89 static const int optionalValuesForType[] =  {0, 0, 1, 1, 2, 0, 0};
  90
  91 // This destructor is needed in order to link correctly with Intel ICC.
  92 SVGTransformable::~SVGTransformable()
  93 {
  94 }
  95
  96 bool SVGTransformable::parseTransformValue(SVGTransform::SVGTransformType type, const UChar*& ptr, const UChar* end, SVGTransform& transform)
  97 {
  98     if (type == SVGTransform::SVG_TRANSFORM_UNKNOWN)
  99         return false;
 100
 101     int valueCount = 0;
 102     float values[] = {0, 0, 0, 0, 0, 0};
 103     if ((valueCount = parseTransformParamList(ptr, end, values, requiredValuesForType[type], optionalValuesForType[type])) < 0)
 104         return false;
 105
 106     switch (type) {
 107     case SVGTransform::SVG_TRANSFORM_UNKNOWN:
 108         ASSERT_NOT_REACHED();
 109         break;
 110     case SVGTransform::SVG_TRANSFORM_SKEWX:
 111         transform.setSkewX(values[0]);
 112         break;
 113     case SVGTransform::SVG_TRANSFORM_SKEWY:
 114         transform.setSkewY(values[0]);
 115         break;
 116     case SVGTransform::SVG_TRANSFORM_SCALE:
 117         if (valueCount == 1) // Spec: if only one param given, assume uniform scaling
 118             transform.setScale(values[0], values[0]);
 119         else
 120             transform.setScale(values[0], values[1]);
 121         break;
 122     case SVGTransform::SVG_TRANSFORM_TRANSLATE:
 123         if (valueCount == 1) // Spec: if only one param given, assume 2nd param to be 0
 124             transform.setTranslate(values[0], 0);
 125         else
 126             transform.setTranslate(values[0], values[1]);
 127         break;
 128     case SVGTransform::SVG_TRANSFORM_ROTATE:
 129         if (valueCount == 1)
 130             transform.setRotate(values[0], 0, 0);
 131         else
 132             transform.setRotate(values[0], values[1], values[2]);
 133         break;
 134     case SVGTransform::SVG_TRANSFORM_MATRIX:
 135         transform.setMatrix(AffineTransform(values[0], values[1], values[2], values[3], values[4], values[5]));
 136         break;
 137     }
 138
 139     return true;
 140 }
 141
 142 static const UChar skewXDesc[] =  {'s', 'k', 'e', 'w', 'X'};
 143 static const UChar skewYDesc[] =  {'s', 'k', 'e', 'w', 'Y'};
 144 static const UChar scaleDesc[] =  {'s', 'c', 'a', 'l', 'e'};
 145 static const UChar translateDesc[] =  {'t', 'r', 'a', 'n', 's', 'l', 'a', 't', 'e'};
 146 static const UChar rotateDesc[] =  {'r', 'o', 't', 'a', 't', 'e'};
 147 static const UChar matrixDesc[] =  {'m', 'a', 't', 'r', 'i', 'x'};
 148
 149 static inline bool parseAndSkipType(const UChar*& currTransform, const UChar* end, SVGTransform::SVGTransformType& type)
 150 {
 151     if (currTransform >= end)
 152         return false;
 153
 154     if (*currTransform == 's') {
 155         if (skipString(currTransform, end, skewXDesc, WTF_ARRAY_LENGTH(skewXDesc)))
 156             type = SVGTransform::SVG_TRANSFORM_SKEWX;
 157         else if (skipString(currTransform, end, skewYDesc, WTF_ARRAY_LENGTH(skewYDesc)))
 158             type = SVGTransform::SVG_TRANSFORM_SKEWY;
 159         else if (skipString(currTransform, end, scaleDesc, WTF_ARRAY_LENGTH(scaleDesc)))
 160             type = SVGTransform::SVG_TRANSFORM_SCALE;
 161         else
 162             return false;
 163     } else if (skipString(currTransform, end, translateDesc, WTF_ARRAY_LENGTH(translateDesc)))
 164         type = SVGTransform::SVG_TRANSFORM_TRANSLATE;
 165     else if (skipString(currTransform, end, rotateDesc, WTF_ARRAY_LENGTH(rotateDesc)))
 166         type = SVGTransform::SVG_TRANSFORM_ROTATE;
 167     else if (skipString(currTransform, end, matrixDesc, WTF_ARRAY_LENGTH(matrixDesc)))
 168         type = SVGTransform::SVG_TRANSFORM_MATRIX;
 169     else
 170         return false;
 171
 172     return true;
 173 }
 174
 175 SVGTransform::SVGTransformType SVGTransformable::parseTransformType(const String& typeString)
 176 {
 177     SVGTransform::SVGTransformType type = SVGTransform::SVG_TRANSFORM_UNKNOWN;
 178     auto upconvertedCharacters = StringView(typeString).upconvertedCharacters();
 179     const UChar* characters = upconvertedCharacters;
 180     parseAndSkipType(characters, characters + typeString.length(), type);
 181     return static_cast<SVGTransform::SVGTransformType>(type);
 182 }
 183
 184 bool SVGTransformable::parseTransformAttribute(SVGTransformList& list, const UChar*& currTransform, const UChar* end, TransformParsingMode mode)
 185 {
 186     if (mode == ClearList)
 187         list.clear();
 188
 189     bool delimParsed = false;
 190     while (currTransform < end) {
 191         delimParsed = false;
 192         SVGTransform::SVGTransformType type = SVGTransform::SVG_TRANSFORM_UNKNOWN;
 193         skipOptionalSVGSpaces(currTransform, end);
 194
 195         if (!parseAndSkipType(currTransform, end, type))
 196             return false;
 197
 198         SVGTransform transform;
 199         if (!parseTransformValue(type, currTransform, end, transform))
 200             return false;
 201
 202         list.append(transform);
 203         skipOptionalSVGSpaces(currTransform, end);
 204         if (currTransform < end && *currTransform == ',') {
 205             delimParsed = true;
 206             ++currTransform;
 207         }
 208         skipOptionalSVGSpaces(currTransform, end);
 209     }
 210
 211     return !delimParsed;
 212 }
 213
 214 }