2011-07-07 Nikolas Zimmermann <nzimmermann@rim.com>
authorzimmermann@webkit.org <zimmermann@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 7 Jul 2011 14:18:01 +0000 (14:18 +0000)
committerzimmermann@webkit.org <zimmermann@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 7 Jul 2011 14:18:01 +0000 (14:18 +0000)
        Move remaining enums out of SVG*Element classes
        https://bugs.webkit.org/show_bug.cgi?id=64075

        Reviewed by Dirk Schulze.

        Move remaining enums out of SVG*Element classes. This is a preparation patch for bug 63797.
        Also move the SVGPropertyTraits template specializations for enum types before the class
        definition in the header, otherwhise we can't use SVGPropertyTraits<FooType>::fromString/toString
        in the DECLARE_ANIMATED* macros, which is needed soon.

        No new tests, just refactoring.

        * rendering/svg/RenderSVGResourceGradient.cpp:
        (WebCore::RenderSVGResourceGradient::applyResource):
        * rendering/svg/RenderSVGResourceGradient.h:
        * rendering/svg/RenderSVGResourceMarker.cpp:
        (WebCore::RenderSVGResourceMarker::angle):
        (WebCore::RenderSVGResourceMarker::markerTransformation):
        * rendering/svg/RenderSVGResourceMarker.h:
        (WebCore::RenderSVGResourceMarker::markerUnits):
        * rendering/svg/RenderSVGTextPath.cpp:
        (WebCore::RenderSVGTextPath::RenderSVGTextPath):
        (WebCore::RenderSVGTextPath::exactAlignment):
        (WebCore::RenderSVGTextPath::stretchMethod):
        * rendering/svg/SVGRenderTreeAsText.cpp:
        (WebCore::operator<<):
        (WebCore::writeCommonGradientProperties):
        * rendering/svg/SVGTextChunkBuilder.cpp:
        (WebCore::SVGTextChunkBuilder::addTextChunk):
        * rendering/svg/SVGTextLayoutEngine.cpp:
        (WebCore::SVGTextLayoutEngine::parentDefinesTextLength):
        (WebCore::SVGTextLayoutEngine::beginTextPathLayout):
        * svg/GradientAttributes.h:
        (WebCore::GradientAttributes::GradientAttributes):
        (WebCore::GradientAttributes::spreadMethod):
        (WebCore::GradientAttributes::setSpreadMethod):
        * svg/SVGComponentTransferFunctionElement.h:
        * svg/SVGFEBlendElement.h:
        * svg/SVGFEColorMatrixElement.h:
        * svg/SVGFECompositeElement.h:
        * svg/SVGFEConvolveMatrixElement.h:
        * svg/SVGFEDisplacementMapElement.h:
        * svg/SVGFEMorphologyElement.h:
        * svg/SVGFETurbulenceElement.h:
        * svg/SVGGradientElement.cpp:
        (WebCore::SVGGradientElement::SVGGradientElement):
        * svg/SVGGradientElement.h:
        * svg/SVGMarkerElement.cpp:
        (WebCore::SVGMarkerElement::SVGMarkerElement):
        (WebCore::SVGMarkerElement::parseMappedAttribute):
        (WebCore::SVGMarkerElement::setOrientToAuto):
        (WebCore::SVGMarkerElement::setOrientToAngle):
        (WebCore::SVGMarkerElement::synchronizeOrientType):
        (WebCore::SVGMarkerElement::orientTypeAnimated):
        * svg/SVGMarkerElement.h:
        * svg/SVGTextContentElement.cpp:
        (WebCore::SVGTextContentElement::SVGTextContentElement):
        * svg/SVGTextContentElement.h:
        * svg/SVGTextPathElement.cpp:
        (WebCore::SVGTextPathElement::SVGTextPathElement):
        * svg/SVGTextPathElement.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@90560 268f45cc-cd09-0410-ab3c-d52691b4dbfc

26 files changed:
Source/WebCore/ChangeLog
Source/WebCore/rendering/svg/RenderSVGResourceGradient.cpp
Source/WebCore/rendering/svg/RenderSVGResourceGradient.h
Source/WebCore/rendering/svg/RenderSVGResourceMarker.cpp
Source/WebCore/rendering/svg/RenderSVGResourceMarker.h
Source/WebCore/rendering/svg/RenderSVGTextPath.cpp
Source/WebCore/rendering/svg/SVGRenderTreeAsText.cpp
Source/WebCore/rendering/svg/SVGTextChunkBuilder.cpp
Source/WebCore/rendering/svg/SVGTextLayoutEngine.cpp
Source/WebCore/svg/GradientAttributes.h
Source/WebCore/svg/SVGComponentTransferFunctionElement.h
Source/WebCore/svg/SVGFEBlendElement.h
Source/WebCore/svg/SVGFEColorMatrixElement.h
Source/WebCore/svg/SVGFECompositeElement.h
Source/WebCore/svg/SVGFEConvolveMatrixElement.h
Source/WebCore/svg/SVGFEDisplacementMapElement.h
Source/WebCore/svg/SVGFEMorphologyElement.h
Source/WebCore/svg/SVGFETurbulenceElement.h
Source/WebCore/svg/SVGGradientElement.cpp
Source/WebCore/svg/SVGGradientElement.h
Source/WebCore/svg/SVGMarkerElement.cpp
Source/WebCore/svg/SVGMarkerElement.h
Source/WebCore/svg/SVGTextContentElement.cpp
Source/WebCore/svg/SVGTextContentElement.h
Source/WebCore/svg/SVGTextPathElement.cpp
Source/WebCore/svg/SVGTextPathElement.h

index b403f0b..6af991c 100644 (file)
@@ -1,3 +1,67 @@
+2011-07-07  Nikolas Zimmermann  <nzimmermann@rim.com>
+
+        Move remaining enums out of SVG*Element classes
+        https://bugs.webkit.org/show_bug.cgi?id=64075
+
+        Reviewed by Dirk Schulze.
+
+        Move remaining enums out of SVG*Element classes. This is a preparation patch for bug 63797.
+        Also move the SVGPropertyTraits template specializations for enum types before the class
+        definition in the header, otherwhise we can't use SVGPropertyTraits<FooType>::fromString/toString
+        in the DECLARE_ANIMATED* macros, which is needed soon.
+
+        No new tests, just refactoring.
+
+        * rendering/svg/RenderSVGResourceGradient.cpp:
+        (WebCore::RenderSVGResourceGradient::applyResource):
+        * rendering/svg/RenderSVGResourceGradient.h:
+        * rendering/svg/RenderSVGResourceMarker.cpp:
+        (WebCore::RenderSVGResourceMarker::angle):
+        (WebCore::RenderSVGResourceMarker::markerTransformation):
+        * rendering/svg/RenderSVGResourceMarker.h:
+        (WebCore::RenderSVGResourceMarker::markerUnits):
+        * rendering/svg/RenderSVGTextPath.cpp:
+        (WebCore::RenderSVGTextPath::RenderSVGTextPath):
+        (WebCore::RenderSVGTextPath::exactAlignment):
+        (WebCore::RenderSVGTextPath::stretchMethod):
+        * rendering/svg/SVGRenderTreeAsText.cpp:
+        (WebCore::operator<<):
+        (WebCore::writeCommonGradientProperties):
+        * rendering/svg/SVGTextChunkBuilder.cpp:
+        (WebCore::SVGTextChunkBuilder::addTextChunk):
+        * rendering/svg/SVGTextLayoutEngine.cpp:
+        (WebCore::SVGTextLayoutEngine::parentDefinesTextLength):
+        (WebCore::SVGTextLayoutEngine::beginTextPathLayout):
+        * svg/GradientAttributes.h:
+        (WebCore::GradientAttributes::GradientAttributes):
+        (WebCore::GradientAttributes::spreadMethod):
+        (WebCore::GradientAttributes::setSpreadMethod):
+        * svg/SVGComponentTransferFunctionElement.h:
+        * svg/SVGFEBlendElement.h:
+        * svg/SVGFEColorMatrixElement.h:
+        * svg/SVGFECompositeElement.h:
+        * svg/SVGFEConvolveMatrixElement.h:
+        * svg/SVGFEDisplacementMapElement.h:
+        * svg/SVGFEMorphologyElement.h:
+        * svg/SVGFETurbulenceElement.h:
+        * svg/SVGGradientElement.cpp:
+        (WebCore::SVGGradientElement::SVGGradientElement):
+        * svg/SVGGradientElement.h:
+        * svg/SVGMarkerElement.cpp:
+        (WebCore::SVGMarkerElement::SVGMarkerElement):
+        (WebCore::SVGMarkerElement::parseMappedAttribute):
+        (WebCore::SVGMarkerElement::setOrientToAuto):
+        (WebCore::SVGMarkerElement::setOrientToAngle):
+        (WebCore::SVGMarkerElement::synchronizeOrientType):
+        (WebCore::SVGMarkerElement::orientTypeAnimated):
+        * svg/SVGMarkerElement.h:
+        * svg/SVGTextContentElement.cpp:
+        (WebCore::SVGTextContentElement::SVGTextContentElement):
+        * svg/SVGTextContentElement.h:
+        * svg/SVGTextPathElement.cpp:
+        (WebCore::SVGTextPathElement::SVGTextPathElement):
+        * svg/SVGTextPathElement.h:
+
 2011-07-07  Ilya Tikhonovsky  <loislo@chromium.org>
 
         Web Inspector: Protocol: pointers to optional "in" parameters passing to the
