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