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