Use #pragma once in WebCore
[WebKit-https.git] / 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 }