Manage SVGPathByteStream through std::unique_ptr
[WebKit-https.git] / Source / WebCore / svg / SVGAnimatedType.h
1 /*
2  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public License
15  * along with this library; see the file COPYING.LIB.  If not, write to
16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  * Boston, MA 02110-1301, USA.
18  */
19
20 #ifndef SVGAnimatedType_h
21 #define SVGAnimatedType_h
22
23 #if ENABLE(SVG)
24 #include "FloatRect.h"
25 #include "SVGAngle.h"
26 #include "SVGColor.h"
27 #include "SVGLength.h"
28 #include "SVGLengthList.h"
29 #include "SVGNumberList.h"
30 #include "SVGPointList.h"
31 #include "SVGPreserveAspectRatio.h"
32 #include "SVGPropertyInfo.h"
33 #include "SVGTransformList.h"
34
35 namespace WebCore {
36
37 class SVGPathByteStream;
38
39 class SVGAnimatedType {
40     WTF_MAKE_FAST_ALLOCATED;
41 public:
42     virtual ~SVGAnimatedType();
43
44     static PassOwnPtr<SVGAnimatedType> createAngleAndEnumeration(std::pair<SVGAngle, unsigned>*);
45     static PassOwnPtr<SVGAnimatedType> createBoolean(bool*);
46     static PassOwnPtr<SVGAnimatedType> createColor(Color*);
47     static PassOwnPtr<SVGAnimatedType> createEnumeration(unsigned*);
48     static PassOwnPtr<SVGAnimatedType> createInteger(int*);
49     static PassOwnPtr<SVGAnimatedType> createIntegerOptionalInteger(std::pair<int, int>*);
50     static PassOwnPtr<SVGAnimatedType> createLength(SVGLength*);
51     static PassOwnPtr<SVGAnimatedType> createLengthList(SVGLengthList*);
52     static PassOwnPtr<SVGAnimatedType> createNumber(float*);
53     static PassOwnPtr<SVGAnimatedType> createNumberList(SVGNumberList*);
54     static PassOwnPtr<SVGAnimatedType> createNumberOptionalNumber(std::pair<float, float>*);
55     static PassOwnPtr<SVGAnimatedType> createPath(std::unique_ptr<SVGPathByteStream>);
56     static PassOwnPtr<SVGAnimatedType> createPointList(SVGPointList*);
57     static PassOwnPtr<SVGAnimatedType> createPreserveAspectRatio(SVGPreserveAspectRatio*);
58     static PassOwnPtr<SVGAnimatedType> createRect(FloatRect*);
59     static PassOwnPtr<SVGAnimatedType> createString(String*);
60     static PassOwnPtr<SVGAnimatedType> createTransformList(SVGTransformList*);
61     static bool supportsAnimVal(AnimatedPropertyType);
62
63     AnimatedPropertyType type() const { return m_type; }
64
65     // Non-mutable accessors.
66     const std::pair<SVGAngle, unsigned>& angleAndEnumeration() const
67     {
68         ASSERT(m_type == AnimatedAngle);
69         return *m_data.angleAndEnumeration;
70     }
71
72     const bool& boolean() const
73     {
74         ASSERT(m_type == AnimatedBoolean);
75         return *m_data.boolean;
76     }
77
78     const Color& color() const
79     {
80         ASSERT(m_type == AnimatedColor);
81         return *m_data.color;
82     }
83
84     const unsigned& enumeration() const
85     {
86         ASSERT(m_type == AnimatedEnumeration);
87         return *m_data.enumeration;
88     }
89
90     const int& integer() const
91     {
92         ASSERT(m_type == AnimatedInteger);
93         return *m_data.integer;
94     }
95
96     const pair<int, int>& integerOptionalInteger() const
97     {
98         ASSERT(m_type == AnimatedIntegerOptionalInteger);
99         return *m_data.integerOptionalInteger;
100     }
101
102     const SVGLength& length() const
103     {
104         ASSERT(m_type == AnimatedLength);
105         return *m_data.length;
106     }
107
108     const SVGLengthList& lengthList() const
109     {
110         ASSERT(m_type == AnimatedLengthList);
111         return *m_data.lengthList;
112     }
113
114     const float& number() const
115     {
116         ASSERT(m_type == AnimatedNumber);
117         return *m_data.number;
118     }
119
120     const SVGNumberList& numberList() const
121     {
122         ASSERT(m_type == AnimatedNumberList);
123         return *m_data.numberList;
124     }
125
126     const pair<float, float>& numberOptionalNumber() const
127     {
128         ASSERT(m_type == AnimatedNumberOptionalNumber);
129         return *m_data.numberOptionalNumber;
130     }
131
132     const SVGPathByteStream* path() const
133     {
134         ASSERT(m_type == AnimatedPath);
135         return m_data.path;
136     }
137
138     const SVGPointList& pointList() const
139     {
140         ASSERT(m_type == AnimatedPoints);
141         return *m_data.pointList;
142     }
143
144     const SVGPreserveAspectRatio& preserveAspectRatio() const
145     {
146         ASSERT(m_type == AnimatedPreserveAspectRatio);
147         return *m_data.preserveAspectRatio;
148     }
149
150     const FloatRect& rect() const
151     {
152         ASSERT(m_type == AnimatedRect);
153         return *m_data.rect;
154     }
155
156     const String& string() const
157     {
158         ASSERT(m_type == AnimatedString);
159         return *m_data.string;
160     }
161
162     const SVGTransformList& transformList() const
163     {
164         ASSERT(m_type == AnimatedTransformList);
165         return *m_data.transformList;
166     }
167
168     // Mutable accessors.
169     std::pair<SVGAngle, unsigned>& angleAndEnumeration()
170     {
171         ASSERT(m_type == AnimatedAngle);
172         return *m_data.angleAndEnumeration;
173     }
174
175     bool& boolean()
176     {
177         ASSERT(m_type == AnimatedBoolean);
178         return *m_data.boolean;
179     }
180
181     Color& color()
182     {
183         ASSERT(m_type == AnimatedColor);
184         return *m_data.color;
185     }
186
187     unsigned& enumeration()
188     {
189         ASSERT(m_type == AnimatedEnumeration);
190         return *m_data.enumeration;
191     }
192
193     int& integer()
194     {
195         ASSERT(m_type == AnimatedInteger);
196         return *m_data.integer;
197     }
198
199     pair<int, int>& integerOptionalInteger()
200     {
201         ASSERT(m_type == AnimatedIntegerOptionalInteger);
202         return *m_data.integerOptionalInteger;
203     }
204
205     SVGLength& length()
206     {
207         ASSERT(m_type == AnimatedLength);
208         return *m_data.length;
209     }
210
211     SVGLengthList& lengthList()
212     {
213         ASSERT(m_type == AnimatedLengthList);
214         return *m_data.lengthList;
215     }
216
217     float& number()
218     {
219         ASSERT(m_type == AnimatedNumber);
220         return *m_data.number;
221     }
222
223     SVGNumberList& numberList()
224     {
225         ASSERT(m_type == AnimatedNumberList);
226         return *m_data.numberList;
227     }
228
229     pair<float, float>& numberOptionalNumber()
230     {
231         ASSERT(m_type == AnimatedNumberOptionalNumber);
232         return *m_data.numberOptionalNumber;
233     }
234
235     SVGPathByteStream* path()
236     {
237         ASSERT(m_type == AnimatedPath);
238         return m_data.path;
239     }
240
241     SVGPointList& pointList()
242     {
243         ASSERT(m_type == AnimatedPoints);
244         return *m_data.pointList;
245     }
246
247     SVGPreserveAspectRatio& preserveAspectRatio()
248     {
249         ASSERT(m_type == AnimatedPreserveAspectRatio);
250         return *m_data.preserveAspectRatio;
251     }
252
253     FloatRect& rect()
254     {
255         ASSERT(m_type == AnimatedRect);
256         return *m_data.rect;
257     }
258
259     String& string()
260     {
261         ASSERT(m_type == AnimatedString);
262         return *m_data.string;
263     }
264
265     SVGTransformList& transformList()
266     {
267         ASSERT(m_type == AnimatedTransformList);
268         return *m_data.transformList;
269     }
270
271     String valueAsString();
272     bool setValueAsString(const QualifiedName&, const String&);
273     
274 private:
275     SVGAnimatedType(AnimatedPropertyType);
276
277     AnimatedPropertyType m_type;
278
279     union DataUnion {
280         DataUnion()
281             : length(0)
282         {
283         }
284
285         std::pair<SVGAngle, unsigned>* angleAndEnumeration;
286         bool* boolean;
287         Color* color;
288         unsigned* enumeration;
289         int* integer;
290         std::pair<int, int>* integerOptionalInteger;
291         SVGLength* length;
292         SVGLengthList* lengthList;
293         float* number;
294         SVGNumberList* numberList;
295         std::pair<float, float>* numberOptionalNumber;
296         SVGPathByteStream* path;
297         SVGPreserveAspectRatio* preserveAspectRatio;
298         SVGPointList* pointList;
299         FloatRect* rect;
300         String* string;
301         SVGTransformList* transformList;
302     } m_data;
303 };
304     
305 } // namespace WebCore
306
307 #endif // ENABLE(SVG)
308 #endif // SVGAnimatedType_h