Reduce use of deprecatedCharacters 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(unsigned 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_SKEWX:
108         transform.setSkewX(values[0]);
109         break;
110     case SVGTransform::SVG_TRANSFORM_SKEWY:
111         transform.setSkewY(values[0]);
112         break;
113     case SVGTransform::SVG_TRANSFORM_SCALE:
114         if (valueCount == 1) // Spec: if only one param given, assume uniform scaling
115             transform.setScale(values[0], values[0]);
116         else
117             transform.setScale(values[0], values[1]);
118         break;
119     case SVGTransform::SVG_TRANSFORM_TRANSLATE:
120         if (valueCount == 1) // Spec: if only one param given, assume 2nd param to be 0
121             transform.setTranslate(values[0], 0);
122         else
123             transform.setTranslate(values[0], values[1]);
124         break;
125     case SVGTransform::SVG_TRANSFORM_ROTATE:
126         if (valueCount == 1)
127             transform.setRotate(values[0], 0, 0);
128         else
129             transform.setRotate(values[0], values[1], values[2]);
130         break;
131     case SVGTransform::SVG_TRANSFORM_MATRIX:
132         transform.setMatrix(AffineTransform(values[0], values[1], values[2], values[3], values[4], values[5]));
133         break;
134     }
135
136     return true;
137 }
138
139 static const UChar skewXDesc[] =  {'s', 'k', 'e', 'w', 'X'};
140 static const UChar skewYDesc[] =  {'s', 'k', 'e', 'w', 'Y'};
141 static const UChar scaleDesc[] =  {'s', 'c', 'a', 'l', 'e'};
142 static const UChar translateDesc[] =  {'t', 'r', 'a', 'n', 's', 'l', 'a', 't', 'e'};
143 static const UChar rotateDesc[] =  {'r', 'o', 't', 'a', 't', 'e'};
144 static const UChar matrixDesc[] =  {'m', 'a', 't', 'r', 'i', 'x'};
145
146 static inline bool parseAndSkipType(const UChar*& currTransform, const UChar* end, unsigned short& type)
147 {
148     if (currTransform >= end)
149         return false;
150
151     if (*currTransform == 's') {
152         if (skipString(currTransform, end, skewXDesc, WTF_ARRAY_LENGTH(skewXDesc)))
153             type = SVGTransform::SVG_TRANSFORM_SKEWX;
154         else if (skipString(currTransform, end, skewYDesc, WTF_ARRAY_LENGTH(skewYDesc)))
155             type = SVGTransform::SVG_TRANSFORM_SKEWY;
156         else if (skipString(currTransform, end, scaleDesc, WTF_ARRAY_LENGTH(scaleDesc)))
157             type = SVGTransform::SVG_TRANSFORM_SCALE;
158         else
159             return false;
160     } else if (skipString(currTransform, end, translateDesc, WTF_ARRAY_LENGTH(translateDesc)))
161         type = SVGTransform::SVG_TRANSFORM_TRANSLATE;
162     else if (skipString(currTransform, end, rotateDesc, WTF_ARRAY_LENGTH(rotateDesc)))
163         type = SVGTransform::SVG_TRANSFORM_ROTATE;
164     else if (skipString(currTransform, end, matrixDesc, WTF_ARRAY_LENGTH(matrixDesc)))
165         type = SVGTransform::SVG_TRANSFORM_MATRIX;
166     else
167         return false;
168
169     return true;
170 }
171
172 SVGTransform::SVGTransformType SVGTransformable::parseTransformType(const String& typeString)
173 {
174     unsigned short type = SVGTransform::SVG_TRANSFORM_UNKNOWN;
175     auto upconvertedCharacters = StringView(typeString).upconvertedCharacters();
176     const UChar* characters = upconvertedCharacters;
177     parseAndSkipType(characters, characters + typeString.length(), type);
178     return static_cast<SVGTransform::SVGTransformType>(type);
179 }
180
181 bool SVGTransformable::parseTransformAttribute(SVGTransformList& list, const UChar*& currTransform, const UChar* end, TransformParsingMode mode)
182 {
183     if (mode == ClearList)
184         list.clear();
185
186     bool delimParsed = false;
187     while (currTransform < end) {
188         delimParsed = false;
189         unsigned short type = SVGTransform::SVG_TRANSFORM_UNKNOWN;
190         skipOptionalSVGSpaces(currTransform, end);
191
192         if (!parseAndSkipType(currTransform, end, type))
193             return false;
194
195         SVGTransform transform;
196         if (!parseTransformValue(type, currTransform, end, transform))
197             return false;
198
199         list.append(transform);
200         skipOptionalSVGSpaces(currTransform, end);
201         if (currTransform < end && *currTransform == ',') {
202             delimParsed = true;
203             ++currTransform;
204         }
205         skipOptionalSVGSpaces(currTransform, end);
206     }
207
208     return !delimParsed;
209 }
210
211 }