index 59e88bc..1aab935 100644 (file)
@@ -278,15 +278,15 @@ void RenderSVGResourceGradient::addStops(GradientData* gradientData, const Vecto
         gradientData->gradient->addColorStop(*it);
 }
 
-GradientSpreadMethod RenderSVGResourceGradient::platformSpreadMethodFromSVGType(SVGGradientElement::SVGSpreadMethodType method) const
+GradientSpreadMethod RenderSVGResourceGradient::platformSpreadMethodFromSVGType(SVGSpreadMethodType method) const
 {
     switch (method) {
-    case SVGGradientElement::SVG_SPREADMETHOD_UNKNOWN:
-    case SVGGradientElement::SVG_SPREADMETHOD_PAD:
+    case SVGSpreadMethodUnknown:
+    case SVGSpreadMethodPad:
         return SpreadMethodPad;
-    case SVGGradientElement::SVG_SPREADMETHOD_REFLECT:
+    case SVGSpreadMethodReflect:
         return SpreadMethodReflect;
-    case SVGGradientElement::SVG_SPREADMETHOD_REPEAT:
+    case SVGSpreadMethodRepeat:
         return SpreadMethodRepeat;
     }
 
index 6e8c1f8..df492e2 100644 (file)
@@ -61,7 +61,7 @@ protected:
     virtual bool collectGradientAttributes(SVGGradientElement*) = 0;
     virtual void buildGradient(GradientData*, SVGGradientElement*) const = 0;
 
-    GradientSpreadMethod platformSpreadMethodFromSVGType(SVGGradientElement::SVGSpreadMethodType) const;
+    GradientSpreadMethod platformSpreadMethodFromSVGType(SVGSpreadMethodType) const;
 
 private:
     bool m_shouldCollectGradientAttributes : 1;
index 5024a51..f621cd9 100644 (file)
@@ -106,7 +106,7 @@ float RenderSVGResourceMarker::angle() const
     ASSERT(marker);
 
     float angle = -1;
-    if (marker->orientType() == SVGMarkerElement::SVG_MARKER_ORIENT_ANGLE)
+    if (marker->orientType() == SVGMarkerOrientAngle)
         angle = marker->orientAngle().value();
 
     return angle;
@@ -118,7 +118,7 @@ AffineTransform RenderSVGResourceMarker::markerTransformation(const FloatPoint&
     ASSERT(marker);
 
     float markerAngle = angle();
-    bool useStrokeWidth = (marker->markerUnits() == SVGMarkerElement::SVG_MARKERUNITS_STROKEWIDTH);
+    bool useStrokeWidth = marker->markerUnits() == SVGMarkerUnitsStrokeWidth;
 
     AffineTransform transform;
     transform.translate(origin.x(), origin.y());
index 0d1aa11..faa2258 100644 (file)
@@ -60,7 +60,7 @@ public:
 
     FloatPoint referencePoint() const;
     float angle() const;
-    SVGMarkerElement::SVGMarkerUnitsType markerUnits() const { return static_cast<SVGMarkerElement*>(node())->markerUnits(); }
+    SVGMarkerUnitsType markerUnits() const { return static_cast<SVGMarkerElement*>(node())->markerUnits(); }
 
     virtual RenderSVGResourceType resourceType() const { return s_resourceType; }
     static RenderSVGResourceType s_resourceType;
index 883f810..8682fb1 100644 (file)
@@ -35,7 +35,7 @@ namespace WebCore {
 
 RenderSVGTextPath::RenderSVGTextPath(Node* n)
     : RenderSVGInline(n)
-    , m_startOffset(0.0f)
+    , m_startOffset(0)
     , m_exactAlignment(true)
     , m_stretchMethod(false)
 {
@@ -69,12 +69,12 @@ float RenderSVGTextPath::startOffset() const
 
 bool RenderSVGTextPath::exactAlignment() const
 {
-    return static_cast<SVGTextPathElement*>(node())->spacing() == SVG_TEXTPATH_SPACINGTYPE_EXACT;
+    return static_cast<SVGTextPathElement*>(node())->spacing() == SVGTextPathSpacingExact;
 }
 
 bool RenderSVGTextPath::stretchMethod() const
 {
-    return static_cast<SVGTextPathElement*>(node())->method() == SVG_TEXTPATH_METHODTYPE_STRETCH;
+    return static_cast<SVGTextPathElement*>(node())->method() == SVGTextPathMethodStretch;
 }
 
 }
index 76b9c9e..a162969 100644 (file)
@@ -192,9 +192,9 @@ static TextStream& operator<<(TextStream& ts, const SVGUnitTypes::SVGUnitType& u
     return ts;
 }
 
-static TextStream& operator<<(TextStream& ts, const SVGMarkerElement::SVGMarkerUnitsType& markerUnit)
+static TextStream& operator<<(TextStream& ts, const SVGMarkerUnitsType& markerUnit)
 {
-    ts << SVGPropertyTraits<SVGMarkerElement::SVGMarkerUnitsType>::toString(markerUnit);
+    ts << SVGPropertyTraits<SVGMarkerUnitsType>::toString(markerUnit);
     return ts;
 }
 
@@ -251,9 +251,9 @@ static TextStream& operator<<(TextStream& ts, LineJoin style)
     return ts;
 }
 
-static TextStream& operator<<(TextStream& ts, const SVGGradientElement::SVGSpreadMethodType& type)
+static TextStream& operator<<(TextStream& ts, const SVGSpreadMethodType& type)
 {
-    ts << SVGPropertyTraits<SVGGradientElement::SVGSpreadMethodType>::toString(type).upper();
+    ts << SVGPropertyTraits<SVGSpreadMethodType>::toString(type).upper();
     return ts;
 }
 
@@ -500,11 +500,11 @@ static inline String boundingBoxModeString(bool boundingBoxMode)
     return boundingBoxMode ? "objectBoundingBox" : "userSpaceOnUse";
 }
 
-static inline void writeCommonGradientProperties(TextStream& ts, SVGGradientElement::SVGSpreadMethodType spreadMethod, const AffineTransform& gradientTransform, bool boundingBoxMode)
+static inline void writeCommonGradientProperties(TextStream& ts, SVGSpreadMethodType spreadMethod, const AffineTransform& gradientTransform, bool boundingBoxMode)
 {
     writeNameValuePair(ts, "gradientUnits", boundingBoxModeString(boundingBoxMode));
 
-    if (spreadMethod != SVGGradientElement::SVG_SPREADMETHOD_PAD)
+    if (spreadMethod != SVGSpreadMethodPad)
         ts << " [spreadMethod=" << spreadMethod << "]";
 
     if (!gradientTransform.isIdentity())
index 0e44cfa..99bd88a 100644 (file)
@@ -130,12 +130,12 @@ void SVGTextChunkBuilder::addTextChunk(Vector<SVGInlineTextBox*>& lineLayoutBoxe
         desiredTextLength = textContentElement->specifiedTextLength().value(textContentElement);
 
         switch (textContentElement->lengthAdjust()) {
-        case SVGTextContentElement::LENGTHADJUST_UNKNOWN:
+        case SVGLengthAdjustUnknown:
             break;
-        case SVGTextContentElement::LENGTHADJUST_SPACING:
+        case SVGLengthAdjustSpacing:
             chunkStyle |= SVGTextChunk::LengthAdjustSpacing;
             break;
-        case SVGTextContentElement::LENGTHADJUST_SPACINGANDGLYPHS:
+        case SVGLengthAdjustSpacingAndGlyphs:
             chunkStyle |= SVGTextChunk::LengthAdjustSpacingAndGlyphs;
             break;
         };
index 8d3efc2..46dc2ee 100644 (file)
@@ -154,10 +154,8 @@ bool SVGTextLayoutEngine::parentDefinesTextLength(RenderObject* parent) const
 {
     RenderObject* currentParent = parent;
     while (currentParent) {
-        SVGTextContentElement* textContentElement = SVGTextContentElement::elementFromRenderer(currentParent);
-        if (textContentElement) {
-            SVGTextContentElement::SVGLengthAdjustType lengthAdjust = textContentElement->lengthAdjust();
-            if (lengthAdjust == SVGTextContentElement::LENGTHADJUST_SPACING && textContentElement->specifiedTextLength().value(textContentElement) > 0)
+        if (SVGTextContentElement* textContentElement = SVGTextContentElement::elementFromRenderer(currentParent)) {
+            if (textContentElement->lengthAdjust() == SVGLengthAdjustSpacing && textContentElement->specifiedTextLength().value(textContentElement) > 0)
                 return true;
         }
 
@@ -208,7 +206,7 @@ void SVGTextLayoutEngine::beginTextPathLayout(RenderObject* object, SVGTextLayou
     m_textPathCurrentOffset = m_textPathStartOffset;
 
     // Eventually handle textLength adjustments.
-    SVGTextContentElement::SVGLengthAdjustType lengthAdjust = SVGTextContentElement::LENGTHADJUST_UNKNOWN;
+    SVGLengthAdjustType lengthAdjust = SVGLengthAdjustUnknown;
     float desiredTextLength = 0;
 
     if (SVGTextContentElement* textContentElement = SVGTextContentElement::elementFromRenderer(textPath)) {
@@ -219,7 +217,7 @@ void SVGTextLayoutEngine::beginTextPathLayout(RenderObject* object, SVGTextLayou
     if (!desiredTextLength)
         return;
 
-    if (lengthAdjust == SVGTextContentElement::LENGTHADJUST_SPACING)
+    if (lengthAdjust == SVGLengthAdjustSpacing)
         m_textPathSpacing = (desiredTextLength - totalLength) / totalCharacters;
     else
         m_textPathScaling = desiredTextLength / totalLength;
index 52c0a02..17f55ce 100644 (file)
@@ -28,7 +28,7 @@ namespace WebCore {
 
 struct GradientAttributes {
     GradientAttributes()
-        : m_spreadMethod(SVGGradientElement::SVG_SPREADMETHOD_PAD)
+        : m_spreadMethod(SVGSpreadMethodPad)
         , m_boundingBoxMode(true)
         , m_spreadMethodSet(false)
         , m_boundingBoxModeSet(false)
@@ -37,12 +37,12 @@ struct GradientAttributes {
     {
     }
 
-    SVGGradientElement::SVGSpreadMethodType spreadMethod() const { return m_spreadMethod; }
+    SVGSpreadMethodType spreadMethod() const { return m_spreadMethod; }
     bool boundingBoxMode() const { return m_boundingBoxMode; }
     AffineTransform gradientTransform() const { return m_gradientTransform; }
     const Vector<Gradient::ColorStop>& stops() const { return m_stops; }
 
-    void setSpreadMethod(SVGGradientElement::SVGSpreadMethodType value)
+    void setSpreadMethod(SVGSpreadMethodType value)
     {
         m_spreadMethod = value;
         m_spreadMethodSet = true;
@@ -73,7 +73,7 @@ struct GradientAttributes {
 
 private:
     // Properties
-    SVGGradientElement::SVGSpreadMethodType m_spreadMethod;
+    SVGSpreadMethodType m_spreadMethod;
     bool m_boundingBoxMode;
     AffineTransform m_gradientTransform;
     Vector<Gradient::ColorStop> m_stops;
index 9116a6d..7ea6c6c 100644 (file)
 
 namespace WebCore {
 
-class SVGComponentTransferFunctionElement : public SVGElement {
-public:
-    ComponentTransferFunction transferFunction() const;
-
-protected:
-    SVGComponentTransferFunctionElement(const QualifiedName&, Document*);
-
-    // FIXME: svgAttributeChanged missing.
-    bool isSupportedAttribute(const QualifiedName&);
-    virtual void parseMappedAttribute(Attribute*);
-    virtual void synchronizeProperty(const QualifiedName&);
-    virtual void fillAttributeToPropertyTypeMap();
-    virtual AttributeToPropertyTypeMap& attributeToPropertyTypeMap();
-    
-private:
-    // Animated property declarations
-    DECLARE_ANIMATED_ENUMERATION(Type, type, ComponentTransferType)
-    DECLARE_ANIMATED_NUMBER_LIST(TableValues, tableValues)
-    DECLARE_ANIMATED_NUMBER(Slope, slope)
-    DECLARE_ANIMATED_NUMBER(Intercept, intercept)
-    DECLARE_ANIMATED_NUMBER(Amplitude, amplitude)
-    DECLARE_ANIMATED_NUMBER(Exponent, exponent)
-    DECLARE_ANIMATED_NUMBER(Offset, offset)
-};
-
 template<>
 struct SVGPropertyTraits<ComponentTransferType> {
     static ComponentTransferType highestEnumValue() { return FECOMPONENTTRANSFER_TYPE_GAMMA; }
@@ -95,6 +70,31 @@ struct SVGPropertyTraits<ComponentTransferType> {
     }
 };
 
+class SVGComponentTransferFunctionElement : public SVGElement {
+public:
+    ComponentTransferFunction transferFunction() const;
+
+protected:
+    SVGComponentTransferFunctionElement(const QualifiedName&, Document*);
+
+    // FIXME: svgAttributeChanged missing.
+    bool isSupportedAttribute(const QualifiedName&);
+    virtual void parseMappedAttribute(Attribute*);
+    virtual void synchronizeProperty(const QualifiedName&);
+    virtual void fillAttributeToPropertyTypeMap();
+    virtual AttributeToPropertyTypeMap& attributeToPropertyTypeMap();
+    
+private:
+    // Animated property declarations
+    DECLARE_ANIMATED_ENUMERATION(Type, type, ComponentTransferType)
+    DECLARE_ANIMATED_NUMBER_LIST(TableValues, tableValues)
+    DECLARE_ANIMATED_NUMBER(Slope, slope)
+    DECLARE_ANIMATED_NUMBER(Intercept, intercept)
+    DECLARE_ANIMATED_NUMBER(Amplitude, amplitude)
+    DECLARE_ANIMATED_NUMBER(Exponent, exponent)
+    DECLARE_ANIMATED_NUMBER(Offset, offset)
+};
+
 } // namespace WebCore
 
 #endif // ENABLE(SVG) && ENABLE(FILTERS)
index 58798ad..ff8288e 100644 (file)
 
 namespace WebCore {
 
-class SVGFEBlendElement : public SVGFilterPrimitiveStandardAttributes {
-public:
-    static PassRefPtr<SVGFEBlendElement> create(const QualifiedName&, Document*);
-
-private:
-    SVGFEBlendElement(const QualifiedName&, Document*);
-
-    bool isSupportedAttribute(const QualifiedName&);
-    virtual void parseMappedAttribute(Attribute*);
-    virtual bool setFilterEffectAttribute(FilterEffect*, const QualifiedName& attrName);
-    virtual void svgAttributeChanged(const QualifiedName&);
-    virtual void synchronizeProperty(const QualifiedName&);
-    virtual void fillAttributeToPropertyTypeMap();
-    virtual AttributeToPropertyTypeMap& attributeToPropertyTypeMap();
-    virtual PassRefPtr<FilterEffect> build(SVGFilterBuilder*, Filter*);
-
-    // Animated property declarations
-    DECLARE_ANIMATED_STRING(In1, in1)
-    DECLARE_ANIMATED_STRING(In2, in2)
-    DECLARE_ANIMATED_ENUMERATION(Mode, mode, BlendModeType)
-};
-
 template<>
 struct SVGPropertyTraits<BlendModeType> {
     static BlendModeType highestEnumValue() { return FEBLEND_MODE_LIGHTEN; }
@@ -91,6 +69,28 @@ struct SVGPropertyTraits<BlendModeType> {
     }
 };
 
+class SVGFEBlendElement : public SVGFilterPrimitiveStandardAttributes {
+public:
+    static PassRefPtr<SVGFEBlendElement> create(const QualifiedName&, Document*);
+
+private:
+    SVGFEBlendElement(const QualifiedName&, Document*);
+
+    bool isSupportedAttribute(const QualifiedName&);
+    virtual void parseMappedAttribute(Attribute*);
+    virtual bool setFilterEffectAttribute(FilterEffect*, const QualifiedName& attrName);
+    virtual void svgAttributeChanged(const QualifiedName&);
+    virtual void synchronizeProperty(const QualifiedName&);
+    virtual void fillAttributeToPropertyTypeMap();
+    virtual AttributeToPropertyTypeMap& attributeToPropertyTypeMap();
+    virtual PassRefPtr<FilterEffect> build(SVGFilterBuilder*, Filter*);
+
+    // Animated property declarations
+    DECLARE_ANIMATED_STRING(In1, in1)
+    DECLARE_ANIMATED_STRING(In2, in2)
+    DECLARE_ANIMATED_ENUMERATION(Mode, mode, BlendModeType)
+};
+
 } // namespace WebCore
 
 #endif // ENABLE(SVG)
index 14b782b..1cedd34 100644 (file)
 
 namespace WebCore {
 
-class SVGFEColorMatrixElement : public SVGFilterPrimitiveStandardAttributes {
-public:
-    static PassRefPtr<SVGFEColorMatrixElement> create(const QualifiedName&, Document*);
-
-private:
-    SVGFEColorMatrixElement(const QualifiedName&, Document*);
-
-    bool isSupportedAttribute(const QualifiedName&);
-    virtual void parseMappedAttribute(Attribute*);
-    virtual bool setFilterEffectAttribute(FilterEffect*, const QualifiedName&);
-    virtual void svgAttributeChanged(const QualifiedName&);
-    virtual void synchronizeProperty(const QualifiedName&);
-    virtual void fillAttributeToPropertyTypeMap();
-    virtual AttributeToPropertyTypeMap& attributeToPropertyTypeMap();
-    virtual PassRefPtr<FilterEffect> build(SVGFilterBuilder*, Filter*);
-
-    // Animated property declarations
-    DECLARE_ANIMATED_STRING(In1, in1)
-    DECLARE_ANIMATED_ENUMERATION(Type, type, ColorMatrixType)
-    DECLARE_ANIMATED_NUMBER_LIST(Values, values)
-};
-
 template<>
 struct SVGPropertyTraits<ColorMatrixType> {
     static ColorMatrixType highestEnumValue() { return FECOLORMATRIX_TYPE_LUMINANCETOALPHA; }
@@ -88,6 +66,28 @@ struct SVGPropertyTraits<ColorMatrixType> {
     }
 };
 
+class SVGFEColorMatrixElement : public SVGFilterPrimitiveStandardAttributes {
+public:
+    static PassRefPtr<SVGFEColorMatrixElement> create(const QualifiedName&, Document*);
+
+private:
+    SVGFEColorMatrixElement(const QualifiedName&, Document*);
+
+    bool isSupportedAttribute(const QualifiedName&);
+    virtual void parseMappedAttribute(Attribute*);
+    virtual bool setFilterEffectAttribute(FilterEffect*, const QualifiedName&);
+    virtual void svgAttributeChanged(const QualifiedName&);
+    virtual void synchronizeProperty(const QualifiedName&);
+    virtual void fillAttributeToPropertyTypeMap();
+    virtual AttributeToPropertyTypeMap& attributeToPropertyTypeMap();
+    virtual PassRefPtr<FilterEffect> build(SVGFilterBuilder*, Filter*);
+
+    // Animated property declarations
+    DECLARE_ANIMATED_STRING(In1, in1)
+    DECLARE_ANIMATED_ENUMERATION(Type, type, ColorMatrixType)
+    DECLARE_ANIMATED_NUMBER_LIST(Values, values)
+};
+
 } // namespace WebCore
 
 #endif // ENABLE(SVG)
index aef9ae9..fe8977f 100644 (file)
 
 namespace WebCore {
 
-class SVGFECompositeElement : public SVGFilterPrimitiveStandardAttributes {
-public:
-    static PassRefPtr<SVGFECompositeElement> create(const QualifiedName&, Document*);
-
-private:
-    SVGFECompositeElement(const QualifiedName&, Document*);
-
-    bool isSupportedAttribute(const QualifiedName&);
-    virtual void parseMappedAttribute(Attribute*);
-    virtual bool setFilterEffectAttribute(FilterEffect*, const QualifiedName&);
-    virtual void svgAttributeChanged(const QualifiedName&);
-    virtual void synchronizeProperty(const QualifiedName&);
-    virtual void fillAttributeToPropertyTypeMap();
-    virtual AttributeToPropertyTypeMap& attributeToPropertyTypeMap();
-    virtual PassRefPtr<FilterEffect> build(SVGFilterBuilder*, Filter*);
-
-    // Animated property declarations
-    DECLARE_ANIMATED_STRING(In1, in1)
-    DECLARE_ANIMATED_STRING(In2, in2)
-    DECLARE_ANIMATED_ENUMERATION(_operator, _operator, CompositeOperationType)
-    DECLARE_ANIMATED_NUMBER(K1, k1)
-    DECLARE_ANIMATED_NUMBER(K2, k2)
-    DECLARE_ANIMATED_NUMBER(K3, k3)
-    DECLARE_ANIMATED_NUMBER(K4, k4)
-};
-
 template<>
 struct SVGPropertyTraits<CompositeOperationType> {
     static CompositeOperationType highestEnumValue() { return FECOMPOSITE_OPERATOR_ARITHMETIC; }
@@ -100,6 +74,32 @@ struct SVGPropertyTraits<CompositeOperationType> {
     }
 };
 
+class SVGFECompositeElement : public SVGFilterPrimitiveStandardAttributes {
+public:
+    static PassRefPtr<SVGFECompositeElement> create(const QualifiedName&, Document*);
+
+private:
+    SVGFECompositeElement(const QualifiedName&, Document*);
+
+    bool isSupportedAttribute(const QualifiedName&);
+    virtual void parseMappedAttribute(Attribute*);
+    virtual bool setFilterEffectAttribute(FilterEffect*, const QualifiedName&);
+    virtual void svgAttributeChanged(const QualifiedName&);
+    virtual void synchronizeProperty(const QualifiedName&);
+    virtual void fillAttributeToPropertyTypeMap();
+    virtual AttributeToPropertyTypeMap& attributeToPropertyTypeMap();
+    virtual PassRefPtr<FilterEffect> build(SVGFilterBuilder*, Filter*);
+
+    // Animated property declarations
+    DECLARE_ANIMATED_STRING(In1, in1)
+    DECLARE_ANIMATED_STRING(In2, in2)
+    DECLARE_ANIMATED_ENUMERATION(_operator, _operator, CompositeOperationType)
+    DECLARE_ANIMATED_NUMBER(K1, k1)
+    DECLARE_ANIMATED_NUMBER(K2, k2)
+    DECLARE_ANIMATED_NUMBER(K3, k3)
+    DECLARE_ANIMATED_NUMBER(K4, k4)
+};
+
 } // namespace WebCore
 
 #endif // ENABLE(SVG)
index 2049ecb..a6120c1 100644 (file)
 
 namespace WebCore {
 
+template<>
+struct SVGPropertyTraits<EdgeModeType> {
+    static EdgeModeType highestEnumValue() { return EDGEMODE_NONE; }
+
+    static String toString(EdgeModeType type)
+    {
+        switch (type) {
+        case EDGEMODE_UNKNOWN:
+            return emptyString();
+        case EDGEMODE_DUPLICATE:
+            return "duplicate";
+        case EDGEMODE_WRAP:
+            return "wrap";
+        case EDGEMODE_NONE:
+            return "none";
+        }
+
+        ASSERT_NOT_REACHED();
+        return emptyString();
+    }
+
+    static EdgeModeType fromString(const String& value)
+    {
+        if (value == "duplicate")
+            return EDGEMODE_DUPLICATE;
+        if (value == "wrap")
+            return EDGEMODE_WRAP;
+        if (value == "none")
+            return EDGEMODE_NONE;
+        return EDGEMODE_UNKNOWN;
+    }
+};
+
 class SVGFEConvolveMatrixElement : public SVGFilterPrimitiveStandardAttributes {
 public:
     static PassRefPtr<SVGFEConvolveMatrixElement> create(const QualifiedName&, Document*);
@@ -70,39 +103,6 @@ private:
     DECLARE_ANIMATED_BOOLEAN(PreserveAlpha, preserveAlpha)
 };
 
-template<>
-struct SVGPropertyTraits<EdgeModeType> {
-    static EdgeModeType highestEnumValue() { return EDGEMODE_NONE; }
-
-    static String toString(EdgeModeType type)
-    {
-        switch (type) {
-        case EDGEMODE_UNKNOWN:
-            return emptyString();
-        case EDGEMODE_DUPLICATE:
-            return "duplicate";
-        case EDGEMODE_WRAP:
-            return "wrap";
-        case EDGEMODE_NONE:
-            return "none";
-        }
-
-        ASSERT_NOT_REACHED();
-        return emptyString();
-    }
-
-    static EdgeModeType fromString(const String& value)
-    {
-        if (value == "duplicate")
-            return EDGEMODE_DUPLICATE;
-        if (value == "wrap")
-            return EDGEMODE_WRAP;
-        if (value == "none")
-            return EDGEMODE_NONE;
-        return EDGEMODE_UNKNOWN;
-    }
-};
-
 } // namespace WebCore
 
 #endif // ENABLE(SVG)
index b4e41d6..20bb662 100644 (file)
 #include "SVGFilterPrimitiveStandardAttributes.h"
 
 namespace WebCore {
-    
-class SVGFEDisplacementMapElement : public SVGFilterPrimitiveStandardAttributes {
-public:
-    static PassRefPtr<SVGFEDisplacementMapElement> create(const QualifiedName&, Document*);
-
-    static ChannelSelectorType stringToChannel(const String&);
-    
-private:
-    SVGFEDisplacementMapElement(const QualifiedName& tagName, Document*);
-    
-    bool isSupportedAttribute(const QualifiedName&);
-    virtual void parseMappedAttribute(Attribute*);
-    virtual bool setFilterEffectAttribute(FilterEffect*, const QualifiedName& attrName);
-    virtual void svgAttributeChanged(const QualifiedName&);
-    virtual void synchronizeProperty(const QualifiedName&);
-    virtual void fillAttributeToPropertyTypeMap();
-    virtual AttributeToPropertyTypeMap& attributeToPropertyTypeMap();
-    virtual PassRefPtr<FilterEffect> build(SVGFilterBuilder*, Filter*);
-
-    // Animated property declarations
-    DECLARE_ANIMATED_STRING(In1, in1)
-    DECLARE_ANIMATED_STRING(In2, in2)
-    DECLARE_ANIMATED_ENUMERATION(XChannelSelector, xChannelSelector, ChannelSelectorType)
-    DECLARE_ANIMATED_ENUMERATION(YChannelSelector, yChannelSelector, ChannelSelectorType)
-    DECLARE_ANIMATED_NUMBER(Scale, scale)
-};
-
 template<>
 struct SVGPropertyTraits<ChannelSelectorType> {
     static ChannelSelectorType highestEnumValue() { return CHANNEL_A; }
@@ -91,6 +65,32 @@ struct SVGPropertyTraits<ChannelSelectorType> {
     }
 };
 
+class SVGFEDisplacementMapElement : public SVGFilterPrimitiveStandardAttributes {
+public:
+    static PassRefPtr<SVGFEDisplacementMapElement> create(const QualifiedName&, Document*);
+
+    static ChannelSelectorType stringToChannel(const String&);
+    
+private:
+    SVGFEDisplacementMapElement(const QualifiedName& tagName, Document*);
+    
+    bool isSupportedAttribute(const QualifiedName&);
+    virtual void parseMappedAttribute(Attribute*);
+    virtual bool setFilterEffectAttribute(FilterEffect*, const QualifiedName& attrName);
+    virtual void svgAttributeChanged(const QualifiedName&);
+    virtual void synchronizeProperty(const QualifiedName&);
+    virtual void fillAttributeToPropertyTypeMap();
+    virtual AttributeToPropertyTypeMap& attributeToPropertyTypeMap();
+    virtual PassRefPtr<FilterEffect> build(SVGFilterBuilder*, Filter*);
+
+    // Animated property declarations
+    DECLARE_ANIMATED_STRING(In1, in1)
+    DECLARE_ANIMATED_STRING(In2, in2)
+    DECLARE_ANIMATED_ENUMERATION(XChannelSelector, xChannelSelector, ChannelSelectorType)
+    DECLARE_ANIMATED_ENUMERATION(YChannelSelector, yChannelSelector, ChannelSelectorType)
+    DECLARE_ANIMATED_NUMBER(Scale, scale)
+};
+
 } // namespace WebCore
 
 #endif // ENABLE(SVG)
index 8b92e4a..94b4a0c 100644 (file)
 
 namespace WebCore {
 
-class SVGFEMorphologyElement : public SVGFilterPrimitiveStandardAttributes {
-public:
-    static PassRefPtr<SVGFEMorphologyElement> create(const QualifiedName&, Document*);
-
-    void setRadius(float radiusX, float radiusY);
-
-private:
-    SVGFEMorphologyElement(const QualifiedName&, Document*);
-
-    bool isSupportedAttribute(const QualifiedName&);
-    virtual void parseMappedAttribute(Attribute*);
-    virtual bool setFilterEffectAttribute(FilterEffect*, const QualifiedName&);
-    virtual void svgAttributeChanged(const QualifiedName&);
-    virtual void synchronizeProperty(const QualifiedName&);
-    virtual void fillAttributeToPropertyTypeMap();
-    virtual AttributeToPropertyTypeMap& attributeToPropertyTypeMap();
-    virtual PassRefPtr<FilterEffect> build(SVGFilterBuilder*, Filter*);
-
-    static const AtomicString& radiusXIdentifier();
-    static const AtomicString& radiusYIdentifier();
-
-    // Animated property declarations
-    DECLARE_ANIMATED_STRING(In1, in1)
-    DECLARE_ANIMATED_ENUMERATION(_operator, _operator, MorphologyOperatorType)
-    DECLARE_ANIMATED_NUMBER(RadiusX, radiusX)
-    DECLARE_ANIMATED_NUMBER(RadiusY, radiusY)
-};
-
 template<>
 struct SVGPropertyTraits<MorphologyOperatorType> {
     static MorphologyOperatorType highestEnumValue() { return FEMORPHOLOGY_OPERATOR_DILATE; }
@@ -85,6 +57,34 @@ struct SVGPropertyTraits<MorphologyOperatorType> {
     }
 };
 
+class SVGFEMorphologyElement : public SVGFilterPrimitiveStandardAttributes {
+public:
+    static PassRefPtr<SVGFEMorphologyElement> create(const QualifiedName&, Document*);
+
+    void setRadius(float radiusX, float radiusY);
+
+private:
+    SVGFEMorphologyElement(const QualifiedName&, Document*);
+
+    bool isSupportedAttribute(const QualifiedName&);
+    virtual void parseMappedAttribute(Attribute*);
+    virtual bool setFilterEffectAttribute(FilterEffect*, const QualifiedName&);
+    virtual void svgAttributeChanged(const QualifiedName&);
+    virtual void synchronizeProperty(const QualifiedName&);
+    virtual void fillAttributeToPropertyTypeMap();
+    virtual AttributeToPropertyTypeMap& attributeToPropertyTypeMap();
+    virtual PassRefPtr<FilterEffect> build(SVGFilterBuilder*, Filter*);
+
+    static const AtomicString& radiusXIdentifier();
+    static const AtomicString& radiusYIdentifier();
+
+    // Animated property declarations
+    DECLARE_ANIMATED_STRING(In1, in1)
+    DECLARE_ANIMATED_ENUMERATION(_operator, _operator, MorphologyOperatorType)
+    DECLARE_ANIMATED_NUMBER(RadiusX, radiusX)
+    DECLARE_ANIMATED_NUMBER(RadiusY, radiusY)
+};
+
 } // namespace WebCore
 
 #endif // ENABLE(SVG)
index 705e966..ac044ba 100644 (file)
@@ -36,34 +36,6 @@ enum SVGStitchOptions {
     SVG_STITCHTYPE_NOSTITCH = 2
 };
 
-class SVGFETurbulenceElement : public SVGFilterPrimitiveStandardAttributes {
-public:
-    static PassRefPtr<SVGFETurbulenceElement> create(const QualifiedName&, Document*);
-
-private:
-    SVGFETurbulenceElement(const QualifiedName&, Document*);
-
-    bool isSupportedAttribute(const QualifiedName&);
-    virtual void parseMappedAttribute(Attribute*);
-    virtual bool setFilterEffectAttribute(FilterEffect*, const QualifiedName& attrName);
-    virtual void svgAttributeChanged(const QualifiedName&);
-    virtual void synchronizeProperty(const QualifiedName&);
-    virtual void fillAttributeToPropertyTypeMap();
-    virtual AttributeToPropertyTypeMap& attributeToPropertyTypeMap();
-    virtual PassRefPtr<FilterEffect> build(SVGFilterBuilder*, Filter*);
-
-    static const AtomicString& baseFrequencyXIdentifier();
-    static const AtomicString& baseFrequencyYIdentifier();
-
-    // Animated property declarations
-    DECLARE_ANIMATED_NUMBER(BaseFrequencyX, baseFrequencyX)
-    DECLARE_ANIMATED_NUMBER(BaseFrequencyY, baseFrequencyY)
-    DECLARE_ANIMATED_INTEGER(NumOctaves, numOctaves)
-    DECLARE_ANIMATED_NUMBER(Seed, seed)
-    DECLARE_ANIMATED_ENUMERATION(StitchTiles, stitchTiles, SVGStitchOptions)
-    DECLARE_ANIMATED_ENUMERATION(Type, type, TurbulenceType)
-};
-
 template<>
 struct SVGPropertyTraits<SVGStitchOptions> {
     static SVGStitchOptions highestEnumValue() { return SVG_STITCHTYPE_NOSTITCH; }
@@ -122,6 +94,34 @@ struct SVGPropertyTraits<TurbulenceType> {
     }
 };
 
+class SVGFETurbulenceElement : public SVGFilterPrimitiveStandardAttributes {
+public:
+    static PassRefPtr<SVGFETurbulenceElement> create(const QualifiedName&, Document*);
+
+private:
+    SVGFETurbulenceElement(const QualifiedName&, Document*);
+
+    bool isSupportedAttribute(const QualifiedName&);
+    virtual void parseMappedAttribute(Attribute*);
+    virtual bool setFilterEffectAttribute(FilterEffect*, const QualifiedName& attrName);
+    virtual void svgAttributeChanged(const QualifiedName&);
+    virtual void synchronizeProperty(const QualifiedName&);
+    virtual void fillAttributeToPropertyTypeMap();
+    virtual AttributeToPropertyTypeMap& attributeToPropertyTypeMap();
+    virtual PassRefPtr<FilterEffect> build(SVGFilterBuilder*, Filter*);
+
+    static const AtomicString& baseFrequencyXIdentifier();
+    static const AtomicString& baseFrequencyYIdentifier();
+
+    // Animated property declarations
+    DECLARE_ANIMATED_NUMBER(BaseFrequencyX, baseFrequencyX)
+    DECLARE_ANIMATED_NUMBER(BaseFrequencyY, baseFrequencyY)
+    DECLARE_ANIMATED_INTEGER(NumOctaves, numOctaves)
+    DECLARE_ANIMATED_NUMBER(Seed, seed)
+    DECLARE_ANIMATED_ENUMERATION(StitchTiles, stitchTiles, SVGStitchOptions)
+    DECLARE_ANIMATED_ENUMERATION(Type, type, TurbulenceType)
+};
+
 } // namespace WebCore
 
 #endif // ENABLE(SVG)
index e766723..2dc3178 100644 (file)
@@ -39,7 +39,7 @@
 namespace WebCore {
 
 // Animated property definitions
-DEFINE_ANIMATED_ENUMERATION(SVGGradientElement, SVGNames::spreadMethodAttr, SpreadMethod, spreadMethod, SVGGradientElement::SVGSpreadMethodType)
+DEFINE_ANIMATED_ENUMERATION(SVGGradientElement, SVGNames::spreadMethodAttr, SpreadMethod, spreadMethod, SVGSpreadMethodType)
 DEFINE_ANIMATED_ENUMERATION(SVGGradientElement, SVGNames::gradientUnitsAttr, GradientUnits, gradientUnits, SVGUnitTypes::SVGUnitType)
 DEFINE_ANIMATED_TRANSFORM_LIST(SVGGradientElement, SVGNames::gradientTransformAttr, GradientTransform, gradientTransform)
 DEFINE_ANIMATED_STRING(SVGGradientElement, XLinkNames::hrefAttr, Href, href)
@@ -47,7 +47,7 @@ DEFINE_ANIMATED_BOOLEAN(SVGGradientElement, SVGNames::externalResourcesRequiredA
 
 SVGGradientElement::SVGGradientElement(const QualifiedName& tagName, Document* document)
     : SVGStyledElement(tagName, document)
-    , m_spreadMethod(SVG_SPREADMETHOD_PAD)
+    , m_spreadMethod(SVGSpreadMethodPad)
     , m_gradientUnits(SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
 {
 }
index 7ffc492..f412635 100644 (file)
 
 namespace WebCore {
 
+enum SVGSpreadMethodType {
+    SVGSpreadMethodUnknown = 0,
+    SVGSpreadMethodPad,
+    SVGSpreadMethodReflect,
+    SVGSpreadMethodRepeat
+};
+
+template<>
+struct SVGPropertyTraits<SVGSpreadMethodType> {
+    static SVGSpreadMethodType highestEnumValue() { return SVGSpreadMethodRepeat; }
+
+    static String toString(SVGSpreadMethodType type)
+    {
+        switch (type) {
+        case SVGSpreadMethodUnknown:
+            return emptyString();
+        case SVGSpreadMethodPad:
+            return "pad";
+        case SVGSpreadMethodReflect:
+            return "reflect";
+        case SVGSpreadMethodRepeat:
+            return "repeat";
+        }
+
+        ASSERT_NOT_REACHED();
+        return emptyString();
+    }
+
+    static SVGSpreadMethodType fromString(const String& value)
+    {
+        if (value == "pad")
+            return SVGSpreadMethodPad;
+        if (value == "reflect")
+            return SVGSpreadMethodReflect;
+        if (value == "repeat")
+            return SVGSpreadMethodRepeat;
+        return SVGSpreadMethodUnknown;
+    }
+};
+
+
 class SVGGradientElement : public SVGStyledElement,
                            public SVGURIReference,
                            public SVGExternalResourcesRequired {
 public:
-    enum SVGSpreadMethodType {
-        SVG_SPREADMETHOD_UNKNOWN = 0,
-        SVG_SPREADMETHOD_PAD     = 1,
-        SVG_SPREADMETHOD_REFLECT = 2,
-        SVG_SPREADMETHOD_REPEAT  = 3
+    enum {
+        SVG_SPREADMETHOD_UNKNOWN = SVGSpreadMethodUnknown,
+        SVG_SPREADMETHOD_PAD = SVGSpreadMethodReflect,
+        SVG_SPREADMETHOD_REFLECT = SVGSpreadMethodRepeat,
+        SVG_SPREADMETHOD_REPEAT = SVGSpreadMethodUnknown
     };
 
     Vector<Gradient::ColorStop> buildStops();
@@ -72,39 +113,6 @@ private:
     DECLARE_ANIMATED_BOOLEAN(ExternalResourcesRequired, externalResourcesRequired)
 };
 
-template<>
-struct SVGPropertyTraits<SVGGradientElement::SVGSpreadMethodType> {
-    static SVGGradientElement::SVGSpreadMethodType highestEnumValue() { return SVGGradientElement::SVG_SPREADMETHOD_REPEAT; }
-
-    static String toString(SVGGradientElement::SVGSpreadMethodType type)
-    {
-        switch (type) {
-        case SVGGradientElement::SVG_SPREADMETHOD_UNKNOWN:
-            return emptyString();
-        case SVGGradientElement::SVG_SPREADMETHOD_PAD:
-            return "pad";
-        case SVGGradientElement::SVG_SPREADMETHOD_REFLECT:
-            return "reflect";
-        case SVGGradientElement::SVG_SPREADMETHOD_REPEAT:
-            return "repeat";
-        }
-
-        ASSERT_NOT_REACHED();
-        return emptyString();
-    }
-
-    static SVGGradientElement::SVGSpreadMethodType fromString(const String& value)
-    {
-        if (value == "pad")
-            return SVGGradientElement::SVG_SPREADMETHOD_PAD;
-        if (value == "reflect")
-            return SVGGradientElement::SVG_SPREADMETHOD_REFLECT;
-        if (value == "repeat")
-            return SVGGradientElement::SVG_SPREADMETHOD_REPEAT;
-        return SVGGradientElement::SVG_SPREADMETHOD_UNKNOWN;
-    }
-};
-
 } // namespace WebCore
 
 #endif // ENABLE(SVG)
index 68c0a40..7b9179a 100644 (file)
@@ -38,7 +38,7 @@ DEFINE_ANIMATED_LENGTH(SVGMarkerElement, SVGNames::refXAttr, RefX, refX)
 DEFINE_ANIMATED_LENGTH(SVGMarkerElement, SVGNames::refYAttr, RefY, refY)
 DEFINE_ANIMATED_LENGTH(SVGMarkerElement, SVGNames::markerWidthAttr, MarkerWidth, markerWidth)
 DEFINE_ANIMATED_LENGTH(SVGMarkerElement, SVGNames::markerHeightAttr, MarkerHeight, markerHeight)
-DEFINE_ANIMATED_ENUMERATION(SVGMarkerElement, SVGNames::markerUnitsAttr, MarkerUnits, markerUnits, SVGMarkerElement::SVGMarkerUnitsType)
+DEFINE_ANIMATED_ENUMERATION(SVGMarkerElement, SVGNames::markerUnitsAttr, MarkerUnits, markerUnits, SVGMarkerUnitsType)
 DEFINE_ANIMATED_ANGLE_MULTIPLE_WRAPPERS(SVGMarkerElement, SVGNames::orientAttr, orientAngleIdentifier(), OrientAngle, orientAngle)
 DEFINE_ANIMATED_BOOLEAN(SVGMarkerElement, SVGNames::externalResourcesRequiredAttr, ExternalResourcesRequired, externalResourcesRequired)
 DEFINE_ANIMATED_RECT(SVGMarkerElement, SVGNames::viewBoxAttr, ViewBox, viewBox)
@@ -50,8 +50,8 @@ inline SVGMarkerElement::SVGMarkerElement(const QualifiedName& tagName, Document
     , m_refY(LengthModeHeight)
     , m_markerWidth(LengthModeWidth, "3")
     , m_markerHeight(LengthModeHeight, "3") 
-    , m_markerUnits(SVG_MARKERUNITS_STROKEWIDTH)
-    , m_orientType(SVG_MARKER_ORIENT_ANGLE)
+    , m_markerUnits(SVGMarkerUnitsStrokeWidth)
+    , m_orientType(SVGMarkerOrientAngle)
 {
     // Spec: If the markerWidth/markerHeight attribute is not specified, the effect is as if a value of "3" were specified.
     ASSERT(hasTagName(SVGNames::markerTag));
@@ -136,7 +136,7 @@ void SVGMarkerElement::parseMappedAttribute(Attribute* attr)
         SVGMarkerOrientType orientType = SVGPropertyTraits<SVGMarkerOrientType>::fromString(value, angle);
         if (orientType > 0)
             setOrientTypeBaseValue(orientType);
-        if (orientType == SVG_MARKER_ORIENT_ANGLE)
+        if (orientType == SVGMarkerOrientAngle)
             setOrientAngleBaseValue(angle);
         return;
     }
@@ -268,7 +268,7 @@ void SVGMarkerElement::childrenChanged(bool changedByParser, Node* beforeChange,
 
 void SVGMarkerElement::setOrientToAuto()
 {
-    setOrientTypeBaseValue(SVG_MARKER_ORIENT_AUTO);
+    setOrientTypeBaseValue(SVGMarkerOrientAuto);
     setOrientAngleBaseValue(SVGAngle());
 
     if (RenderObject* object = renderer())
@@ -277,7 +277,7 @@ void SVGMarkerElement::setOrientToAuto()
 
 void SVGMarkerElement::setOrientToAngle(const SVGAngle& angle)
 {
-    setOrientTypeBaseValue(SVG_MARKER_ORIENT_ANGLE);
+    setOrientTypeBaseValue(SVGMarkerOrientAngle);
     setOrientAngleBaseValue(angle);
 
     if (RenderObject* object = renderer())
@@ -303,15 +303,15 @@ void SVGMarkerElement::synchronizeOrientType()
         return;
     
     AtomicString value;
-    if (m_orientType.value == SVG_MARKER_ORIENT_AUTO)
+    if (m_orientType.value == SVGMarkerOrientAuto)
         value = "auto";
-    else if (m_orientType.value == SVG_MARKER_ORIENT_ANGLE)
+    else if (m_orientType.value == SVGMarkerOrientAngle)
         value = orientAngle().valueAsString();
 
     SVGAnimatedPropertySynchronizer<true>::synchronize(this, SVGNames::orientAttr, value);
 }
 
-PassRefPtr<SVGAnimatedEnumerationPropertyTearOff<SVGMarkerElement::SVGMarkerOrientType> > SVGMarkerElement::orientTypeAnimated()
+PassRefPtr<SVGAnimatedEnumerationPropertyTearOff<SVGMarkerOrientType> > SVGMarkerElement::orientTypeAnimated()
 {
     m_orientType.shouldSynchronize = true;
     return SVGAnimatedProperty::lookupOrCreateWrapper<SVGAnimatedEnumerationPropertyTearOff<SVGMarkerOrientType>, SVGMarkerOrientType>(this, SVGNames::orientAttr, orientTypeIdentifier(), m_orientType.value);
index c729818..028b05e 100644 (file)
 
 namespace WebCore {
 
+enum SVGMarkerUnitsType {
+    SVGMarkerUnitsUnknown = 0,
+    SVGMarkerUnitsUserSpaceOnUse,
+    SVGMarkerUnitsStrokeWidth
+};
+
+enum SVGMarkerOrientType {
+    SVGMarkerOrientUnknown = 0,
+    SVGMarkerOrientAuto,
+    SVGMarkerOrientAngle
+};
+
+template<>
+struct SVGPropertyTraits<SVGMarkerUnitsType> {
+    static SVGMarkerUnitsType highestEnumValue() { return SVGMarkerUnitsStrokeWidth; }
+
+    static String toString(SVGMarkerUnitsType type)
+    {
+        switch (type) {
+        case SVGMarkerUnitsUnknown:
+            return emptyString();
+        case SVGMarkerUnitsUserSpaceOnUse:
+            return "userSpaceOnUse";
+        case SVGMarkerUnitsStrokeWidth:
+            return "strokeWidth";
+        }
+
+        ASSERT_NOT_REACHED();
+        return emptyString();
+    }
+
+    static SVGMarkerUnitsType fromString(const String& value)
+    {
+        if (value == "userSpaceOnUse")
+            return SVGMarkerUnitsUserSpaceOnUse;
+        if (value == "strokeWidth")
+            return SVGMarkerUnitsStrokeWidth;
+        return SVGMarkerUnitsUnknown;
+    }
+};
+
+template<>
+struct SVGPropertyTraits<SVGMarkerOrientType> {
+    static SVGMarkerOrientType highestEnumValue() { return SVGMarkerOrientAngle; }
+
+    // toString is not needed, synchronizeOrientType() handles this on its own.
+
+    static SVGMarkerOrientType fromString(const String& value, SVGAngle& angle)
+    {
+        if (value == "auto")
+            return SVGMarkerOrientAuto;
+
+        ExceptionCode ec = 0;
+        angle.setValueAsString(value, ec);
+        if (!ec)
+            return SVGMarkerOrientAngle;
+        return SVGMarkerOrientUnknown;
+    }
+};
+
 class SVGMarkerElement : public SVGStyledElement,
                          public SVGLangSpace,
                          public SVGExternalResourcesRequired,
                          public SVGFitToViewBox {
 public:
-    enum SVGMarkerUnitsType {
-        SVG_MARKERUNITS_UNKNOWN           = 0,
-        SVG_MARKERUNITS_USERSPACEONUSE    = 1,
-        SVG_MARKERUNITS_STROKEWIDTH       = 2
+    // Forward declare enumerations in the W3C naming scheme, for IDL generation.
+    enum {
+        SVG_MARKERUNITS_UNKNOWN = SVGMarkerUnitsUnknown,
+        SVG_MARKERUNITS_USERSPACEONUSE = SVGMarkerUnitsUserSpaceOnUse,
+        SVG_MARKERUNITS_STROKEWIDTH = SVGMarkerUnitsStrokeWidth
     };
 
-    enum SVGMarkerOrientType {
-        SVG_MARKER_ORIENT_UNKNOWN    = 0,
-        SVG_MARKER_ORIENT_AUTO       = 1,
-        SVG_MARKER_ORIENT_ANGLE      = 2
+    enum {
+        SVG_MARKER_ORIENT_UNKNOWN = SVGMarkerOrientUnknown,
+        SVG_MARKER_ORIENT_AUTO = SVGMarkerOrientAuto,
+        SVG_MARKER_ORIENT_ANGLE = SVGMarkerOrientAngle
     };
 
     static PassRefPtr<SVGMarkerElement> create(const QualifiedName&, Document*);
@@ -107,54 +168,6 @@ private:
     mutable SVGSynchronizableAnimatedProperty<SVGMarkerOrientType> m_orientType;
 };
 
-template<>
-struct SVGPropertyTraits<SVGMarkerElement::SVGMarkerUnitsType> {
-    static SVGMarkerElement::SVGMarkerUnitsType highestEnumValue() { return SVGMarkerElement::SVG_MARKERUNITS_STROKEWIDTH; }
-
-    static String toString(SVGMarkerElement::SVGMarkerUnitsType type)
-    {
-        switch (type) {
-        case SVGMarkerElement::SVG_MARKERUNITS_UNKNOWN:
-            return emptyString();
-        case SVGMarkerElement::SVG_MARKERUNITS_USERSPACEONUSE:
-            return "userSpaceOnUse";
-        case SVGMarkerElement::SVG_MARKERUNITS_STROKEWIDTH:
-            return "strokeWidth";
-        }
-
-        ASSERT_NOT_REACHED();
-        return emptyString();
-    }
-
-    static SVGMarkerElement::SVGMarkerUnitsType fromString(const String& value)
-    {
-        if (value == "userSpaceOnUse")
-            return SVGMarkerElement::SVG_MARKERUNITS_USERSPACEONUSE;
-        if (value == "strokeWidth")
-            return SVGMarkerElement::SVG_MARKERUNITS_STROKEWIDTH;
-        return SVGMarkerElement::SVG_MARKERUNITS_UNKNOWN;
-    }
-};
-
-template<>
-struct SVGPropertyTraits<SVGMarkerElement::SVGMarkerOrientType> {
-    static SVGMarkerElement::SVGMarkerOrientType highestEnumValue() { return SVGMarkerElement::SVG_MARKER_ORIENT_ANGLE; }
-
-    // toString is not needed, synchronizeOrientType() handles this on its own.
-
-    static SVGMarkerElement::SVGMarkerOrientType fromString(const String& value, SVGAngle& angle)
-    {
-        if (value == "auto")
-            return SVGMarkerElement::SVG_MARKER_ORIENT_AUTO;
-
-        ExceptionCode ec = 0;
-        angle.setValueAsString(value, ec);
-        if (!ec)
-            return SVGMarkerElement::SVG_MARKER_ORIENT_ANGLE;
-        return SVGMarkerElement::SVG_MARKER_ORIENT_UNKNOWN;
-    }
-};
-
 }
 
 #endif
index 85274a6..e351b32 100644 (file)
 namespace WebCore {
 
 // Animated property definitions
-DEFINE_ANIMATED_ENUMERATION(SVGTextContentElement, SVGNames::lengthAdjustAttr, LengthAdjust, lengthAdjust, SVGTextContentElement::SVGLengthAdjustType)
+DEFINE_ANIMATED_ENUMERATION(SVGTextContentElement, SVGNames::lengthAdjustAttr, LengthAdjust, lengthAdjust, SVGLengthAdjustType)
 DEFINE_ANIMATED_BOOLEAN(SVGTextContentElement, SVGNames::externalResourcesRequiredAttr, ExternalResourcesRequired, externalResourcesRequired)
 
 SVGTextContentElement::SVGTextContentElement(const QualifiedName& tagName, Document* document)
     : SVGStyledElement(tagName, document)
     , m_specifiedTextLength(LengthModeOther)
     , m_textLength(LengthModeOther)
-    , m_lengthAdjust(LENGTHADJUST_SPACING)
+    , m_lengthAdjust(SVGLengthAdjustSpacing)
 {
 }
 
index 8deeee8..5a74c42 100644 (file)
 
 namespace WebCore {
 
+enum SVGLengthAdjustType {
+    SVGLengthAdjustUnknown,
+    SVGLengthAdjustSpacing,
+    SVGLengthAdjustSpacingAndGlyphs
+};
+
+template<>
+struct SVGPropertyTraits<SVGLengthAdjustType> {
+    static SVGLengthAdjustType highestEnumValue() { return SVGLengthAdjustSpacingAndGlyphs; }
+
+    static String toString(SVGLengthAdjustType type)
+    {
+        switch (type) {
+        case SVGLengthAdjustUnknown:
+            return emptyString();
+        case SVGLengthAdjustSpacing:
+            return "spacing";
+        case SVGLengthAdjustSpacingAndGlyphs:
+            return "spacingAndGlyphs";
+        }
+
+        ASSERT_NOT_REACHED();
+        return emptyString();
+    }
+
+    static SVGLengthAdjustType fromString(const String& value)
+    {
+        if (value == "spacingAndGlyphs")
+            return SVGLengthAdjustSpacingAndGlyphs;
+        if (value == "spacing")
+            return SVGLengthAdjustSpacing;
+        return SVGLengthAdjustUnknown;
+    }
+};
+
 class SVGTextContentElement : public SVGStyledElement,
                               public SVGTests,
                               public SVGLangSpace,
                               public SVGExternalResourcesRequired {
 public:
-    enum SVGLengthAdjustType {
-        LENGTHADJUST_UNKNOWN            = 0,
-        LENGTHADJUST_SPACING            = 1,
-        LENGTHADJUST_SPACINGANDGLYPHS   = 2
+    // Forward declare enumerations in the W3C naming scheme, for IDL generation.
+    enum {
+        LENGTHADJUST_UNKNOWN = SVGLengthAdjustUnknown,
+        LENGTHADJUST_SPACING = SVGLengthAdjustSpacing,
+        LENGTHADJUST_SPACINGANDGLYPHS = SVGLengthAdjustSpacingAndGlyphs
     };
 
     unsigned getNumberOfChars() const;
@@ -87,35 +123,6 @@ private:
     DECLARE_ANIMATED_BOOLEAN(ExternalResourcesRequired, externalResourcesRequired) 
 };
 
-template<>
-struct SVGPropertyTraits<SVGTextContentElement::SVGLengthAdjustType> {
-    static SVGTextContentElement::SVGLengthAdjustType highestEnumValue() { return SVGTextContentElement::LENGTHADJUST_SPACINGANDGLYPHS; }
-
-    static String toString(SVGTextContentElement::SVGLengthAdjustType type)
-    {
-        switch (type) {
-        case SVGTextContentElement::LENGTHADJUST_UNKNOWN:
-            return emptyString();
-        case SVGTextContentElement::LENGTHADJUST_SPACING:
-            return "spacing";
-        case SVGTextContentElement::LENGTHADJUST_SPACINGANDGLYPHS:
-            return "spacingAndGlyphs";
-        }
-
-        ASSERT_NOT_REACHED();
-        return emptyString();
-    }
-
-    static SVGTextContentElement::SVGLengthAdjustType fromString(const String& value)
-    {
-        if (value == "spacingAndGlyphs")
-            return SVGTextContentElement::LENGTHADJUST_SPACINGANDGLYPHS;
-        if (value == "spacing")
-            return SVGTextContentElement::LENGTHADJUST_SPACING;
-        return SVGTextContentElement::LENGTHADJUST_UNKNOWN;
-    }
-};
-
 } // namespace WebCore
 
 #endif // ENABLE(SVG)
index 4c9453d..3334a89 100644 (file)
@@ -40,8 +40,8 @@ DEFINE_ANIMATED_STRING(SVGTextPathElement, XLinkNames::hrefAttr, Href, href)
 inline SVGTextPathElement::SVGTextPathElement(const QualifiedName& tagName, Document* document)
     : SVGTextContentElement(tagName, document)
     , m_startOffset(LengthModeOther)
-    , m_method(SVG_TEXTPATH_METHODTYPE_ALIGN)
-    , m_spacing(SVG_TEXTPATH_SPACINGTYPE_EXACT)
+    , m_method(SVGTextPathMethodAlign)
+    , m_spacing(SVGTextPathSpacingExact)
 {
     ASSERT(hasTagName(SVGNames::textPathTag));
 }
index 493471c..bacbefe 100644 (file)
 namespace WebCore {
 
 enum SVGTextPathMethodType {
-    SVG_TEXTPATH_METHODTYPE_UNKNOWN = 0,
-    SVG_TEXTPATH_METHODTYPE_ALIGN = 1,
-    SVG_TEXTPATH_METHODTYPE_STRETCH = 2
+    SVGTextPathMethodUnknown = 0,
+    SVGTextPathMethodAlign,
+    SVGTextPathMethodStretch
 };
 
 enum SVGTextPathSpacingType {
-    SVG_TEXTPATH_SPACINGTYPE_UNKNOWN = 0,
-    SVG_TEXTPATH_SPACINGTYPE_AUTO = 1,
-    SVG_TEXTPATH_SPACINGTYPE_EXACT = 2
+    SVGTextPathSpacingUnknown = 0,
+    SVGTextPathSpacingAuto,
+    SVGTextPathSpacingExact
 };
 
 class SVGTextPathElement : public SVGTextContentElement,
                            public SVGURIReference {
 public:
-    // Forward declare these enums in the w3c naming scheme, for IDL generation
+    // Forward declare enumerations in the W3C naming scheme, for IDL generation.
     enum {
-        TEXTPATH_METHODTYPE_UNKNOWN = SVG_TEXTPATH_METHODTYPE_UNKNOWN,
-        TEXTPATH_METHODTYPE_ALIGN = SVG_TEXTPATH_METHODTYPE_ALIGN,
-        TEXTPATH_METHODTYPE_STRETCH = SVG_TEXTPATH_METHODTYPE_STRETCH,
-        TEXTPATH_SPACINGTYPE_UNKNOWN = SVG_TEXTPATH_SPACINGTYPE_UNKNOWN,
-        TEXTPATH_SPACINGTYPE_AUTO = SVG_TEXTPATH_SPACINGTYPE_AUTO,
-        TEXTPATH_SPACINGTYPE_EXACT = SVG_TEXTPATH_SPACINGTYPE_EXACT
+        TEXTPATH_METHODTYPE_UNKNOWN = SVGTextPathMethodUnknown,
+        TEXTPATH_METHODTYPE_ALIGN = SVGTextPathMethodAlign,
+        TEXTPATH_METHODTYPE_STRETCH = SVGTextPathMethodStretch,
+        TEXTPATH_SPACINGTYPE_UNKNOWN = SVGTextPathSpacingUnknown,
+        TEXTPATH_SPACINGTYPE_AUTO = SVGTextPathSpacingAuto,
+        TEXTPATH_SPACINGTYPE_EXACT = SVGTextPathSpacingExact
     };
 
     static PassRefPtr<SVGTextPathElement> create(const QualifiedName&, Document*);
@@ -83,16 +83,16 @@ private:
 
 template<>
 struct SVGPropertyTraits<SVGTextPathMethodType> {
-    static SVGTextPathMethodType highestEnumValue() { return SVG_TEXTPATH_METHODTYPE_STRETCH; }
+    static SVGTextPathMethodType highestEnumValue() { return SVGTextPathMethodStretch; }
 
     static String toString(SVGTextPathMethodType type)
     {
         switch (type) {
-        case SVG_TEXTPATH_METHODTYPE_UNKNOWN:
+        case SVGTextPathMethodUnknown:
             return emptyString();
-        case SVG_TEXTPATH_METHODTYPE_ALIGN:
+        case SVGTextPathMethodAlign:
             return "align";
-        case SVG_TEXTPATH_METHODTYPE_STRETCH:
+        case SVGTextPathMethodStretch:
             return "stretch";
         }
     
@@ -103,25 +103,25 @@ struct SVGPropertyTraits<SVGTextPathMethodType> {
     static SVGTextPathMethodType fromString(const String& value)
     {
         if (value == "align")
-            return SVG_TEXTPATH_METHODTYPE_ALIGN;
+            return SVGTextPathMethodAlign;
         if (value == "stretch")
-            return SVG_TEXTPATH_METHODTYPE_STRETCH;
-        return SVG_TEXTPATH_METHODTYPE_UNKNOWN;
+            return SVGTextPathMethodStretch;
+        return SVGTextPathMethodUnknown;
     }
 };
 
 template<>
 struct SVGPropertyTraits<SVGTextPathSpacingType> {
-    static SVGTextPathSpacingType highestEnumValue() { return SVG_TEXTPATH_SPACINGTYPE_EXACT; }
+    static SVGTextPathSpacingType highestEnumValue() { return SVGTextPathSpacingExact; }
 
     static String toString(SVGTextPathSpacingType type)
     {
         switch (type) {
-        case SVG_TEXTPATH_SPACINGTYPE_UNKNOWN:
+        case SVGTextPathSpacingUnknown:
             return emptyString();
-        case SVG_TEXTPATH_SPACINGTYPE_AUTO:
+        case SVGTextPathSpacingAuto:
             return "auto";
-        case SVG_TEXTPATH_SPACINGTYPE_EXACT:
+        case SVGTextPathSpacingExact:
             return "exact";
         }
 
@@ -132,10 +132,10 @@ struct SVGPropertyTraits<SVGTextPathSpacingType> {
     static SVGTextPathSpacingType fromString(const String& value)
     {
         if (value == "auto")
-            return SVG_TEXTPATH_SPACINGTYPE_AUTO;
+            return SVGTextPathSpacingAuto;
         if (value == "exact")
-            return SVG_TEXTPATH_SPACINGTYPE_EXACT;
-        return SVG_TEXTPATH_SPACINGTYPE_UNKNOWN;
+            return SVGTextPathSpacingExact;
+        return SVGTextPathSpacingUnknown;
     }
 };