2010-01-26 Nikolas Zimmermann <nzimmermann@rim.com>
authorzimmermann@webkit.org <zimmermann@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 27 Jan 2010 01:51:39 +0000 (01:51 +0000)
committerzimmermann@webkit.org <zimmermann@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 27 Jan 2010 01:51:39 +0000 (01:51 +0000)
        Reviewed by Oliver Hunt.

        SVG consumes way too much memory to store animated properties in the DOM
        https://bugs.webkit.org/show_bug.cgi?id=34188

        Shrink WebCore library size to 75% (measured in debug builds) and reduce SVG memory usage to <25%.
        Adding Oliver testcase as manual-tests/svg-node-count-vs-scroll.xhtml, which creates an arbitary number of
        rects (50.000 <rect> elements added to the DOM by default) - memory usage down to 111M from 503M (RPRVT).
        The SVG DOM side is almost fine, still some optimizations possible, that will be implemented soon - next
        target is the SVG render tree, there are plenty of possibilities to reduce memory usage there.

        Redesign the way we store animated properties in the individual SVG*Element files. Short story: In order
        to support SVG DOM through the bindings (e.g. JS) we need to associate SVGAnimatedProperty objects with
        the SVGElement object that created it - we used to store this pointer directly in the SVGAnimatedProperty.
        This means, every SVGAnimatedProperty stored in a SVGRectElement, stored a pointer to the SVGRectElement, resulting
        in excessive memory usage. This is now properly implemented, without wasting tons of memory. Unfortunately this
        requires touching all SVG*Element files.

        Detailed list of changes:
        - Remove template bloat by not specializing class templates for each attributeName/tagName combination. Instead
          SVGAnimatedProperty is a non-specialized template class now, only depending on the AnimatedType (ie. SVGLength for SVGAnimatedLength)
          -> This heavily reduces the generated code, thus shrinking WebCore size. I hope we can build windows again without SVGAllInOne.cpp

        - Remove "exportStrings" / "exportString" handling from make_names.pl - SVG defined string literals for each QualifiedName,
          in order to use template specialization based on "const char*" parameters. All that bloat is gone, so there's no need for it anymore.

        - Redesign SVGAnimatedProperty so it does not need any back-pointers to the SVGElement that created it

        - Don't actually store the XML DOM attribute name associated with a SVG DOM property in SVGAnimatedProperty, move the associatedAttributeName()
          function inside the macro declaration and just return the passed macro parameter DOMAttribute there, storing is inefficient and useless.

        - Remove SynchronizablePropertyController, which was living in SVGElement as member variable, keeping a HashMap<AttributeName, SVGAnimatedProperty>.
          It was needed before to lookup a SVGAnimatedProperty for a XML DOM attribute, in order to synchronize SVG <-> XML dom properties/attributes.
          Instead just add a "synchronizeProperty(const QualifiedName&)" method to all SVG*Element classes. As each SVG*Element class knows about its
          animated properties it can just ask them to synchronize themselves - no need for any dynamic lookups anymore.

        - Remove SynchronizableTypeWrapper which added more complexity for the sake of SVG <-> XML DOM synchronization, all replaced by synchronizeProperty.

        - Pass around any POD objects as const references, instead of copying them for no reason.

        - Clean up SVGAnimatedProperty, splitting up into SVGAnimatedProperty/PropertySynchronizer/PropertyTraits.

        - Remove baseValue/setBaseValue code from SVGDocumentExtensions, not needed anymore.

        ... and tons of changes to all SVG*Element classes, adapting to the new way of handling animated properties.

        * GNUmakefile.am: Remove Synchronizable* from build, add new SVGAnimatedPropertySynchronizer/Traits files
        * WebCore.gypi: Ditto.
        * WebCore.vcproj/WebCore.vcproj: Ditto.
        * WebCore.xcodeproj/project.pbxproj: Ditto.
        * bindings/js/JSSVGPODTypeWrapper.h: Change synchronization callback signatures, as we pass around const-references now.
        * dom/Element.cpp: Let updateAnimatedSVGAttribute take a QualifiedName instead of pure Strings.
        (WebCore::Element::getAttribute):
        (WebCore::Element::hasAttributes):
        * dom/Element.h:
        (WebCore::Element::updateAnimatedSVGAttribute):
        (WebCore::Element::attributes):
        * dom/make_names.pl: Remove SVG specific "exportString" / "exportStrings" functionality, see above.
        * html/HTMLAttributeNames.in: Remove "exportString" tag from "className" attribute.
        * manual-tests/svg-node-count-vs-scroll.xhtml: Added. Can be used to verify memory consumption with a lot of DOM objects.
        * mathml/mathattrs.in: MathML doesn't need "exportStrings" - remove it.
        * mathml/mathtags.in: Ditto.
        * svg/SVGAElement.cpp:
        (WebCore::SVGAElement::SVGAElement):
        (WebCore::SVGAElement::synchronizeProperty):
        * svg/SVGAElement.h:
        * svg/SVGAllInOne.cpp: Remove SynchronizablePropertyController.cpp
        * svg/SVGAltGlyphElement.cpp:
        (WebCore::SVGAltGlyphElement::SVGAltGlyphElement):
        (WebCore::SVGAltGlyphElement::synchronizeProperty):
        * svg/SVGAltGlyphElement.h:
        * svg/SVGAnimateTransformElement.cpp:
        (WebCore::SVGAnimateTransformElement::applyResultsToTarget):
        * svg/SVGAnimatedProperty.h: Rewritten, see above for details.
        (WebCore::SVGAnimatedPropertyTearOff::create):
        (WebCore::SVGAnimatedPropertyTearOff::setBaseVal):
        (WebCore::SVGAnimatedPropertyTearOff::setAnimVal):
        (WebCore::SVGAnimatedPropertyTearOff::baseVal):
        (WebCore::SVGAnimatedPropertyTearOff::animVal):
        (WebCore::SVGAnimatedPropertyTearOff::associatedAttributeName):
        (WebCore::SVGAnimatedPropertyTearOff::SVGAnimatedPropertyTearOff):
        (WebCore::SVGAnimatedPropertyTearOff::~SVGAnimatedPropertyTearOff):
        (WebCore::SVGAnimatedProperty::~SVGAnimatedProperty):
        (WebCore::SVGAnimatedProperty::SVGAnimatedProperty):
        (WebCore::SVGAnimatedProperty::value):
        (WebCore::SVGAnimatedProperty::baseValue):
        (WebCore::SVGAnimatedProperty::setValue):
        (WebCore::SVGAnimatedProperty::setBaseValue):
        (WebCore::SVGAnimatedProperty::shouldSynchronize):
        (WebCore::SVGAnimatedProperty::setShouldSynchronize):
        * svg/SVGAnimatedPropertySynchronizer.h: Added.
        (WebCore::):
        * svg/SVGAnimatedPropertyTraits.h: Added.
        (WebCore::):
        * svg/SVGAnimatedTemplate.h: Move SVGAnimatedPropertyTraits into its own file.
        (WebCore::SVGAnimatedTemplate::forgetWrapper):
        (WebCore::lookupOrCreateWrapper):
        * svg/SVGAnimationElement.cpp:
        (WebCore::SVGAnimationElement::SVGAnimationElement):
        (WebCore::SVGAnimationElement::synchronizeProperty):
        * svg/SVGAnimationElement.h:
        * svg/SVGCircleElement.cpp:
        (WebCore::SVGCircleElement::SVGCircleElement):
        (WebCore::SVGCircleElement::synchronizeProperty):
        * svg/SVGCircleElement.h:
        * svg/SVGClipPathElement.cpp:
        (WebCore::SVGClipPathElement::SVGClipPathElement):
        (WebCore::SVGClipPathElement::synchronizeProperty):
        * svg/SVGClipPathElement.h:
        * svg/SVGComponentTransferFunctionElement.cpp:
        (WebCore::SVGComponentTransferFunctionElement::SVGComponentTransferFunctionElement):
        (WebCore::SVGComponentTransferFunctionElement::parseMappedAttribute):
        (WebCore::SVGComponentTransferFunctionElement::synchronizeProperty):
        * svg/SVGComponentTransferFunctionElement.h:
        * svg/SVGCursorElement.cpp:
        (WebCore::SVGCursorElement::SVGCursorElement):
        (WebCore::SVGCursorElement::synchronizeProperty):
        * svg/SVGCursorElement.h:
        * svg/SVGDefsElement.cpp:
        (WebCore::SVGDefsElement::SVGDefsElement):
        (WebCore::SVGDefsElement::synchronizeProperty):
        * svg/SVGDefsElement.h:
        * svg/SVGDocumentExtensions.h:
        * svg/SVGElement.cpp: Adapt to synchronization changes: use synchronizeProperty() call, instead of SynchronizablePropertyController.
        (WebCore::SVGElement::updateAnimatedSVGAttribute):
        * svg/SVGElement.h: Don't store SynchronizablePropertyController anymore, it's gone.
        (WebCore::SVGElement::synchronizeProperty):
        (WebCore::SVGElement::setSynchronizedSVGAttributes):
        * svg/SVGEllipseElement.cpp:
        (WebCore::SVGEllipseElement::SVGEllipseElement):
        (WebCore::SVGEllipseElement::synchronizeProperty):
        * svg/SVGEllipseElement.h:
        * svg/SVGExternalResourcesRequired.cpp:
        * svg/SVGExternalResourcesRequired.h:
        * svg/SVGFEBlendElement.cpp:
        (WebCore::SVGFEBlendElement::SVGFEBlendElement):
        (WebCore::SVGFEBlendElement::synchronizeProperty):
        * svg/SVGFEBlendElement.h:
        * svg/SVGFEColorMatrixElement.cpp:
        (WebCore::SVGFEColorMatrixElement::SVGFEColorMatrixElement):
        (WebCore::SVGFEColorMatrixElement::synchronizeProperty):
        * svg/SVGFEColorMatrixElement.h:
        * svg/SVGFEComponentTransferElement.cpp:
        (WebCore::SVGFEComponentTransferElement::SVGFEComponentTransferElement):
        (WebCore::SVGFEComponentTransferElement::synchronizeProperty):
        * svg/SVGFEComponentTransferElement.h:
        * svg/SVGFECompositeElement.cpp:
        (WebCore::SVGFECompositeElement::SVGFECompositeElement):
        (WebCore::SVGFECompositeElement::parseMappedAttribute):
        (WebCore::SVGFECompositeElement::synchronizeProperty):
        * svg/SVGFECompositeElement.h:
        * svg/SVGFEDiffuseLightingElement.cpp:
        (WebCore::SVGFEDiffuseLightingElement::SVGFEDiffuseLightingElement):
        (WebCore::SVGFEDiffuseLightingElement::synchronizeProperty):
        * svg/SVGFEDiffuseLightingElement.h:
        * svg/SVGFEDisplacementMapElement.cpp:
        (WebCore::SVGFEDisplacementMapElement::SVGFEDisplacementMapElement):
        (WebCore::SVGFEDisplacementMapElement::synchronizeProperty):
        * svg/SVGFEDisplacementMapElement.h:
        * svg/SVGFEGaussianBlurElement.cpp:
        (WebCore::SVGFEGaussianBlurElement::SVGFEGaussianBlurElement):
        (WebCore::SVGFEGaussianBlurElement::synchronizeProperty):
        * svg/SVGFEGaussianBlurElement.h:
        * svg/SVGFEImageElement.cpp:
        (WebCore::SVGFEImageElement::SVGFEImageElement):
        (WebCore::SVGFEImageElement::synchronizeProperty):
        * svg/SVGFEImageElement.h:
        * svg/SVGFELightElement.cpp:
        (WebCore::SVGFELightElement::SVGFELightElement):
        (WebCore::SVGFELightElement::synchronizeProperty):
        * svg/SVGFELightElement.h:
        * svg/SVGFEMergeNodeElement.cpp:
        (WebCore::SVGFEMergeNodeElement::SVGFEMergeNodeElement):
        (WebCore::SVGFEMergeNodeElement::synchronizeProperty):
        * svg/SVGFEMergeNodeElement.h:
        * svg/SVGFEMorphologyElement.cpp:
        (WebCore::SVGFEMorphologyElement::SVGFEMorphologyElement):
        (WebCore::SVGFEMorphologyElement::synchronizeProperty):
        * svg/SVGFEMorphologyElement.h:
        * svg/SVGFEOffsetElement.cpp:
        (WebCore::SVGFEOffsetElement::SVGFEOffsetElement):
        (WebCore::SVGFEOffsetElement::synchronizeProperty):
        * svg/SVGFEOffsetElement.h:
        * svg/SVGFESpecularLightingElement.cpp:
        (WebCore::SVGFESpecularLightingElement::SVGFESpecularLightingElement):
        (WebCore::SVGFESpecularLightingElement::synchronizeProperty):
        * svg/SVGFESpecularLightingElement.h:
        * svg/SVGFETileElement.cpp:
        (WebCore::SVGFETileElement::SVGFETileElement):
        (WebCore::SVGFETileElement::synchronizeProperty):
        * svg/SVGFETileElement.h:
        * svg/SVGFETurbulenceElement.cpp:
        (WebCore::SVGFETurbulenceElement::SVGFETurbulenceElement):
        (WebCore::SVGFETurbulenceElement::synchronizeProperty):
        * svg/SVGFETurbulenceElement.h:
        * svg/SVGFilterElement.cpp:
        (WebCore::SVGFilterElement::SVGFilterElement):
        (WebCore::SVGFilterElement::synchronizeProperty):
        * svg/SVGFilterElement.h:
        * svg/SVGFilterPrimitiveStandardAttributes.cpp:
        (WebCore::SVGFilterPrimitiveStandardAttributes::SVGFilterPrimitiveStandardAttributes):
        (WebCore::SVGFilterPrimitiveStandardAttributes::synchronizeProperty):
        * svg/SVGFilterPrimitiveStandardAttributes.h:
        * svg/SVGFitToViewBox.cpp:
        * svg/SVGFitToViewBox.h:
        * svg/SVGFontElement.cpp:
        (WebCore::SVGFontElement::SVGFontElement):
        (WebCore::SVGFontElement::synchronizeProperty):
        * svg/SVGFontElement.h:
        * svg/SVGForeignObjectElement.cpp:
        (WebCore::SVGForeignObjectElement::SVGForeignObjectElement):
        (WebCore::SVGForeignObjectElement::synchronizeProperty):
        * svg/SVGForeignObjectElement.h:
        * svg/SVGGElement.cpp:
        (WebCore::SVGGElement::SVGGElement):
        (WebCore::SVGGElement::synchronizeProperty):
        * svg/SVGGElement.h:
        * svg/SVGGradientElement.cpp:
        (WebCore::SVGGradientElement::SVGGradientElement):
        (WebCore::SVGGradientElement::synchronizeProperty):
        * svg/SVGGradientElement.h:
        * svg/SVGImageElement.cpp:
        (WebCore::SVGImageElement::SVGImageElement):
        (WebCore::SVGImageElement::synchronizeProperty):
        * svg/SVGImageElement.h:
        * svg/SVGLineElement.cpp:
        (WebCore::SVGLineElement::SVGLineElement):
        (WebCore::SVGLineElement::synchronizeProperty):
        * svg/SVGLineElement.h:
        * svg/SVGLinearGradientElement.cpp:
        (WebCore::SVGLinearGradientElement::SVGLinearGradientElement):
        (WebCore::SVGLinearGradientElement::synchronizeProperty):
        * svg/SVGLinearGradientElement.h:
        * svg/SVGList.h: Adapt to const-reference changes.
        (WebCore::SVGPODListItem::setValue):
        * svg/SVGMPathElement.cpp:
        (WebCore::SVGMPathElement::SVGMPathElement):
        (WebCore::SVGMPathElement::synchronizeProperty):
        * svg/SVGMPathElement.h:
        * svg/SVGMarkerElement.cpp:
        (WebCore::SVGMarkerElement::SVGMarkerElement):
        (WebCore::SVGMarkerElement::synchronizeProperty):
        * svg/SVGMarkerElement.h:
        * svg/SVGMaskElement.cpp:
        (WebCore::SVGMaskElement::SVGMaskElement):
        (WebCore::SVGMaskElement::synchronizeProperty):
        * svg/SVGMaskElement.h:
        * svg/SVGPathElement.cpp:
        (WebCore::SVGPathElement::SVGPathElement):
        (WebCore::SVGPathElement::synchronizeProperty):
        * svg/SVGPathElement.h:
        * svg/SVGPatternElement.cpp:
        (WebCore::SVGPatternElement::SVGPatternElement):
        (WebCore::SVGPatternElement::synchronizeProperty):
        * svg/SVGPatternElement.h:
        * svg/SVGPolyElement.cpp:
        (WebCore::SVGPolyElement::SVGPolyElement):
        (WebCore::SVGPolyElement::svgAttributeChanged):
        (WebCore::SVGPolyElement::synchronizeProperty):
        * svg/SVGPolyElement.h:
        * svg/SVGRadialGradientElement.cpp:
        (WebCore::SVGRadialGradientElement::SVGRadialGradientElement):
        (WebCore::SVGRadialGradientElement::synchronizeProperty):
        * svg/SVGRadialGradientElement.h:
        * svg/SVGRectElement.cpp:
        (WebCore::SVGRectElement::SVGRectElement):
        (WebCore::SVGRectElement::synchronizeProperty):
        * svg/SVGRectElement.h:
        * svg/SVGSVGElement.cpp:
        (WebCore::SVGSVGElement::SVGSVGElement):
        (WebCore::SVGSVGElement::synchronizeProperty):
        * svg/SVGSVGElement.h:
        * svg/SVGScriptElement.cpp:
        (WebCore::SVGScriptElement::SVGScriptElement):
        (WebCore::SVGScriptElement::synchronizeProperty):
        * svg/SVGScriptElement.h:
        * svg/SVGStopElement.cpp:
        (WebCore::SVGStopElement::SVGStopElement):
        (WebCore::SVGStopElement::synchronizeProperty):
        * svg/SVGStopElement.h:
        * svg/SVGStyledElement.cpp:
        (WebCore::SVGStyledElement::SVGStyledElement):
        (WebCore::SVGStyledElement::parseMappedAttribute):
        (WebCore::SVGStyledElement::synchronizeProperty):
        * svg/SVGStyledElement.h:
        * svg/SVGStyledTransformableElement.cpp:
        (WebCore::SVGStyledTransformableElement::SVGStyledTransformableElement):
        (WebCore::SVGStyledTransformableElement::synchronizeProperty):
        * svg/SVGStyledTransformableElement.h:
        * svg/SVGSwitchElement.cpp:
        (WebCore::SVGSwitchElement::SVGSwitchElement):
        (WebCore::SVGSwitchElement::synchronizeProperty):
        * svg/SVGSwitchElement.h:
        * svg/SVGSymbolElement.cpp:
        (WebCore::SVGSymbolElement::SVGSymbolElement):
        (WebCore::SVGSymbolElement::synchronizeProperty):
        * svg/SVGSymbolElement.h:
        * svg/SVGTRefElement.cpp:
        (WebCore::SVGTRefElement::SVGTRefElement):
        (WebCore::SVGTRefElement::synchronizeProperty):
        * svg/SVGTRefElement.h:
        * svg/SVGTextContentElement.cpp:
        (WebCore::SVGTextContentElement::SVGTextContentElement):
        (WebCore::SVGTextContentElement::synchronizeProperty):
        * svg/SVGTextContentElement.h:
        * svg/SVGTextElement.cpp:
        (WebCore::SVGTextElement::SVGTextElement):
        (WebCore::SVGTextElement::synchronizeProperty):
        * svg/SVGTextElement.h:
        * svg/SVGTextPathElement.cpp:
        (WebCore::SVGTextPathElement::SVGTextPathElement):
        (WebCore::SVGTextPathElement::synchronizeProperty):
        * svg/SVGTextPathElement.h:
        * svg/SVGTextPositioningElement.cpp:
        (WebCore::SVGTextPositioningElement::SVGTextPositioningElement):
        (WebCore::SVGTextPositioningElement::synchronizeProperty):
        * svg/SVGTextPositioningElement.h:
        * svg/SVGURIReference.cpp:
        * svg/SVGURIReference.h:
        * svg/SVGUseElement.cpp:
        (WebCore::SVGUseElement::SVGUseElement):
        (WebCore::SVGUseElement::synchronizeProperty):
        * svg/SVGUseElement.h:
        * svg/SVGViewElement.cpp:
        (WebCore::SVGViewElement::SVGViewElement):
        (WebCore::SVGViewElement::synchronizeProperty):
        * svg/SVGViewElement.h:
        * svg/SVGViewSpec.cpp:
        (WebCore::SVGViewSpec::SVGViewSpec):
        * svg/SVGViewSpec.h:
        (WebCore::SVGViewSpec::contextElement):
        * svg/SynchronizablePropertyController.cpp: Removed.
        * svg/SynchronizablePropertyController.h: Removed.
        * svg/SynchronizableTypeWrapper.h: Removed.
        * svg/svgattrs.in: Remove "exportStrings" tag.
        * svg/svgtags.in: Ditto.
        * svg/xlinkattrs.in:

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

148 files changed:
WebCore/ChangeLog
WebCore/Configurations/Base.xcconfig
WebCore/GNUmakefile.am
WebCore/WebCore.gypi
WebCore/WebCore.vcproj/WebCore.vcproj
WebCore/WebCore.xcodeproj/project.pbxproj
WebCore/bindings/js/JSSVGPODTypeWrapper.h
WebCore/dom/Element.cpp
WebCore/dom/Element.h
WebCore/dom/make_names.pl
WebCore/html/HTMLAttributeNames.in
WebCore/manual-tests/svg-node-count-vs-scroll.xhtml [new file with mode: 0644]
WebCore/mathml/mathattrs.in
WebCore/mathml/mathtags.in
WebCore/svg/SVGAElement.cpp
WebCore/svg/SVGAElement.h
WebCore/svg/SVGAllInOne.cpp
WebCore/svg/SVGAltGlyphElement.cpp
WebCore/svg/SVGAltGlyphElement.h
WebCore/svg/SVGAnimateTransformElement.cpp
WebCore/svg/SVGAnimatedProperty.h
WebCore/svg/SVGAnimatedPropertySynchronizer.h [new file with mode: 0644]
WebCore/svg/SVGAnimatedPropertyTraits.h [new file with mode: 0644]
WebCore/svg/SVGAnimatedTemplate.h
WebCore/svg/SVGAnimationElement.cpp
WebCore/svg/SVGAnimationElement.h
WebCore/svg/SVGCircleElement.cpp
WebCore/svg/SVGCircleElement.h
WebCore/svg/SVGClipPathElement.cpp
WebCore/svg/SVGClipPathElement.h
WebCore/svg/SVGComponentTransferFunctionElement.cpp
WebCore/svg/SVGComponentTransferFunctionElement.h
WebCore/svg/SVGCursorElement.cpp
WebCore/svg/SVGCursorElement.h
WebCore/svg/SVGDefsElement.cpp
WebCore/svg/SVGDefsElement.h
WebCore/svg/SVGDocumentExtensions.h
WebCore/svg/SVGElement.cpp
WebCore/svg/SVGElement.h
WebCore/svg/SVGEllipseElement.cpp
WebCore/svg/SVGEllipseElement.h
WebCore/svg/SVGExternalResourcesRequired.cpp
WebCore/svg/SVGExternalResourcesRequired.h
WebCore/svg/SVGFEBlendElement.cpp
WebCore/svg/SVGFEBlendElement.h
WebCore/svg/SVGFEColorMatrixElement.cpp
WebCore/svg/SVGFEColorMatrixElement.h
WebCore/svg/SVGFEComponentTransferElement.cpp
WebCore/svg/SVGFEComponentTransferElement.h
WebCore/svg/SVGFECompositeElement.cpp
WebCore/svg/SVGFECompositeElement.h
WebCore/svg/SVGFEDiffuseLightingElement.cpp
WebCore/svg/SVGFEDiffuseLightingElement.h
WebCore/svg/SVGFEDisplacementMapElement.cpp
WebCore/svg/SVGFEDisplacementMapElement.h
WebCore/svg/SVGFEGaussianBlurElement.cpp
WebCore/svg/SVGFEGaussianBlurElement.h
WebCore/svg/SVGFEImageElement.cpp
WebCore/svg/SVGFEImageElement.h
WebCore/svg/SVGFELightElement.cpp
WebCore/svg/SVGFELightElement.h
WebCore/svg/SVGFEMergeNodeElement.cpp
WebCore/svg/SVGFEMergeNodeElement.h
WebCore/svg/SVGFEMorphologyElement.cpp
WebCore/svg/SVGFEMorphologyElement.h
WebCore/svg/SVGFEOffsetElement.cpp
WebCore/svg/SVGFEOffsetElement.h
WebCore/svg/SVGFESpecularLightingElement.cpp
WebCore/svg/SVGFESpecularLightingElement.h
WebCore/svg/SVGFETileElement.cpp
WebCore/svg/SVGFETileElement.h
WebCore/svg/SVGFETurbulenceElement.cpp
WebCore/svg/SVGFETurbulenceElement.h
WebCore/svg/SVGFilterElement.cpp
WebCore/svg/SVGFilterElement.h
WebCore/svg/SVGFilterPrimitiveStandardAttributes.cpp
WebCore/svg/SVGFilterPrimitiveStandardAttributes.h
WebCore/svg/SVGFitToViewBox.cpp
WebCore/svg/SVGFitToViewBox.h
WebCore/svg/SVGFontElement.cpp
WebCore/svg/SVGFontElement.h
WebCore/svg/SVGForeignObjectElement.cpp
WebCore/svg/SVGForeignObjectElement.h
WebCore/svg/SVGGElement.cpp
WebCore/svg/SVGGElement.h
WebCore/svg/SVGGradientElement.cpp
WebCore/svg/SVGGradientElement.h
WebCore/svg/SVGImageElement.cpp
WebCore/svg/SVGImageElement.h
WebCore/svg/SVGLineElement.cpp
WebCore/svg/SVGLineElement.h
WebCore/svg/SVGLinearGradientElement.cpp
WebCore/svg/SVGLinearGradientElement.h
WebCore/svg/SVGList.h
WebCore/svg/SVGMPathElement.cpp
WebCore/svg/SVGMPathElement.h
WebCore/svg/SVGMarkerElement.cpp
WebCore/svg/SVGMarkerElement.h
WebCore/svg/SVGMaskElement.cpp
WebCore/svg/SVGMaskElement.h
WebCore/svg/SVGPathElement.cpp
WebCore/svg/SVGPathElement.h
WebCore/svg/SVGPatternElement.cpp
WebCore/svg/SVGPatternElement.h
WebCore/svg/SVGPolyElement.cpp
WebCore/svg/SVGPolyElement.h
WebCore/svg/SVGRadialGradientElement.cpp
WebCore/svg/SVGRadialGradientElement.h
WebCore/svg/SVGRectElement.cpp
WebCore/svg/SVGRectElement.h
WebCore/svg/SVGSVGElement.cpp
WebCore/svg/SVGSVGElement.h
WebCore/svg/SVGScriptElement.cpp
WebCore/svg/SVGScriptElement.h
WebCore/svg/SVGStopElement.cpp
WebCore/svg/SVGStopElement.h
WebCore/svg/SVGStyledElement.cpp
WebCore/svg/SVGStyledElement.h
WebCore/svg/SVGStyledTransformableElement.cpp
WebCore/svg/SVGStyledTransformableElement.h
WebCore/svg/SVGSwitchElement.cpp
WebCore/svg/SVGSwitchElement.h
WebCore/svg/SVGSymbolElement.cpp
WebCore/svg/SVGSymbolElement.h
WebCore/svg/SVGTRefElement.cpp
WebCore/svg/SVGTRefElement.h
WebCore/svg/SVGTextContentElement.cpp
WebCore/svg/SVGTextContentElement.h
WebCore/svg/SVGTextElement.cpp
WebCore/svg/SVGTextElement.h
WebCore/svg/SVGTextPathElement.cpp
WebCore/svg/SVGTextPathElement.h
WebCore/svg/SVGTextPositioningElement.cpp
WebCore/svg/SVGTextPositioningElement.h
WebCore/svg/SVGURIReference.cpp
WebCore/svg/SVGURIReference.h
WebCore/svg/SVGUseElement.cpp
WebCore/svg/SVGUseElement.h
WebCore/svg/SVGViewElement.cpp
WebCore/svg/SVGViewElement.h
WebCore/svg/SVGViewSpec.cpp
WebCore/svg/SVGViewSpec.h
WebCore/svg/SynchronizablePropertyController.cpp [deleted file]
WebCore/svg/SynchronizablePropertyController.h [deleted file]
WebCore/svg/SynchronizableTypeWrapper.h [deleted file]
WebCore/svg/svgattrs.in
WebCore/svg/svgtags.in
WebCore/svg/xlinkattrs.in

index 12a48f4..d179646 100644 (file)
@@ -1,3 +1,343 @@
+2010-01-26  Nikolas Zimmermann  <nzimmermann@rim.com>
+
+        Reviewed by Oliver Hunt.
+
+        SVG consumes way too much memory to store animated properties in the DOM
+        https://bugs.webkit.org/show_bug.cgi?id=34188
+
+        Shrink WebCore library size to 75% (measured in debug builds) and reduce SVG memory usage to <25%.
+        Adding Oliver testcase as manual-tests/svg-node-count-vs-scroll.xhtml, which creates an arbitary number of
+        rects (50.000 <rect> elements added to the DOM by default) - memory usage down to 111M from 503M (RPRVT).
+        The SVG DOM side is almost fine, still some optimizations possible, that will be implemented soon - next
+        target is the SVG render tree, there are plenty of possibilities to reduce memory usage there.
+
+        Redesign the way we store animated properties in the individual SVG*Element files. Short story: In order
+        to support SVG DOM through the bindings (e.g. JS) we need to associate SVGAnimatedProperty objects with
+        the SVGElement object that created it - we used to store this pointer directly in the SVGAnimatedProperty.
+        This means, every SVGAnimatedProperty stored in a SVGRectElement, stored a pointer to the SVGRectElement, resulting
+        in excessive memory usage. This is now properly implemented, without wasting tons of memory. Unfortunately this
+        requires touching all SVG*Element files.
+
+        Detailed list of changes:
+        - Remove template bloat by not specializing class templates for each attributeName/tagName combination. Instead
+          SVGAnimatedProperty is a non-specialized template class now, only depending on the AnimatedType (ie. SVGLength for SVGAnimatedLength)
+          -> This heavily reduces the generated code, thus shrinking WebCore size. I hope we can build windows again without SVGAllInOne.cpp
+
+        - Remove "exportStrings" / "exportString" handling from make_names.pl - SVG defined string literals for each QualifiedName,
+          in order to use template specialization based on "const char*" parameters. All that bloat is gone, so there's no need for it anymore.
+
+        - Redesign SVGAnimatedProperty so it does not need any back-pointers to the SVGElement that created it
+
+        - Don't actually store the XML DOM attribute name associated with a SVG DOM property in SVGAnimatedProperty, move the associatedAttributeName()
+          function inside the macro declaration and just return the passed macro parameter DOMAttribute there, storing is inefficient and useless.
+
+        - Remove SynchronizablePropertyController, which was living in SVGElement as member variable, keeping a HashMap<AttributeName, SVGAnimatedProperty>.
+          It was needed before to lookup a SVGAnimatedProperty for a XML DOM attribute, in order to synchronize SVG <-> XML dom properties/attributes.
+          Instead just add a "synchronizeProperty(const QualifiedName&)" method to all SVG*Element classes. As each SVG*Element class knows about its
+          animated properties it can just ask them to synchronize themselves - no need for any dynamic lookups anymore.
+
+        - Remove SynchronizableTypeWrapper which added more complexity for the sake of SVG <-> XML DOM synchronization, all replaced by synchronizeProperty.
+
+        - Pass around any POD objects as const references, instead of copying them for no reason.
+
+        - Clean up SVGAnimatedProperty, splitting up into SVGAnimatedProperty/PropertySynchronizer/PropertyTraits.
+
+        - Remove baseValue/setBaseValue code from SVGDocumentExtensions, not needed anymore.
+
+        ... and tons of changes to all SVG*Element classes, adapting to the new way of handling animated properties.
+
+        * GNUmakefile.am: Remove Synchronizable* from build, add new SVGAnimatedPropertySynchronizer/Traits files
+        * WebCore.gypi: Ditto.
+        * WebCore.vcproj/WebCore.vcproj: Ditto.
+        * WebCore.xcodeproj/project.pbxproj: Ditto.
+        * bindings/js/JSSVGPODTypeWrapper.h: Change synchronization callback signatures, as we pass around const-references now.
+        * dom/Element.cpp: Let updateAnimatedSVGAttribute take a QualifiedName instead of pure Strings.
+        (WebCore::Element::getAttribute):
+        (WebCore::Element::hasAttributes):
+        * dom/Element.h:
+        (WebCore::Element::updateAnimatedSVGAttribute):
+        (WebCore::Element::attributes):
+        * dom/make_names.pl: Remove SVG specific "exportString" / "exportStrings" functionality, see above.
+        * html/HTMLAttributeNames.in: Remove "exportString" tag from "className" attribute.
+        * manual-tests/svg-node-count-vs-scroll.xhtml: Added. Can be used to verify memory consumption with a lot of DOM objects.
+        * mathml/mathattrs.in: MathML doesn't need "exportStrings" - remove it.
+        * mathml/mathtags.in: Ditto.
+        * svg/SVGAElement.cpp:
+        (WebCore::SVGAElement::SVGAElement):
+        (WebCore::SVGAElement::synchronizeProperty):
+        * svg/SVGAElement.h:
+        * svg/SVGAllInOne.cpp: Remove SynchronizablePropertyController.cpp
+        * svg/SVGAltGlyphElement.cpp:
+        (WebCore::SVGAltGlyphElement::SVGAltGlyphElement):
+        (WebCore::SVGAltGlyphElement::synchronizeProperty):
+        * svg/SVGAltGlyphElement.h:
+        * svg/SVGAnimateTransformElement.cpp:
+        (WebCore::SVGAnimateTransformElement::applyResultsToTarget):
+        * svg/SVGAnimatedProperty.h: Rewritten, see above for details.
+        (WebCore::SVGAnimatedPropertyTearOff::create):
+        (WebCore::SVGAnimatedPropertyTearOff::setBaseVal):
+        (WebCore::SVGAnimatedPropertyTearOff::setAnimVal):
+        (WebCore::SVGAnimatedPropertyTearOff::baseVal):
+        (WebCore::SVGAnimatedPropertyTearOff::animVal):
+        (WebCore::SVGAnimatedPropertyTearOff::associatedAttributeName):
+        (WebCore::SVGAnimatedPropertyTearOff::SVGAnimatedPropertyTearOff):
+        (WebCore::SVGAnimatedPropertyTearOff::~SVGAnimatedPropertyTearOff):
+        (WebCore::SVGAnimatedProperty::~SVGAnimatedProperty):
+        (WebCore::SVGAnimatedProperty::SVGAnimatedProperty):
+        (WebCore::SVGAnimatedProperty::value):
+        (WebCore::SVGAnimatedProperty::baseValue):
+        (WebCore::SVGAnimatedProperty::setValue):
+        (WebCore::SVGAnimatedProperty::setBaseValue):
+        (WebCore::SVGAnimatedProperty::shouldSynchronize):
+        (WebCore::SVGAnimatedProperty::setShouldSynchronize):
+        * svg/SVGAnimatedPropertySynchronizer.h: Added.
+        (WebCore::):
+        * svg/SVGAnimatedPropertyTraits.h: Added.
+        (WebCore::):
+        * svg/SVGAnimatedTemplate.h: Move SVGAnimatedPropertyTraits into its own file.
+        (WebCore::SVGAnimatedTemplate::forgetWrapper):
+        (WebCore::lookupOrCreateWrapper):
+        * svg/SVGAnimationElement.cpp:
+        (WebCore::SVGAnimationElement::SVGAnimationElement):
+        (WebCore::SVGAnimationElement::synchronizeProperty):
+        * svg/SVGAnimationElement.h:
+        * svg/SVGCircleElement.cpp:
+        (WebCore::SVGCircleElement::SVGCircleElement):
+        (WebCore::SVGCircleElement::synchronizeProperty):
+        * svg/SVGCircleElement.h:
+        * svg/SVGClipPathElement.cpp:
+        (WebCore::SVGClipPathElement::SVGClipPathElement):
+        (WebCore::SVGClipPathElement::synchronizeProperty):
+        * svg/SVGClipPathElement.h:
+        * svg/SVGComponentTransferFunctionElement.cpp:
+        (WebCore::SVGComponentTransferFunctionElement::SVGComponentTransferFunctionElement):
+        (WebCore::SVGComponentTransferFunctionElement::parseMappedAttribute):
+        (WebCore::SVGComponentTransferFunctionElement::synchronizeProperty):
+        * svg/SVGComponentTransferFunctionElement.h:
+        * svg/SVGCursorElement.cpp:
+        (WebCore::SVGCursorElement::SVGCursorElement):
+        (WebCore::SVGCursorElement::synchronizeProperty):
+        * svg/SVGCursorElement.h:
+        * svg/SVGDefsElement.cpp:
+        (WebCore::SVGDefsElement::SVGDefsElement):
+        (WebCore::SVGDefsElement::synchronizeProperty):
+        * svg/SVGDefsElement.h:
+        * svg/SVGDocumentExtensions.h:
+        * svg/SVGElement.cpp: Adapt to synchronization changes: use synchronizeProperty() call, instead of SynchronizablePropertyController.
+        (WebCore::SVGElement::updateAnimatedSVGAttribute):
+        * svg/SVGElement.h: Don't store SynchronizablePropertyController anymore, it's gone.
+        (WebCore::SVGElement::synchronizeProperty):
+        (WebCore::SVGElement::setSynchronizedSVGAttributes):
+        * svg/SVGEllipseElement.cpp:
+        (WebCore::SVGEllipseElement::SVGEllipseElement):
+        (WebCore::SVGEllipseElement::synchronizeProperty):
+        * svg/SVGEllipseElement.h:
+        * svg/SVGExternalResourcesRequired.cpp:
+        * svg/SVGExternalResourcesRequired.h:
+        * svg/SVGFEBlendElement.cpp:
+        (WebCore::SVGFEBlendElement::SVGFEBlendElement):
+        (WebCore::SVGFEBlendElement::synchronizeProperty):
+        * svg/SVGFEBlendElement.h:
+        * svg/SVGFEColorMatrixElement.cpp:
+        (WebCore::SVGFEColorMatrixElement::SVGFEColorMatrixElement):
+        (WebCore::SVGFEColorMatrixElement::synchronizeProperty):
+        * svg/SVGFEColorMatrixElement.h:
+        * svg/SVGFEComponentTransferElement.cpp:
+        (WebCore::SVGFEComponentTransferElement::SVGFEComponentTransferElement):
+        (WebCore::SVGFEComponentTransferElement::synchronizeProperty):
+        * svg/SVGFEComponentTransferElement.h:
+        * svg/SVGFECompositeElement.cpp:
+        (WebCore::SVGFECompositeElement::SVGFECompositeElement):
+        (WebCore::SVGFECompositeElement::parseMappedAttribute):
+        (WebCore::SVGFECompositeElement::synchronizeProperty):
+        * svg/SVGFECompositeElement.h:
+        * svg/SVGFEDiffuseLightingElement.cpp:
+        (WebCore::SVGFEDiffuseLightingElement::SVGFEDiffuseLightingElement):
+        (WebCore::SVGFEDiffuseLightingElement::synchronizeProperty):
+        * svg/SVGFEDiffuseLightingElement.h:
+        * svg/SVGFEDisplacementMapElement.cpp:
+        (WebCore::SVGFEDisplacementMapElement::SVGFEDisplacementMapElement):
+        (WebCore::SVGFEDisplacementMapElement::synchronizeProperty):
+        * svg/SVGFEDisplacementMapElement.h:
+        * svg/SVGFEGaussianBlurElement.cpp:
+        (WebCore::SVGFEGaussianBlurElement::SVGFEGaussianBlurElement):
+        (WebCore::SVGFEGaussianBlurElement::synchronizeProperty):
+        * svg/SVGFEGaussianBlurElement.h:
+        * svg/SVGFEImageElement.cpp:
+        (WebCore::SVGFEImageElement::SVGFEImageElement):
+        (WebCore::SVGFEImageElement::synchronizeProperty):
+        * svg/SVGFEImageElement.h:
+        * svg/SVGFELightElement.cpp:
+        (WebCore::SVGFELightElement::SVGFELightElement):
+        (WebCore::SVGFELightElement::synchronizeProperty):
+        * svg/SVGFELightElement.h:
+        * svg/SVGFEMergeNodeElement.cpp:
+        (WebCore::SVGFEMergeNodeElement::SVGFEMergeNodeElement):
+        (WebCore::SVGFEMergeNodeElement::synchronizeProperty):
+        * svg/SVGFEMergeNodeElement.h:
+        * svg/SVGFEMorphologyElement.cpp:
+        (WebCore::SVGFEMorphologyElement::SVGFEMorphologyElement):
+        (WebCore::SVGFEMorphologyElement::synchronizeProperty):
+        * svg/SVGFEMorphologyElement.h:
+        * svg/SVGFEOffsetElement.cpp:
+        (WebCore::SVGFEOffsetElement::SVGFEOffsetElement):
+        (WebCore::SVGFEOffsetElement::synchronizeProperty):
+        * svg/SVGFEOffsetElement.h:
+        * svg/SVGFESpecularLightingElement.cpp:
+        (WebCore::SVGFESpecularLightingElement::SVGFESpecularLightingElement):
+        (WebCore::SVGFESpecularLightingElement::synchronizeProperty):
+        * svg/SVGFESpecularLightingElement.h:
+        * svg/SVGFETileElement.cpp:
+        (WebCore::SVGFETileElement::SVGFETileElement):
+        (WebCore::SVGFETileElement::synchronizeProperty):
+        * svg/SVGFETileElement.h:
+        * svg/SVGFETurbulenceElement.cpp:
+        (WebCore::SVGFETurbulenceElement::SVGFETurbulenceElement):
+        (WebCore::SVGFETurbulenceElement::synchronizeProperty):
+        * svg/SVGFETurbulenceElement.h:
+        * svg/SVGFilterElement.cpp:
+        (WebCore::SVGFilterElement::SVGFilterElement):
+        (WebCore::SVGFilterElement::synchronizeProperty):
+        * svg/SVGFilterElement.h:
+        * svg/SVGFilterPrimitiveStandardAttributes.cpp:
+        (WebCore::SVGFilterPrimitiveStandardAttributes::SVGFilterPrimitiveStandardAttributes):
+        (WebCore::SVGFilterPrimitiveStandardAttributes::synchronizeProperty):
+        * svg/SVGFilterPrimitiveStandardAttributes.h:
+        * svg/SVGFitToViewBox.cpp:
+        * svg/SVGFitToViewBox.h:
+        * svg/SVGFontElement.cpp:
+        (WebCore::SVGFontElement::SVGFontElement):
+        (WebCore::SVGFontElement::synchronizeProperty):
+        * svg/SVGFontElement.h:
+        * svg/SVGForeignObjectElement.cpp:
+        (WebCore::SVGForeignObjectElement::SVGForeignObjectElement):
+        (WebCore::SVGForeignObjectElement::synchronizeProperty):
+        * svg/SVGForeignObjectElement.h:
+        * svg/SVGGElement.cpp:
+        (WebCore::SVGGElement::SVGGElement):
+        (WebCore::SVGGElement::synchronizeProperty):
+        * svg/SVGGElement.h:
+        * svg/SVGGradientElement.cpp:
+        (WebCore::SVGGradientElement::SVGGradientElement):
+        (WebCore::SVGGradientElement::synchronizeProperty):
+        * svg/SVGGradientElement.h:
+        * svg/SVGImageElement.cpp:
+        (WebCore::SVGImageElement::SVGImageElement):
+        (WebCore::SVGImageElement::synchronizeProperty):
+        * svg/SVGImageElement.h:
+        * svg/SVGLineElement.cpp:
+        (WebCore::SVGLineElement::SVGLineElement):
+        (WebCore::SVGLineElement::synchronizeProperty):
+        * svg/SVGLineElement.h:
+        * svg/SVGLinearGradientElement.cpp:
+        (WebCore::SVGLinearGradientElement::SVGLinearGradientElement):
+        (WebCore::SVGLinearGradientElement::synchronizeProperty):
+        * svg/SVGLinearGradientElement.h:
+        * svg/SVGList.h: Adapt to const-reference changes.
+        (WebCore::SVGPODListItem::setValue):
+        * svg/SVGMPathElement.cpp:
+        (WebCore::SVGMPathElement::SVGMPathElement):
+        (WebCore::SVGMPathElement::synchronizeProperty):
+        * svg/SVGMPathElement.h:
+        * svg/SVGMarkerElement.cpp:
+        (WebCore::SVGMarkerElement::SVGMarkerElement):
+        (WebCore::SVGMarkerElement::synchronizeProperty):
+        * svg/SVGMarkerElement.h:
+        * svg/SVGMaskElement.cpp:
+        (WebCore::SVGMaskElement::SVGMaskElement):
+        (WebCore::SVGMaskElement::synchronizeProperty):
+        * svg/SVGMaskElement.h:
+        * svg/SVGPathElement.cpp:
+        (WebCore::SVGPathElement::SVGPathElement):
+        (WebCore::SVGPathElement::synchronizeProperty):
+        * svg/SVGPathElement.h:
+        * svg/SVGPatternElement.cpp:
+        (WebCore::SVGPatternElement::SVGPatternElement):
+        (WebCore::SVGPatternElement::synchronizeProperty):
+        * svg/SVGPatternElement.h:
+        * svg/SVGPolyElement.cpp:
+        (WebCore::SVGPolyElement::SVGPolyElement):
+        (WebCore::SVGPolyElement::svgAttributeChanged):
+        (WebCore::SVGPolyElement::synchronizeProperty):
+        * svg/SVGPolyElement.h:
+        * svg/SVGRadialGradientElement.cpp:
+        (WebCore::SVGRadialGradientElement::SVGRadialGradientElement):
+        (WebCore::SVGRadialGradientElement::synchronizeProperty):
+        * svg/SVGRadialGradientElement.h:
+        * svg/SVGRectElement.cpp:
+        (WebCore::SVGRectElement::SVGRectElement):
+        (WebCore::SVGRectElement::synchronizeProperty):
+        * svg/SVGRectElement.h:
+        * svg/SVGSVGElement.cpp:
+        (WebCore::SVGSVGElement::SVGSVGElement):
+        (WebCore::SVGSVGElement::synchronizeProperty):
+        * svg/SVGSVGElement.h:
+        * svg/SVGScriptElement.cpp:
+        (WebCore::SVGScriptElement::SVGScriptElement):
+        (WebCore::SVGScriptElement::synchronizeProperty):
+        * svg/SVGScriptElement.h:
+        * svg/SVGStopElement.cpp:
+        (WebCore::SVGStopElement::SVGStopElement):
+        (WebCore::SVGStopElement::synchronizeProperty):
+        * svg/SVGStopElement.h:
+        * svg/SVGStyledElement.cpp:
+        (WebCore::SVGStyledElement::SVGStyledElement):
+        (WebCore::SVGStyledElement::parseMappedAttribute):
+        (WebCore::SVGStyledElement::synchronizeProperty):
+        * svg/SVGStyledElement.h:
+        * svg/SVGStyledTransformableElement.cpp:
+        (WebCore::SVGStyledTransformableElement::SVGStyledTransformableElement):
+        (WebCore::SVGStyledTransformableElement::synchronizeProperty):
+        * svg/SVGStyledTransformableElement.h:
+        * svg/SVGSwitchElement.cpp:
+        (WebCore::SVGSwitchElement::SVGSwitchElement):
+        (WebCore::SVGSwitchElement::synchronizeProperty):
+        * svg/SVGSwitchElement.h:
+        * svg/SVGSymbolElement.cpp:
+        (WebCore::SVGSymbolElement::SVGSymbolElement):
+        (WebCore::SVGSymbolElement::synchronizeProperty):
+        * svg/SVGSymbolElement.h:
+        * svg/SVGTRefElement.cpp:
+        (WebCore::SVGTRefElement::SVGTRefElement):
+        (WebCore::SVGTRefElement::synchronizeProperty):
+        * svg/SVGTRefElement.h:
+        * svg/SVGTextContentElement.cpp:
+        (WebCore::SVGTextContentElement::SVGTextContentElement):
+        (WebCore::SVGTextContentElement::synchronizeProperty):
+        * svg/SVGTextContentElement.h:
+        * svg/SVGTextElement.cpp:
+        (WebCore::SVGTextElement::SVGTextElement):
+        (WebCore::SVGTextElement::synchronizeProperty):
+        * svg/SVGTextElement.h:
+        * svg/SVGTextPathElement.cpp:
+        (WebCore::SVGTextPathElement::SVGTextPathElement):
+        (WebCore::SVGTextPathElement::synchronizeProperty):
+        * svg/SVGTextPathElement.h:
+        * svg/SVGTextPositioningElement.cpp:
+        (WebCore::SVGTextPositioningElement::SVGTextPositioningElement):
+        (WebCore::SVGTextPositioningElement::synchronizeProperty):
+        * svg/SVGTextPositioningElement.h:
+        * svg/SVGURIReference.cpp:
+        * svg/SVGURIReference.h:
+        * svg/SVGUseElement.cpp:
+        (WebCore::SVGUseElement::SVGUseElement):
+        (WebCore::SVGUseElement::synchronizeProperty):
+        * svg/SVGUseElement.h:
+        * svg/SVGViewElement.cpp:
+        (WebCore::SVGViewElement::SVGViewElement):
+        (WebCore::SVGViewElement::synchronizeProperty):
+        * svg/SVGViewElement.h:
+        * svg/SVGViewSpec.cpp:
+        (WebCore::SVGViewSpec::SVGViewSpec):
+        * svg/SVGViewSpec.h:
+        (WebCore::SVGViewSpec::contextElement):
+        * svg/SynchronizablePropertyController.cpp: Removed.
+        * svg/SynchronizablePropertyController.h: Removed.
+        * svg/SynchronizableTypeWrapper.h: Removed.
+        * svg/svgattrs.in: Remove "exportStrings" tag.
+        * svg/svgtags.in: Ditto.
+        * svg/xlinkattrs.in:
+
 2010-01-26  Adele Peterson  <adele@apple.com>
 
         Reviewed by Darin Adler.
index 441c9fa..48972e2 100644 (file)
@@ -34,7 +34,7 @@ GCC_FAST_OBJC_DISPATCH = YES;
 GCC_GENERATE_DEBUGGING_SYMBOLS = YES;
 GCC_MODEL_TUNING = G5;
 GCC_OBJC_CALL_CXX_CDTORS = YES;
-GCC_PRECOMPILE_PREFIX_HEADER = YES;
+GCC_PRECOMPILE_PREFIX_HEADER = NO;
 GCC_THREADSAFE_STATICS = NO;
 GCC_TREAT_WARNINGS_AS_ERRORS = YES;
 GCC_WARN_ABOUT_DEPRECATED_FUNCTIONS = NO;
index 102cfe2..4d9f3a7 100644 (file)
@@ -3275,9 +3275,6 @@ webcore_sources += \
        WebCore/svg/SVGZoomAndPan.h \
        WebCore/svg/SVGZoomEvent.cpp \
        WebCore/svg/SVGZoomEvent.h \
-       WebCore/svg/SynchronizablePropertyController.cpp \
-       WebCore/svg/SynchronizablePropertyController.h \
-       WebCore/svg/SynchronizableTypeWrapper.h \
        WebCore/svg/animation/SMILTime.cpp \
        WebCore/svg/animation/SMILTime.h \
        WebCore/svg/animation/SMILTimeContainer.cpp \
index 1a1c3ac..6abdfde 100644 (file)
             'svg/SVGAnimatedPoints.cpp',
             'svg/SVGAnimatedPoints.h',
             'svg/SVGAnimatedProperty.h',
+            'svg/SVGAnimatedPropertySynchronizer.h',
+            'svg/SVGAnimatedPropertyTraits.h',
             'svg/SVGAnimatedTemplate.h',
             'svg/SVGAnimationElement.cpp',
             'svg/SVGAnimationElement.h',
             'svg/SVGZoomAndPan.h',
             'svg/SVGZoomEvent.cpp',
             'svg/SVGZoomEvent.h',
-            'svg/SynchronizablePropertyController.cpp',
-            'svg/SynchronizablePropertyController.h',
-            'svg/SynchronizableTypeWrapper.h',
             'websockets/ThreadableWebSocketChannel.cpp',
             'websockets/ThreadableWebSocketChannel.h',
             'websockets/ThreadableWebSocketChannelClientWrapper.h',
index 36cc5b7..b058d1f 100644 (file)
                                >\r
                        </File>\r
                        <File\r
+                               RelativePath="..\svg\SVGAnimatedProperty.h"\r
+                               >\r
+                       </File>\r
+                       <File\r
+                               RelativePath="..\svg\SVGAnimatedPropertySynchronizer.h"\r
+                               >\r
+                       </File>\r
+                       <File\r
+                               RelativePath="..\svg\SVGAnimatedPropertyTraits.h"\r
+                               >\r
+                       </File>\r
+                       <File\r
                                RelativePath="..\svg\SVGAnimatedTemplate.h"\r
                                >\r
                        </File>\r
                                RelativePath="..\svg\SVGZoomEvent.h"\r
                                >\r
                        </File>\r
-                       <File\r
-                               RelativePath="..\svg\SynchronizablePropertyController.h"\r
-                               >\r
-                       </File>\r
                        <Filter\r
                                Name="animation"\r
                                >\r
index 81919d8..92a2bf0 100644 (file)
@@ -76,6 +76,8 @@
                084CE5CC0F27DADC00E6240E /* WMLOptGroupElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 084CE5C80F27DADC00E6240E /* WMLOptGroupElement.h */; };
                084CE5CD0F27DADC00E6240E /* WMLOptionElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 084CE5C90F27DADC00E6240E /* WMLOptionElement.cpp */; };
                084CE5CE0F27DADC00E6240E /* WMLOptionElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 084CE5CA0F27DADC00E6240E /* WMLOptionElement.h */; };
+               084D2833110A7FCB0038239A /* SVGAnimatedPropertySynchronizer.h in Headers */ = {isa = PBXBuildFile; fileRef = 084D2831110A7FCB0038239A /* SVGAnimatedPropertySynchronizer.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               084D2834110A7FCB0038239A /* SVGAnimatedPropertyTraits.h in Headers */ = {isa = PBXBuildFile; fileRef = 084D2832110A7FCB0038239A /* SVGAnimatedPropertyTraits.h */; settings = {ATTRIBUTES = (Private, ); }; };
                084DBAA10ED39D360038C226 /* WMLVariables.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 084DBA9D0ED39D350038C226 /* WMLVariables.cpp */; };
                084DBAA20ED39D360038C226 /* WMLVariables.h in Headers */ = {isa = PBXBuildFile; fileRef = 084DBA9E0ED39D360038C226 /* WMLVariables.h */; };
                08591AA50F085C4E009BACB1 /* InputElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 08591AA40F085C4E009BACB1 /* InputElement.h */; settings = {ATTRIBUTES = (Private, ); }; };
@@ -95,9 +97,6 @@
                08744BAA0EDB7D86004C9E63 /* WMLOnEventElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 08744BA90EDB7D86004C9E63 /* WMLOnEventElement.cpp */; };
                08744BAE0EDB7D92004C9E63 /* WMLOnEventElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 08744BAD0EDB7D92004C9E63 /* WMLOnEventElement.h */; };
                0878B1FD10874E3F00A55097 /* SVGAnimatedProperty.h in Headers */ = {isa = PBXBuildFile; fileRef = 0878B1F910874E3F00A55097 /* SVGAnimatedProperty.h */; settings = {ATTRIBUTES = (Private, ); }; };
-               0878B1FE10874E3F00A55097 /* SynchronizablePropertyController.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0878B1FA10874E3F00A55097 /* SynchronizablePropertyController.cpp */; };
-               0878B1FF10874E3F00A55097 /* SynchronizablePropertyController.h in Headers */ = {isa = PBXBuildFile; fileRef = 0878B1FB10874E3F00A55097 /* SynchronizablePropertyController.h */; settings = {ATTRIBUTES = (Private, ); }; };
-               0878B20010874E3F00A55097 /* SynchronizableTypeWrapper.h in Headers */ = {isa = PBXBuildFile; fileRef = 0878B1FC10874E3F00A55097 /* SynchronizableTypeWrapper.h */; settings = {ATTRIBUTES = (Private, ); }; };
                087D97BF10FB8D7700C00874 /* JSSVGPODListCustom.h in Headers */ = {isa = PBXBuildFile; fileRef = 087D97BE10FB8D7700C00874 /* JSSVGPODListCustom.h */; };
                087FFA0F0EFF3ED3009DBD88 /* WMLInsertedLegendElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 087FFA0D0EFF3ED3009DBD88 /* WMLInsertedLegendElement.cpp */; };
                087FFA100EFF3ED3009DBD88 /* WMLInsertedLegendElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 087FFA0E0EFF3ED3009DBD88 /* WMLInsertedLegendElement.h */; };
                B2227A320D00BF220071B782 /* SVGLength.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B222789C0D00BF200071B782 /* SVGLength.cpp */; };
                B2227A330D00BF220071B782 /* SVGLength.h in Headers */ = {isa = PBXBuildFile; fileRef = B222789D0D00BF200071B782 /* SVGLength.h */; settings = {ATTRIBUTES = (Private, ); }; };
                B2227A350D00BF220071B782 /* SVGLengthList.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B222789F0D00BF200071B782 /* SVGLengthList.cpp */; };
-               B2227A360D00BF220071B782 /* SVGLengthList.h in Headers */ = {isa = PBXBuildFile; fileRef = B22278A00D00BF200071B782 /* SVGLengthList.h */; };
+               B2227A360D00BF220071B782 /* SVGLengthList.h in Headers */ = {isa = PBXBuildFile; fileRef = B22278A00D00BF200071B782 /* SVGLengthList.h */; settings = {ATTRIBUTES = (Private, ); }; };
                B2227A380D00BF220071B782 /* SVGLinearGradientElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B22278A20D00BF200071B782 /* SVGLinearGradientElement.cpp */; };
                B2227A390D00BF220071B782 /* SVGLinearGradientElement.h in Headers */ = {isa = PBXBuildFile; fileRef = B22278A30D00BF200071B782 /* SVGLinearGradientElement.h */; };
                B2227A3B0D00BF220071B782 /* SVGLineElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B22278A50D00BF200071B782 /* SVGLineElement.cpp */; };
                B2227A3C0D00BF220071B782 /* SVGLineElement.h in Headers */ = {isa = PBXBuildFile; fileRef = B22278A60D00BF200071B782 /* SVGLineElement.h */; };
-               B2227A3E0D00BF220071B782 /* SVGList.h in Headers */ = {isa = PBXBuildFile; fileRef = B22278A80D00BF200071B782 /* SVGList.h */; };
-               B2227A3F0D00BF220071B782 /* SVGListTraits.h in Headers */ = {isa = PBXBuildFile; fileRef = B22278A90D00BF200071B782 /* SVGListTraits.h */; };
+               B2227A3E0D00BF220071B782 /* SVGList.h in Headers */ = {isa = PBXBuildFile; fileRef = B22278A80D00BF200071B782 /* SVGList.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               B2227A3F0D00BF220071B782 /* SVGListTraits.h in Headers */ = {isa = PBXBuildFile; fileRef = B22278A90D00BF200071B782 /* SVGListTraits.h */; settings = {ATTRIBUTES = (Private, ); }; };
                B2227A400D00BF220071B782 /* SVGLocatable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B22278AA0D00BF200071B782 /* SVGLocatable.cpp */; };
                B2227A410D00BF220071B782 /* SVGLocatable.h in Headers */ = {isa = PBXBuildFile; fileRef = B22278AB0D00BF200071B782 /* SVGLocatable.h */; };
                B2227A430D00BF220071B782 /* SVGMarkerElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B22278AD0D00BF200071B782 /* SVGMarkerElement.cpp */; };
                B2227A4D0D00BF220071B782 /* SVGMPathElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B22278B70D00BF200071B782 /* SVGMPathElement.cpp */; };
                B2227A4E0D00BF220071B782 /* SVGMPathElement.h in Headers */ = {isa = PBXBuildFile; fileRef = B22278B80D00BF200071B782 /* SVGMPathElement.h */; };
                B2227A500D00BF220071B782 /* SVGNumberList.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B22278BA0D00BF200071B782 /* SVGNumberList.cpp */; };
-               B2227A510D00BF220071B782 /* SVGNumberList.h in Headers */ = {isa = PBXBuildFile; fileRef = B22278BB0D00BF200071B782 /* SVGNumberList.h */; };
+               B2227A510D00BF220071B782 /* SVGNumberList.h in Headers */ = {isa = PBXBuildFile; fileRef = B22278BB0D00BF200071B782 /* SVGNumberList.h */; settings = {ATTRIBUTES = (Private, ); }; };
                B2227A530D00BF220071B782 /* SVGPaint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B22278BD0D00BF200071B782 /* SVGPaint.cpp */; };
                B2227A540D00BF220071B782 /* SVGPaint.h in Headers */ = {isa = PBXBuildFile; fileRef = B22278BE0D00BF200071B782 /* SVGPaint.h */; settings = {ATTRIBUTES = (Private, ); }; };
                B2227A560D00BF220071B782 /* SVGParserUtilities.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B22278C00D00BF200071B782 /* SVGParserUtilities.cpp */; };
                B2227AD30D00BF220071B782 /* SVGTitleElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B222793D0D00BF210071B782 /* SVGTitleElement.cpp */; };
                B2227AD40D00BF220071B782 /* SVGTitleElement.h in Headers */ = {isa = PBXBuildFile; fileRef = B222793E0D00BF210071B782 /* SVGTitleElement.h */; };
                B2227AD60D00BF220071B782 /* SVGTransform.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B22279400D00BF210071B782 /* SVGTransform.cpp */; };
-               B2227AD70D00BF220071B782 /* SVGTransform.h in Headers */ = {isa = PBXBuildFile; fileRef = B22279410D00BF210071B782 /* SVGTransform.h */; };
+               B2227AD70D00BF220071B782 /* SVGTransform.h in Headers */ = {isa = PBXBuildFile; fileRef = B22279410D00BF210071B782 /* SVGTransform.h */; settings = {ATTRIBUTES = (Private, ); }; };
                B2227AD90D00BF220071B782 /* SVGTransformable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B22279430D00BF210071B782 /* SVGTransformable.cpp */; };
                B2227ADA0D00BF220071B782 /* SVGTransformable.h in Headers */ = {isa = PBXBuildFile; fileRef = B22279440D00BF210071B782 /* SVGTransformable.h */; };
                B2227ADC0D00BF220071B782 /* SVGTransformDistance.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B22279460D00BF210071B782 /* SVGTransformDistance.cpp */; };
                B2227ADD0D00BF220071B782 /* SVGTransformDistance.h in Headers */ = {isa = PBXBuildFile; fileRef = B22279470D00BF210071B782 /* SVGTransformDistance.h */; };
                B2227ADE0D00BF220071B782 /* SVGTransformList.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B22279480D00BF210071B782 /* SVGTransformList.cpp */; };
-               B2227ADF0D00BF220071B782 /* SVGTransformList.h in Headers */ = {isa = PBXBuildFile; fileRef = B22279490D00BF210071B782 /* SVGTransformList.h */; };
+               B2227ADF0D00BF220071B782 /* SVGTransformList.h in Headers */ = {isa = PBXBuildFile; fileRef = B22279490D00BF210071B782 /* SVGTransformList.h */; settings = {ATTRIBUTES = (Private, ); }; };
                B2227AE10D00BF220071B782 /* SVGTRefElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B222794B0D00BF210071B782 /* SVGTRefElement.cpp */; };
                B2227AE20D00BF220071B782 /* SVGTRefElement.h in Headers */ = {isa = PBXBuildFile; fileRef = B222794C0D00BF210071B782 /* SVGTRefElement.h */; };
                B2227AE40D00BF220071B782 /* SVGTSpanElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B222794E0D00BF210071B782 /* SVGTSpanElement.cpp */; };
                084CE5C80F27DADC00E6240E /* WMLOptGroupElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WMLOptGroupElement.h; sourceTree = "<group>"; };
                084CE5C90F27DADC00E6240E /* WMLOptionElement.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WMLOptionElement.cpp; sourceTree = "<group>"; };
                084CE5CA0F27DADC00E6240E /* WMLOptionElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WMLOptionElement.h; sourceTree = "<group>"; };
+               084D2831110A7FCB0038239A /* SVGAnimatedPropertySynchronizer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SVGAnimatedPropertySynchronizer.h; sourceTree = "<group>"; };
+               084D2832110A7FCB0038239A /* SVGAnimatedPropertyTraits.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SVGAnimatedPropertyTraits.h; sourceTree = "<group>"; };
                084DBA9D0ED39D350038C226 /* WMLVariables.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WMLVariables.cpp; sourceTree = "<group>"; };
                084DBA9E0ED39D360038C226 /* WMLVariables.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WMLVariables.h; sourceTree = "<group>"; };
                08591AA40F085C4E009BACB1 /* InputElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InputElement.h; sourceTree = "<group>"; };
                08744BA90EDB7D86004C9E63 /* WMLOnEventElement.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WMLOnEventElement.cpp; sourceTree = "<group>"; };
                08744BAD0EDB7D92004C9E63 /* WMLOnEventElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WMLOnEventElement.h; sourceTree = "<group>"; };
                0878B1F910874E3F00A55097 /* SVGAnimatedProperty.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SVGAnimatedProperty.h; sourceTree = "<group>"; };
-               0878B1FA10874E3F00A55097 /* SynchronizablePropertyController.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SynchronizablePropertyController.cpp; sourceTree = "<group>"; };
-               0878B1FB10874E3F00A55097 /* SynchronizablePropertyController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SynchronizablePropertyController.h; sourceTree = "<group>"; };
-               0878B1FC10874E3F00A55097 /* SynchronizableTypeWrapper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SynchronizableTypeWrapper.h; sourceTree = "<group>"; };
                087D97BE10FB8D7700C00874 /* JSSVGPODListCustom.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSSVGPODListCustom.h; sourceTree = "<group>"; };
                087FFA0D0EFF3ED3009DBD88 /* WMLInsertedLegendElement.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WMLInsertedLegendElement.cpp; sourceTree = "<group>"; };
                087FFA0E0EFF3ED3009DBD88 /* WMLInsertedLegendElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WMLInsertedLegendElement.h; sourceTree = "<group>"; };
                                B22277F30D00BF1F0071B782 /* SVGAnimatedPoints.idl */,
                                B22277F40D00BF1F0071B782 /* SVGAnimatedPreserveAspectRatio.idl */,
                                0878B1F910874E3F00A55097 /* SVGAnimatedProperty.h */,
+                               084D2831110A7FCB0038239A /* SVGAnimatedPropertySynchronizer.h */,
+                               084D2832110A7FCB0038239A /* SVGAnimatedPropertyTraits.h */,
                                B22277F50D00BF1F0071B782 /* SVGAnimatedRect.idl */,
                                B22277F60D00BF1F0071B782 /* SVGAnimatedString.idl */,
                                B22277F70D00BF1F0071B782 /* SVGAnimatedTemplate.h */,
                                B2E4EC940D00C22B00432643 /* SVGZoomEvent.cpp */,
                                B2E4EC950D00C22B00432643 /* SVGZoomEvent.h */,
                                B2E4EC960D00C22B00432643 /* SVGZoomEvent.idl */,
-                               0878B1FA10874E3F00A55097 /* SynchronizablePropertyController.cpp */,
-                               0878B1FB10874E3F00A55097 /* SynchronizablePropertyController.h */,
-                               0878B1FC10874E3F00A55097 /* SynchronizableTypeWrapper.h */,
                                B28C6A260D00C44800334AA4 /* xlinkattrs.in */,
                        );
                        path = svg;
                                B2227AF30D00BF220071B782 /* SVGViewSpec.h in Headers */,
                                B2227AF60D00BF220071B782 /* SVGZoomAndPan.h in Headers */,
                                B2E4EC980D00C22B00432643 /* SVGZoomEvent.h in Headers */,
-                               0878B1FF10874E3F00A55097 /* SynchronizablePropertyController.h in Headers */,
-                               0878B20010874E3F00A55097 /* SynchronizableTypeWrapper.h in Headers */,
                                93E62D9B0985F41600E1B5E3 /* SystemTime.h in Headers */,
                                A8CFF0510A154F09000A4234 /* TableLayout.h in Headers */,
                                BCE3BEC30D222B1D007E06E4 /* TagNodeList.h in Headers */,
                                59B5977511086579007159E8 /* BridgeJSC.h in Headers */,
                                93C4F6EB1108F9A50099D0DB /* AccessibilityScrollbar.h in Headers */,
                                082FCAC4110927CE00CC4821 /* JSSVGContextCache.h in Headers */,
+                               084D2833110A7FCB0038239A /* SVGAnimatedPropertySynchronizer.h in Headers */,
+                               084D2834110A7FCB0038239A /* SVGAnimatedPropertyTraits.h in Headers */,
                                59E842661109E5A2000305AD /* JNIBridgeJSC.h in Headers */,
                        );
                        runOnlyForDeploymentPostprocessing = 0;
                                B2227AF20D00BF220071B782 /* SVGViewSpec.cpp in Sources */,
                                B2227AF50D00BF220071B782 /* SVGZoomAndPan.cpp in Sources */,
                                B2E4EC970D00C22B00432643 /* SVGZoomEvent.cpp in Sources */,
-                               0878B1FE10874E3F00A55097 /* SynchronizablePropertyController.cpp in Sources */,
                                6582A16309999D6D00BEEB6D /* SystemTimeMac.cpp in Sources */,
                                BCE3BEC20D222B1D007E06E4 /* TagNodeList.cpp in Sources */,
                                6550B6A5099DF0270090D781 /* Text.cpp in Sources */,
index 65f928d..50a903a 100644 (file)
@@ -77,7 +77,7 @@ template<typename PODType, typename PODTypeCreator>
 class JSSVGDynamicPODTypeWrapper : public JSSVGPODTypeWrapper<PODType> {
 public:
     typedef PODType (PODTypeCreator::*GetterMethod)() const; 
-    typedef void (PODTypeCreator::*SetterMethod)(PODType);
+    typedef void (PODTypeCreator::*SetterMethod)(const PODType&);
 
     static PassRefPtr<JSSVGDynamicPODTypeWrapper> create(PassRefPtr<PODTypeCreator> creator, GetterMethod getter, SetterMethod setter)
     {
@@ -226,7 +226,7 @@ public:
     typedef SVGPODListItem<PODType> PODListItemPtrType;
 
     typedef PODType (SVGPODListItem<PODType>::*GetterMethod)() const; 
-    typedef void (SVGPODListItem<PODType>::*SetterMethod)(PODType);
+    typedef void (SVGPODListItem<PODType>::*SetterMethod)(const PODType&);
 
     static PassRefPtr<JSSVGPODTypeWrapperCreatorForList> create(PassRefPtr<PODListItemPtrType> creator, const QualifiedName& attributeName)
     {
@@ -270,7 +270,7 @@ private:
 template<typename PODType, typename PODTypeCreator>
 struct PODTypeWrapperCacheInfo {
     typedef PODType (PODTypeCreator::*GetterMethod)() const; 
-    typedef void (PODTypeCreator::*SetterMethod)(PODType);
+    typedef void (PODTypeCreator::*SetterMethod)(const PODType&);
 
     // Empty value
     PODTypeWrapperCacheInfo()
@@ -357,7 +357,7 @@ template<typename PODType, typename PODTypeCreator>
 class JSSVGDynamicPODTypeWrapperCache {
 public:
     typedef PODType (PODTypeCreator::*GetterMethod)() const; 
-    typedef void (PODTypeCreator::*SetterMethod)(PODType);
+    typedef void (PODTypeCreator::*SetterMethod)(const PODType&);
 
     typedef PODTypeWrapperCacheInfo<PODType, PODTypeCreator> CacheInfo;
     typedef PODTypeWrapperCacheInfoHash<PODType, PODTypeCreator> CacheInfoHash;
index 8b6ee45..ac4fdb3 100644 (file)
@@ -182,7 +182,7 @@ const AtomicString& Element::getAttribute(const QualifiedName& name) const
 
 #if ENABLE(SVG)
     if (!m_areSVGAttributesValid)
-        updateAnimatedSVGAttribute(name.localName());
+        updateAnimatedSVGAttribute(name);
 #endif
 
     if (namedAttrMap)
@@ -488,8 +488,10 @@ const AtomicString& Element::getAttribute(const String& name) const
         updateStyleAttribute();
 
 #if ENABLE(SVG)
-    if (!m_areSVGAttributesValid)
-        updateAnimatedSVGAttribute(name);
+    if (!m_areSVGAttributesValid) {
+        // We're not passing a namespace argument on purpose. SVGNames::*Attr are defined w/o namespaces as well.
+        updateAnimatedSVGAttribute(QualifiedName(nullAtom, name, nullAtom));
+    }
 #endif
 
     if (namedAttrMap)
@@ -672,7 +674,7 @@ bool Element::hasAttributes() const
 
 #if ENABLE(SVG)
     if (!m_areSVGAttributesValid)
-        updateAnimatedSVGAttribute(String());
+        updateAnimatedSVGAttribute(anyQName());
 #endif
 
     return namedAttrMap && namedAttrMap->length() > 0;
index facb13d..15032d7 100644 (file)
@@ -301,7 +301,7 @@ private:
     virtual void updateStyleAttribute() const { }
 
 #if ENABLE(SVG)
-    virtual void updateAnimatedSVGAttribute(const String&) const { }
+    virtual void updateAnimatedSVGAttribute(const QualifiedName&) const { }
 #endif
 
     void updateFocusAppearanceSoonAfterAttach();
@@ -358,7 +358,7 @@ inline NamedNodeMap* Element::attributes(bool readonly) const
 
 #if ENABLE(SVG)
     if (!m_areSVGAttributesValid)
-        updateAnimatedSVGAttribute(String());
+        updateAnimatedSVGAttribute(anyQName());
 #endif
 
     if (!readonly && !namedAttrMap)
index 6b5ddb4..daf45ef 100755 (executable)
@@ -94,7 +94,6 @@ sub defaultTagPropertyHash
         'constructorNeedsCreatedByParser' => 0,
         'constructorNeedsFormElement' => 0,
         'createWithNew' => 0,
-        'exportString' => 0,
         'interfaceName' => defaultInterfaceName($_[0]),
         # By default, the JSInterfaceName is the same as the interfaceName.
         'JSInterfaceName' => defaultInterfaceName($_[0]),
@@ -104,11 +103,6 @@ sub defaultTagPropertyHash
     );
 }
 
-sub defaultAttrPropertyHash
-{
-    return ('exportString' => 0);
-}
-
 sub defaultParametersHash
 {
     return (
@@ -117,8 +111,7 @@ sub defaultParametersHash
         'namespaceURI' => '',
         'guardFactoryWith' => '',
         'tagsNullNamespace' => 0,
-        'attrsNullNamespace' => 0,
-        'exportStrings' => 0
+        'attrsNullNamespace' => 0
     );
 }
 
@@ -157,7 +150,7 @@ sub attrsHandler
     $attr =~ s/-/_/g;
 
     # Initialize default properties' values.
-    $attrs{$attr} = { defaultAttrPropertyHash($attr) } if !defined($attrs{$attr});
+    $attrs{$attr} = {} if !defined($attrs{$attr});
 
     if ($property) {
         die "Unknown property $property for attribute $attr\n" if !defined($attrs{$attr}{$property});
@@ -220,10 +213,6 @@ sub printMacros
 
     for my $name (sort keys %$namesRef) {
         print F "$macro $name","$suffix;\n";
-
-        if ($parameters{exportStrings} or $names{$name}{exportString}) { 
-            print F "extern char $name", "${suffix}String[];\n";
-        }
     }
 }
 
@@ -534,14 +523,6 @@ DEFINE_GLOBAL(AtomicString, ${lowerNamespace}NamespaceURI, \"$parameters{namespa
         print F "}\n";
     }
 
-    if (keys %tags) {
-        printDefinitionStrings($F, \%tags, "tags");
-    }
-
-    if (keys %attrs) {
-        printDefinitionStrings($F, \%attrs, "attributes");
-    }
-
 print F "\nvoid init()
 {
     static bool initialized = false;
@@ -599,25 +580,6 @@ sub printElementIncludes
     }
 }
 
-sub printDefinitionStrings
-{
-    my ($F, $namesRef, $type) = @_;
-    my $singularType = substr($type, 0, -1);
-    my $shortType = substr($singularType, 0, 4);
-    my $shortCamelType = ucfirst($shortType);
-    print F "\n// " . ucfirst($type) . " as strings\n";
-
-    my %names = %$namesRef;
-    for my $name (sort keys %$namesRef) {
-        next if (!$parameters{exportStrings} and !$names{$name}{exportString});
-
-        my $realName = $name;
-        $realName =~ s/_/-/g;
-
-        print F "char $name","${shortCamelType}String[] = \"$realName\";\n";
-    }
-} 
-
 sub printDefinitions
 {
     my ($F, $namesRef, $type, $namespaceURI) = @_;
@@ -628,19 +590,10 @@ sub printDefinitions
     
     print F "    // " . ucfirst($type) . "\n";
 
-    my %names = %$namesRef;
     for my $name (sort keys %$namesRef) {
-        next if ($parameters{exportStrings} or $names{$name}{exportString});
-
         my $realName = $name;
         $realName =~ s/_/-/g;
-        print F "    const char *$name","${shortCamelType}String = \"$realName\";\n";
-    }
-
-    print "\n";
-
-    for my $name (sort keys %$namesRef) {
-        print F "    new ((void*)&$name","${shortCamelType}) QualifiedName(nullAtom, $name","${shortCamelType}String, $namespaceURI);\n";
+        print F "    new ((void*)&$name","${shortCamelType}) QualifiedName(nullAtom, \"$realName\", $namespaceURI);\n";
     }
 }
 
index 2f2cb7e..ad13070 100644 (file)
@@ -63,7 +63,7 @@ charset
 checked
 cellborder
 cite
-class exportString
+class
 classid
 clear
 code
diff --git a/WebCore/manual-tests/svg-node-count-vs-scroll.xhtml b/WebCore/manual-tests/svg-node-count-vs-scroll.xhtml
new file mode 100644 (file)
index 0000000..1890a53
--- /dev/null
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xmlns:svg="http://www.w3.org/2000/svg" xml:lang="en">
+ <head>
+  <title>SVG Scrolling Performance depends on #node is Safari?</title>
+
+  <script type="text/javascript">
+  <![CDATA[
+
+  var SVG_NS = 'http://www.w3.org/2000/svg';
+
+  function init() {
+    var nodeCount = parseInt(prompt('# <rect> to generate? ', 50000));
+
+    var svgRoot = document.createElementNS(SVG_NS, 'svg');
+
+    for (var i = 0; i < nodeCount; i++) {
+      var node = document.createElementNS(SVG_NS, 'rect');
+      node.setAttribute('x', i);
+      node.setAttribute('y', i);
+      node.setAttribute('width', 1);
+      node.setAttribute('height', i);
+      node.setAttribute('fill', 'red');
+
+      svgRoot.appendChild(node);
+    }
+
+    svgRoot.style.width = nodeCount + 'px';
+    svgRoot.style.height = nodeCount + 'px';
+    document.body.appendChild(svgRoot);
+  }
+
+  ]]>
+  </script>
+ </head>
+
+ <body onload="init()">
+   <h1>SVG Scrolling Performance depends on #node is Safari?</h1>
+ </body>
+</html>
+
index 24bf71a..df2329a 100644 (file)
@@ -2,7 +2,6 @@ namespace="MathML"
 namespaceURI="http://www.w3.org/1998/Math/MathML"
 guardFactoryWith="ENABLE(MATHML)"
 attrsNullNamespace
-exportStrings
 
 close
 denomalign
index 8704dbf..c853fca 100644 (file)
@@ -1,7 +1,6 @@
 namespace="MathML"
 namespaceURI="http://www.w3.org/1998/Math/MathML"
 guardFactoryWith="ENABLE(MATHML)"
-exportStrings
 
 math
 mfrac interfaceName=MathMLInlineContainerElement
index d0d3613..b344a4e 100644 (file)
@@ -51,9 +51,6 @@ SVGAElement::SVGAElement(const QualifiedName& tagName, Document *doc)
     , SVGTests()
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
-    , m_target(this, SVGNames::targetAttr)
-    , m_href(this, XLinkNames::hrefAttr)
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
 {
 }
 
@@ -98,6 +95,25 @@ void SVGAElement::svgAttributeChanged(const QualifiedName& attrName)
     }
 }
 
+void SVGAElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledTransformableElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeTarget();
+        synchronizeHref();
+        synchronizeExternalResourcesRequired();
+        return;
+    }
+
+    if (attrName == SVGNames::targetAttr)
+        synchronizeTarget();
+    else if (SVGURIReference::isKnownAttribute(attrName))
+        synchronizeHref();
+    else if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+}
+
 RenderObject* SVGAElement::createRenderer(RenderArena* arena, RenderStyle*)
 {
     if (static_cast<SVGElement*>(parent())->isTextContent())
index a3e59c5..36046d3 100644 (file)
@@ -46,6 +46,7 @@ namespace WebCore {
 
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
 
         virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
 
@@ -59,15 +60,13 @@ namespace WebCore {
         virtual bool childShouldCreateRenderer(Node*) const;
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGAElement, SVGNames::aTagString, SVGNames::targetAttrString, String, Target, target)
+        DECLARE_ANIMATED_PROPERTY(SVGAElement, SVGNames::targetAttr, String, Target, target)
 
         // SVGURIReference
-        ANIMATED_PROPERTY_DECLARATIONS(SVGAElement, SVGURIReferenceIdentifier, XLinkNames::hrefAttrString, String, Href, href)
+        DECLARE_ANIMATED_PROPERTY(SVGAElement, XLinkNames::hrefAttr, String, Href, href)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGAElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGAElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
     };
 
 } // namespace WebCore
index 9790917..067adf2 100644 (file)
 #include "SVGViewSpec.cpp"
 #include "SVGZoomAndPan.cpp"
 #include "SVGZoomEvent.cpp"
-#include "SynchronizablePropertyController.cpp"
index f13edf5..8371867 100644 (file)
@@ -35,7 +35,6 @@ namespace WebCore {
 
 SVGAltGlyphElement::SVGAltGlyphElement(const QualifiedName& tagName, Document* doc)
     : SVGTextPositioningElement(tagName, doc)
-    , m_href(this, XLinkNames::hrefAttr)
 {
 }
 
@@ -43,6 +42,14 @@ SVGAltGlyphElement::~SVGAltGlyphElement()
 {
 }
 
+void SVGAltGlyphElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGTextPositioningElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName() || SVGURIReference::isKnownAttribute(attrName))
+        synchronizeHref();
+}
+
 void SVGAltGlyphElement::setGlyphRef(const AtomicString&, ExceptionCode& ec)
 {
     ec = NO_MODIFICATION_ALLOWED_ERR;
index b571880..a28bbad 100644 (file)
@@ -36,7 +36,9 @@ namespace WebCore {
     public:
         SVGAltGlyphElement(const QualifiedName&, Document*);
         virtual ~SVGAltGlyphElement();
-                
+
+        virtual void synchronizeProperty(const QualifiedName&);
+
         virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
         bool childShouldCreateRenderer(Node*) const;
 
@@ -49,7 +51,7 @@ namespace WebCore {
 
     private:    
         // SVGURIReference
-        ANIMATED_PROPERTY_DECLARATIONS(SVGAltGlyphElement, SVGURIReferenceIdentifier, XLinkNames::hrefAttrString, String, Href, href)
+        DECLARE_ANIMATED_PROPERTY(SVGAltGlyphElement, XLinkNames::hrefAttr, String, Href, href)
     };
 
 } // namespace WebCore
index 3ebba06..362a22d 100644 (file)
@@ -170,9 +170,9 @@ void SVGAnimateTransformElement::applyResultsToTarget()
         SVGElement* shadowTreeElement = (*it)->shadowTreeElement();
         ASSERT(shadowTreeElement);
         if (shadowTreeElement->isStyledTransformable())
-            static_cast<SVGStyledTransformableElement*>(shadowTreeElement)->setTransform(transformList.get());
+            static_cast<SVGStyledTransformableElement*>(shadowTreeElement)->setTransformBaseValue(transformList.get());
         else if (shadowTreeElement->hasTagName(SVGNames::textTag))
-            static_cast<SVGTextElement*>(shadowTreeElement)->setTransform(transformList.get());
+            static_cast<SVGTextElement*>(shadowTreeElement)->setTransformBaseValue(transformList.get());
         if (shadowTreeElement->renderer())
             shadowTreeElement->renderer()->setNeedsLayout(true);
     }
index 984046f..0e3ceda 100644 (file)
@@ -1,6 +1,6 @@
 /*
     Copyright (C) 2008 Nikolas Zimmermann <zimmermann@kde.org>
-    Copyright (C) Research In Motion Limited 2009. All rights reserved.
+    Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
 #define SVGAnimatedProperty_h
 
 #if ENABLE(SVG)
+#include "SVGAnimatedPropertySynchronizer.h"
+#include "SVGAnimatedPropertyTraits.h"
 #include "SVGAnimatedTemplate.h"
-#include "SVGDocumentExtensions.h"
-#include "SynchronizableTypeWrapper.h"
 
 namespace WebCore {
 
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    class SVGAnimatedProperty;
-
-    template<typename OwnerType, typename OwnerElement, typename AnimatedType, typename DecoratedType, const char* TagName, const char* PropertyName>
-    class SVGAnimatedPropertyTearOff : public SVGAnimatedTemplate<DecoratedType> {
-    public:
-        typedef SVGAnimatedPropertyTearOff<OwnerType, OwnerElement, AnimatedType, DecoratedType, TagName, PropertyName> Self;
-        typedef SVGAnimatedProperty<OwnerType, AnimatedType, TagName, PropertyName> Creator;
+template<typename AnimatedType>
+class SVGAnimatedProperty;
 
-        static PassRefPtr<Self> create(const Creator& creator, const OwnerElement* owner, const QualifiedName& attributeName)
-        {
-            return adoptRef(new Self(creator, owner, attributeName));
-        }
+template<typename AnimatedType>
+class SVGAnimatedPropertyTearOff : public SVGAnimatedTemplate<AnimatedType> {
+public:
+    typedef typename SVGAnimatedPropertyTraits<AnimatedType>::PassType PassType;
+    typedef typename SVGAnimatedPropertyTraits<AnimatedType>::ReturnType ReturnType;
 
-        virtual DecoratedType baseVal() const;
-        virtual void setBaseVal(DecoratedType);
+    typedef SVGAnimatedPropertyTearOff<AnimatedType> Self;
+    typedef SVGAnimatedProperty<AnimatedType> Creator;
 
-        virtual DecoratedType animVal() const;
-        virtual void setAnimVal(DecoratedType);
-
-    private:
-        SVGAnimatedPropertyTearOff(const Creator&, const OwnerElement*, const QualifiedName& attributeName);
-
-        Creator& m_creator;
-        RefPtr<OwnerElement> m_ownerElement;
-    };
-
-    // Helper templates mapping owner types to owner elements (for SVG*Element OwnerType is equal to OwnerElement, for non-SVG*Element derived types, they're different)
-    template<typename OwnerType, bool isDerivedFromSVGElement>
-    struct GetOwnerElementForType;
-
-    template<typename OwnerType>
-    struct IsDerivedFromSVGElement;
-
-    // Helper template used for synchronizing SVG <-> XML properties
-    template<typename OwnerType, typename DecoratedType, bool isDerivedFromSVGElement>
-    struct PropertySynchronizer;
-
-    // Abstract base class
-    class SVGAnimatedPropertyBase : public Noncopyable {
-    public:
-        virtual ~SVGAnimatedPropertyBase() { }
-        virtual void synchronize() const = 0;
-        virtual void startAnimation() const = 0;
-        virtual void stopAnimation() = 0;
-    };
-
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    class SVGAnimatedProperty : public SVGAnimatedPropertyBase {
-    public:
-        typedef OwnerTypeArg OwnerType;
-        typedef AnimatedTypeArg AnimatedType;
-
-        typedef typename SVGAnimatedTypeValue<AnimatedType>::StorableType StorableType;
-        typedef typename SVGAnimatedTypeValue<AnimatedType>::DecoratedType DecoratedType;
-
-        typedef GetOwnerElementForType<OwnerType, IsDerivedFromSVGElement<OwnerType>::value> OwnerElementForType;
-        typedef typename OwnerElementForType::OwnerElement OwnerElement;
-        typedef SVGAnimatedPropertyTearOff<OwnerType, OwnerElement, AnimatedType, DecoratedType, TagName, PropertyName> TearOff;
-
-        // attributeName & attributeIdentifier may differ. For SVGMarkerElement, there are two exposed SVG animatable
-        // properties: orientType & orientAngle, though only one DOM attribute "orient", handle these cases!
-        SVGAnimatedProperty(const OwnerType*, const QualifiedName& attributeName);
-        SVGAnimatedProperty(const OwnerType*, const QualifiedName& attributeName, const AtomicString& attributeIdentifier);
-
-        // "Forwarding constructors" for primitive type assignment with more than one argument
-        template<typename T1>
-        SVGAnimatedProperty(const OwnerType*, const QualifiedName& attributeName,
-                            const T1&);
-
-        template<typename T1>
-        SVGAnimatedProperty(const OwnerType*, const QualifiedName& attributeName, const AtomicString& attributeIdentifier,
-                            const T1&);
-
-        template<typename T1, typename T2>
-        SVGAnimatedProperty(const OwnerType*, const QualifiedName& attributeName,
-                            const T1&, const T2&);
-
-        template<typename T1, typename T2>
-        SVGAnimatedProperty(const OwnerType*, const QualifiedName& attributeName, const AtomicString& attributeIdentifier,
-                            const T1&, const T2&);
-
-        template<typename T1, typename T2, typename T3>
-        SVGAnimatedProperty(const OwnerType*, const QualifiedName& attributeName,
-                            const T1&, const T2&, const T3&);
-    
-        template<typename T1, typename T2, typename T3>
-        SVGAnimatedProperty(const OwnerType*, const QualifiedName& attributeName, const AtomicString& attributeIdentifier,
-                            const T1&, const T2&, const T3&);
-
-        DecoratedType value() const;
-        void setValue(DecoratedType);
-
-        DecoratedType baseValue() const;
-        void setBaseValue(DecoratedType);
-
-        // Tear offs only used by bindings, never in internal code
-        PassRefPtr<TearOff> animatedTearOff() const;
-
-        void registerProperty();
-        virtual void synchronize() const;
-
-        void startAnimation() const;
-        void stopAnimation();
-
-    private:
-        const OwnerElement* ownerElement() const;
-
-    private:
-        // We're a member variable on stack, living in OwnerType, NO need to ref here.
-        const OwnerType* m_ownerType;
-
-        const QualifiedName& m_attributeName;
-        const AtomicString& m_attributeIdentifier;
-
-        mutable SynchronizableTypeWrapper<StorableType> m_value;
-
-#ifndef NDEBUG
-        bool m_registered;
-#endif
-    };
-
-    // SVGAnimatedPropertyTearOff implementation
-    template<typename OwnerType, typename OwnerElement, typename AnimatedType, typename DecoratedType, const char* TagName, const char* PropertyName>
-    SVGAnimatedPropertyTearOff<OwnerType, OwnerElement, AnimatedType, DecoratedType, TagName, PropertyName>::SVGAnimatedPropertyTearOff(const Creator& creator,
-                                                                                                                                        const OwnerElement* owner,
-                                                                                                                                        const QualifiedName& attributeName)
-        : SVGAnimatedTemplate<DecoratedType>(attributeName)
-        , m_creator(const_cast<Creator&>(creator))
-        , m_ownerElement(const_cast<OwnerElement*>(owner))
+    static PassRefPtr<Self> create(Creator& creator, SVGElement* contextElement)
     {
-        ASSERT(m_ownerElement);
+        return adoptRef(new Self(creator, contextElement));
     }
 
-    template<typename OwnerType, typename OwnerElement, typename AnimatedType, typename DecoratedType, const char* TagName, const char* PropertyName>
-    DecoratedType SVGAnimatedPropertyTearOff<OwnerType, OwnerElement, AnimatedType, DecoratedType, TagName, PropertyName>::baseVal() const
+    virtual void setBaseVal(PassType type)
     {
-        return m_creator.baseValue();
+        m_creator.setBaseValue(type);
+        m_contextElement->setSynchronizedSVGAttributes(false);
     }
 
-    template<typename OwnerType, typename OwnerElement, typename AnimatedType, typename DecoratedType, const char* TagName, const char* PropertyName>
-    void SVGAnimatedPropertyTearOff<OwnerType, OwnerElement, AnimatedType, DecoratedType, TagName, PropertyName>::setBaseVal(DecoratedType newBaseVal)
+    virtual void setAnimVal(PassType type)
     {
-        m_creator.setBaseValue(newBaseVal);
+        m_creator.setValue(type);
+        m_contextElement->setSynchronizedSVGAttributes(false);
     }
 
-    template<typename OwnerType, typename OwnerElement, typename AnimatedType, typename DecoratedType, const char* TagName, const char* PropertyName>
-    DecoratedType SVGAnimatedPropertyTearOff<OwnerType, OwnerElement, AnimatedType, DecoratedType, TagName, PropertyName>::animVal() const
-    {
-        return m_creator.value();
-    }
+    virtual ReturnType baseVal() const { return m_creator.baseValue(); }
+    virtual ReturnType animVal() const { return m_creator.value(); }
+    virtual const QualifiedName& associatedAttributeName() const { return m_creator.associatedAttributeName(); }
 
-    template<typename OwnerType, typename OwnerElement, typename AnimatedType, typename DecoratedType, const char* TagName, const char* PropertyName>
-    void SVGAnimatedPropertyTearOff<OwnerType, OwnerElement, AnimatedType, DecoratedType, TagName, PropertyName>::setAnimVal(DecoratedType newAnimVal)
+private:
+    SVGAnimatedPropertyTearOff(Creator& creator, SVGElement* contextElement)
+        : m_creator(creator)
+        , m_contextElement(contextElement)
     {
-        m_creator.setValue(newAnimVal);
+        m_creator.setShouldSynchronize(true);
     }
 
-    // SVGAnimatedProperty implementation
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::SVGAnimatedProperty(const OwnerType* owner,
-                                                                                                   const QualifiedName& attributeName)
-        : m_ownerType(owner)
-        , m_attributeName(attributeName)
-        , m_attributeIdentifier(attributeName.localName())
-        , m_value()
-#ifndef NDEBUG
-        , m_registered(false)
-#endif
+    virtual ~SVGAnimatedPropertyTearOff()
     {
-        ASSERT(m_ownerType);
-        registerProperty();
+        m_creator.setShouldSynchronize(false);
     }
 
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::SVGAnimatedProperty(const OwnerType* owner,
-                                                                                                   const QualifiedName& attributeName,
-                                                                                                   const AtomicString& attributeIdentifier)
-        : m_ownerType(owner)
-        , m_attributeName(attributeName)
-        , m_attributeIdentifier(attributeIdentifier)
-        , m_value()
-#ifndef NDEBUG
-        , m_registered(false)
-#endif
-    {
-        ASSERT(m_ownerType);
-        registerProperty();
-    }
-
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    template<typename T1>
-    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::SVGAnimatedProperty(const OwnerType* owner,
-                                                                                                   const QualifiedName& attributeName,
-                                                                                                   const T1& arg1)
-        : m_ownerType(owner)
-        , m_attributeName(attributeName)
-        , m_attributeIdentifier(attributeName.localName())
-        , m_value(arg1)
-#ifndef NDEBUG
-        , m_registered(false)
-#endif
-    {
-        ASSERT(m_ownerType);
-        registerProperty();
-    }
-
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    template<typename T1>
-    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::SVGAnimatedProperty(const OwnerType* owner,
-                                                                                                   const QualifiedName& attributeName,
-                                                                                                   const AtomicString& attributeIdentifier,
-                                                                                                   const T1& arg1)
-        : m_ownerType(owner)
-        , m_attributeName(attributeName)
-        , m_attributeIdentifier(attributeIdentifier)
-        , m_value(arg1)
-#ifndef NDEBUG
-        , m_registered(false)
-#endif
-    {
-        ASSERT(m_ownerType);
-        registerProperty();
-    }
-
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    template<typename T1, typename T2>
-    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::SVGAnimatedProperty(const OwnerType* owner,
-                                                                                                   const QualifiedName& attributeName,
-                                                                                                   const T1& arg1,
-                                                                                                   const T2& arg2)
-        : m_ownerType(owner)
-        , m_attributeName(attributeName)
-        , m_attributeIdentifier(attributeName.localName())
-        , m_value(arg1, arg2)
-#ifndef NDEBUG
-        , m_registered(false)
-#endif
-    {
-        ASSERT(m_ownerType);
-        registerProperty();
-    }
-
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    template<typename T1, typename T2>
-    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::SVGAnimatedProperty(const OwnerType* owner,
-                                                                                                   const QualifiedName& attributeName,
-                                                                                                   const AtomicString& attributeIdentifier,
-                                                                                                   const T1& arg1,
-                                                                                                   const T2& arg2)
-        : m_ownerType(owner)
-        , m_attributeName(attributeName)
-        , m_attributeIdentifier(attributeIdentifier)
-        , m_value(arg1, arg2)
-#ifndef NDEBUG
-        , m_registered(false)
-#endif
-    {
-        ASSERT(m_ownerType);
-        registerProperty();
-    }
-
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    template<typename T1, typename T2, typename T3>
-    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::SVGAnimatedProperty(const OwnerType* owner,
-                                                                                                   const QualifiedName& attributeName,
-                                                                                                   const T1& arg1,
-                                                                                                   const T2& arg2,
-                                                                                                   const T3& arg3)
-        : m_ownerType(owner)
-        , m_attributeName(attributeName)
-        , m_attributeIdentifier(attributeName.localName())
-        , m_value(arg1, arg2, arg3)
-#ifndef NDEBUG
-        , m_registered(false)
-#endif
-    {
-        ASSERT(m_ownerType);
-        registerProperty();
-    }
-
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    template<typename T1, typename T2, typename T3>
-    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::SVGAnimatedProperty(const OwnerType* owner,
-                                                                                                   const QualifiedName& attributeName,
-                                                                                                   const AtomicString& attributeIdentifier,
-                                                                                                   const T1& arg1,
-                                                                                                   const T2& arg2,
-                                                                                                   const T3& arg3)
-        : m_ownerType(owner)
-        , m_attributeName(attributeName)
-        , m_attributeIdentifier(attributeIdentifier)
-        , m_value(arg1, arg2, arg3)
-#ifndef NDEBUG
-        , m_registered(false)
-#endif
-    {
-        ASSERT(m_ownerType);
-        registerProperty();
-    }
-
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    typename SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::DecoratedType
-    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::value() const
-    {
-        ASSERT(m_registered);
-        return m_value;
-    }
-
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    void SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::setValue(typename SVGAnimatedProperty::DecoratedType newValue)
-    {
-        ASSERT(m_registered);
-        m_value = newValue;
-        ownerElement()->setSynchronizedSVGAttributes(false);
-    }
+    Creator& m_creator;
+    RefPtr<SVGElement> m_contextElement;
+};
 
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    typename SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::DecoratedType
-    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::baseValue() const
-    {
-        ASSERT(m_registered);
-        const OwnerElement* ownerElement = this->ownerElement();
-        SVGDocumentExtensions* extensions = ownerElement->accessDocumentSVGExtensions();
-        if (extensions && extensions->hasBaseValue<DecoratedType>(ownerElement, m_attributeIdentifier))
-            return extensions->baseValue<DecoratedType>(ownerElement, m_attributeIdentifier);
+template<typename AnimatedType>
+class SVGAnimatedProperty {
+public:
+    virtual ~SVGAnimatedProperty() { }
 
-        return m_value;
-    }
+    typedef typename SVGAnimatedPropertyTraits<AnimatedType>::PassType PassType;
+    typedef typename SVGAnimatedPropertyTraits<AnimatedType>::ReturnType ReturnType;
+    typedef typename SVGAnimatedPropertyTraits<AnimatedType>::StoredType StoredType;
 
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    void SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::setBaseValue(typename SVGAnimatedProperty::DecoratedType newValue)
+    SVGAnimatedProperty()
+        : m_value(SVGAnimatedPropertyTraits<AnimatedType>::null())
+        , m_shouldSynchronize(false)
     {
-        ASSERT(m_registered);
-        const OwnerElement* ownerElement = this->ownerElement();
-        SVGDocumentExtensions* extensions = ownerElement->accessDocumentSVGExtensions();
-        if (extensions && extensions->hasBaseValue<DecoratedType>(ownerElement, m_attributeIdentifier)) {
-            extensions->setBaseValue<DecoratedType>(ownerElement, m_attributeIdentifier, newValue);
-            return;
-        }
-
-        // Only update stored property, if not animating
-        m_value = newValue;
-        ownerElement->setSynchronizedSVGAttributes(false);
     }
 
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    PassRefPtr<typename SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::TearOff>
-    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::animatedTearOff() const
+    template<typename ConstructorParameterOne>
+    SVGAnimatedProperty(const ConstructorParameterOne& value1)
+        : m_value(value1)
+        , m_shouldSynchronize(false)
     {
-        ASSERT(m_registered);
-        return lookupOrCreateWrapper<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName, TearOff, OwnerElement>(*this, ownerElement(), m_attributeName, m_attributeIdentifier);
     }
 
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    void SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::registerProperty()
+    template<typename ConstructorParameterOne, typename ConstructorParameterTwo>
+    SVGAnimatedProperty(const ConstructorParameterOne& value1, const ConstructorParameterTwo& value2)
+        : m_value(value1, value2)
+        , m_shouldSynchronize(false)
     {
-        ASSERT(!m_registered);
-        ownerElement()->propertyController().registerProperty(m_attributeName, this);
-
-#ifndef NDEBUG
-        m_registered = true;
-#endif
     }
 
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    void SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::synchronize() const
-    {
-        ASSERT(m_registered);
-        if (!m_value.needsSynchronization()) 
-            return; 
+    ReturnType value() const { return SVGAnimatedPropertyTraits<AnimatedType>::toReturnType(m_value); }
+    ReturnType baseValue() const { return SVGAnimatedPropertyTraits<AnimatedType>::toReturnType(m_value); }
 
-        PropertySynchronizer<OwnerElement, DecoratedType, IsDerivedFromSVGElement<OwnerType>::value>::synchronize(ownerElement(), m_attributeName, baseValue());
-        m_value.setSynchronized(); 
-    }
+    void setValue(PassType type) { m_value = type; }
+    void setBaseValue(PassType type) { m_value = type; }
 
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    void SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::startAnimation() const
-    {
-        ASSERT(m_registered);
-        const OwnerElement* ownerElement = this->ownerElement();
-        if (SVGDocumentExtensions* extensions = ownerElement->accessDocumentSVGExtensions()) {
-            ASSERT(!extensions->hasBaseValue<DecoratedType>(ownerElement, m_attributeIdentifier));
-            extensions->setBaseValue<DecoratedType>(ownerElement, m_attributeIdentifier, m_value);
-        }
-    }
-    
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    void SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::stopAnimation()
-    {
-        ASSERT(m_registered);
-        const OwnerElement* ownerElement = this->ownerElement();
-        if (SVGDocumentExtensions* extensions = ownerElement->accessDocumentSVGExtensions()) {
-            ASSERT(extensions->hasBaseValue<DecoratedType>(ownerElement, m_attributeIdentifier));
-            setValue(extensions->baseValue<DecoratedType>(ownerElement, m_attributeIdentifier));
-            extensions->removeBaseValue<DecoratedType>(ownerElement, m_attributeIdentifier);
-        }
-    }
+    bool shouldSynchronize() const { return m_shouldSynchronize; }
+    void setShouldSynchronize(bool value) { m_shouldSynchronize = value; }
 
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
-    const typename SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::OwnerElement*
-    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::ownerElement() const
-    {
-        return OwnerElementForType::ownerElement(m_ownerType);
-    }
+    virtual const QualifiedName& associatedAttributeName() const = 0;
 
-    // GetOwnerElementForType implementation
-    template<typename OwnerType>
-    struct GetOwnerElementForType<OwnerType, true> : Noncopyable {
-        typedef OwnerType OwnerElement;
-
-        static const OwnerElement* ownerElement(const OwnerType* type)
-        {
-            return type;
-        }
-    };
-
-    template<typename OwnerType>
-    struct GetOwnerElementForType<OwnerType, false> : Noncopyable {    
-        typedef SVGElement OwnerElement;
-
-        static const OwnerElement* ownerElement(const OwnerType* type)
-        {
-            const OwnerElement* context = type->contextElement();
-            ASSERT(context);
-            return context;
-        }
-    };
-
-    // IsDerivedFromSVGElement implementation
-    template<typename OwnerType>
-    struct IsDerivedFromSVGElement : Noncopyable {
-        static const bool value = true;
-    };
-
-    class SVGViewSpec;
-    template<>
-    struct IsDerivedFromSVGElement<SVGViewSpec> : Noncopyable {
-        static const bool value = false;
-    };
-
-    // PropertySynchronizer implementation
-    template<typename OwnerElement, typename DecoratedType>
-    struct PropertySynchronizer<OwnerElement, DecoratedType, true> : Noncopyable {
-        static void synchronize(const OwnerElement* ownerElement, const QualifiedName& attributeName, DecoratedType baseValue)
-        {
-            AtomicString value(SVGAnimatedTypeValue<DecoratedType>::toString(baseValue));
-
-            NamedNodeMap* namedAttrMap = ownerElement->attributes(false); 
-            Attribute* old = namedAttrMap->getAttributeItem(attributeName);
-            if (old && value.isNull()) 
-                namedAttrMap->removeAttribute(old->name()); 
-            else if (!old && !value.isNull()) 
-                namedAttrMap->addAttribute(const_cast<OwnerElement*>(ownerElement)->createAttribute(attributeName, value));
-            else if (old && !value.isNull()) 
-                old->setValue(value); 
-        }
-    };
-
-    template<typename OwnerElement, typename DecoratedType>
-    struct PropertySynchronizer<OwnerElement, DecoratedType, false> : Noncopyable {
-        static void synchronize(const OwnerElement*, const QualifiedName&, DecoratedType)
-        {
-            // no-op, for types not inheriting from Element, thus nothing to synchronize
-        }
-    };
-
-    // Helper macro used to register animated properties within SVG* classes
-    #define ANIMATED_PROPERTY_DECLARATIONS(OwnerType, ElementTag, AttributeTag, AnimatedType, UpperProperty, LowerProperty) \
-    private: \
-        typedef SVGAnimatedProperty<OwnerType, AnimatedType, ElementTag, AttributeTag> SVGAnimatedProperty##UpperProperty; \
-        typedef SVGAnimatedTypeValue<AnimatedType>::DecoratedType DecoratedTypeFor##UpperProperty; \
-        SVGAnimatedProperty##UpperProperty m_##LowerProperty; \
-    public: \
-        DecoratedTypeFor##UpperProperty LowerProperty() const { return m_##LowerProperty.value(); } \
-        void set##UpperProperty(DecoratedTypeFor##UpperProperty type) { m_##LowerProperty.setValue(type); } \
-        DecoratedTypeFor##UpperProperty LowerProperty##BaseValue() const { return m_##LowerProperty.baseValue(); } \
-        void set##UpperProperty##BaseValue(DecoratedTypeFor##UpperProperty type) { m_##LowerProperty.setBaseValue(type); } \
-        PassRefPtr<SVGAnimatedProperty##UpperProperty::TearOff> LowerProperty##Animated() const { return m_##LowerProperty.animatedTearOff(); }
+protected:
+    StoredType m_value;
+    bool m_shouldSynchronize;
+};
 
 };
 
+// Helper macro used within DECLARE_ANIMATED_PROPERTY below
+#define DEFINE_ANIMATED_PROPERTY(OwnerType, DOMAttribute, AnimatedType, UpperProperty) \
+class SVGAnimatedProperty##UpperProperty : public SVGAnimatedProperty<AnimatedType> { \
+public: \
+    SVGAnimatedProperty##UpperProperty() \
+        : SVGAnimatedProperty<AnimatedType>() \
+    { \
+    } \
+    \
+    template<typename ConstructorParameterOne> \
+    SVGAnimatedProperty##UpperProperty(const ConstructorParameterOne& value1) \
+        : SVGAnimatedProperty<AnimatedType>(value1) \
+    { \
+    } \
+    \
+    template<typename ConstructorParameterOne, typename ConstructorParameterTwo> \
+    SVGAnimatedProperty##UpperProperty(const ConstructorParameterOne& value1, const ConstructorParameterTwo& value2) \
+        : SVGAnimatedProperty<AnimatedType>(value1, value2) \
+    { \
+    } \
+    \
+    void synchronize(SVGElement* contextElement) \
+    { \
+        ASSERT(m_shouldSynchronize); \
+        AtomicString value(SVGAnimatedPropertyTraits<AnimatedType>::toString(baseValue())); \
+        SVGAnimatedPropertySynchronizer<IsDerivedFromSVGElement<OwnerType>::value>::synchronize(contextElement, DOMAttribute, value); \
+    } \
+    \
+    virtual const QualifiedName& associatedAttributeName() const \
+    { \
+        return DOMAttribute; \
+    } \
+}
+
+// Helper macro shared by DECLARE_ANIMATED_PROPERTY / DECLARE_ANIMATED_PROPERTY_MULTIPLE_WRAPPERS
+#define DECLARE_ANIMATED_PROPERTY_SHARED(OwnerType, DOMAttribute, SVGDOMAttributeIdentifier, AnimatedType, UpperProperty, LowerProperty) \
+private: \
+    typedef SVGAnimatedPropertyTearOff<AnimatedType> SVGAnimatedPropertyTearOff##UpperProperty; \
+    DEFINE_ANIMATED_PROPERTY(OwnerType, DOMAttribute, AnimatedType, UpperProperty); \
+    SVGAnimatedProperty##UpperProperty m_##LowerProperty; \
+    \
+public: \
+    SVGAnimatedPropertyTraits<AnimatedType>::ReturnType LowerProperty() const \
+    { \
+        return m_##LowerProperty.value(); \
+    } \
+    \
+    SVGAnimatedPropertyTraits<AnimatedType>::ReturnType LowerProperty##BaseValue() const \
+    { \
+        return m_##LowerProperty.baseValue(); \
+    } \
+    \
+    void set##UpperProperty(SVGAnimatedPropertyTraits<AnimatedType>::PassType type) \
+    { \
+        m_##LowerProperty.setValue(type); \
+        SVGElement* contextElement = GetOwnerElementForType<OwnerType, IsDerivedFromSVGElement<OwnerType>::value>::ownerElement(this); \
+        contextElement->setSynchronizedSVGAttributes(false); \
+    } \
+    \
+    void set##UpperProperty##BaseValue(SVGAnimatedPropertyTraits<AnimatedType>::PassType type) \
+    { \
+        m_##LowerProperty.setBaseValue(type); \
+        SVGElement* contextElement = GetOwnerElementForType<OwnerType, IsDerivedFromSVGElement<OwnerType>::value>::ownerElement(this); \
+        contextElement->setSynchronizedSVGAttributes(false); \
+    } \
+    \
+    void synchronize##UpperProperty() \
+    { \
+        if (!m_##LowerProperty.shouldSynchronize()) \
+            return; \
+        SVGElement* contextElement = GetOwnerElementForType<OwnerType, IsDerivedFromSVGElement<OwnerType>::value>::ownerElement(this); \
+        m_##LowerProperty.synchronize(contextElement); \
+    } \
+    \
+    PassRefPtr<SVGAnimatedPropertyTearOff##UpperProperty> LowerProperty##Animated() \
+    { \
+        SVGElement* contextElement = GetOwnerElementForType<OwnerType, IsDerivedFromSVGElement<OwnerType>::value>::ownerElement(this); \
+        return lookupOrCreateWrapper<AnimatedType, SVGAnimatedPropertyTearOff##UpperProperty>(contextElement, m_##LowerProperty, DOMAttribute); \
+    }
+
+// Used for SVG DOM properties that map exactly to one XML DOM attribute
+#define DECLARE_ANIMATED_PROPERTY(OwnerType, DOMAttribute, AnimatedType, UpperProperty, LowerProperty) \
+DECLARE_ANIMATED_PROPERTY_SHARED(OwnerType, DOMAttribute, DOMAttribute.localName(), AnimatedType, UpperProperty, LowerProperty)
+
+// Used for the rare case multiple SVG DOM properties that map to the same XML dom attribute
+#define DECLARE_ANIMATED_PROPERTY_MULTIPLE_WRAPPERS(OwnerType, DOMAttribute, SVGDOMAttributeIdentifier, AnimatedType, UpperProperty, LowerProperty) \
+DECLARE_ANIMATED_PROPERTY_SHARED(OwnerType, DOMAttribute, SVGDOMAttributeIdentifier, AnimatedType, UpperProperty, LowerProperty)
+
 #endif
 #endif
diff --git a/WebCore/svg/SVGAnimatedPropertySynchronizer.h b/WebCore/svg/SVGAnimatedPropertySynchronizer.h
new file mode 100644 (file)
index 0000000..ddd0493
--- /dev/null
@@ -0,0 +1,96 @@
+/*
+    Copyright (C) Research In Motion Limited 2010. All rights reserved.
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#ifndef SVGAnimatedPropertySynchronizer_h
+#define SVGAnimatedPropertySynchronizer_h
+
+#include "SVGAnimatedPropertyTraits.h"
+
+#if ENABLE(SVG)
+namespace WebCore {
+
+class SVGElement;
+
+// GetOwnerElementForType implementation
+template<typename OwnerType, bool isDerivedFromSVGElement>
+struct GetOwnerElementForType;
+
+template<typename OwnerType>
+struct GetOwnerElementForType<OwnerType, true> : public Noncopyable {
+    static SVGElement* ownerElement(OwnerType* type)
+    {
+        return type;
+    }
+};
+
+template<typename OwnerType>
+struct GetOwnerElementForType<OwnerType, false> : public Noncopyable {    
+    static SVGElement* ownerElement(OwnerType* type)
+    {
+        SVGElement* context = type->contextElement();
+        ASSERT(context);
+        return context;
+    }
+};
+
+// IsDerivedFromSVGElement implementation
+template<typename OwnerType>
+struct IsDerivedFromSVGElement : public Noncopyable {
+    static const bool value = true;
+};
+
+class SVGViewSpec;
+template<>
+struct IsDerivedFromSVGElement<SVGViewSpec> : public Noncopyable {
+    static const bool value = false;
+};
+
+// Helper template used for synchronizing SVG <-> XML properties
+template<bool isDerivedFromSVGElement>
+struct SVGAnimatedPropertySynchronizer {
+    static void synchronize(SVGElement*, const QualifiedName&, const AtomicString&);
+};
+
+template<>
+struct SVGAnimatedPropertySynchronizer<true> {
+    static void synchronize(SVGElement* ownerElement, const QualifiedName& attrName, const AtomicString& value)
+    {
+        NamedNodeMap* namedAttrMap = ownerElement->attributes(false); 
+        Attribute* old = namedAttrMap->getAttributeItem(attrName);
+        if (old && value.isNull()) 
+            namedAttrMap->removeAttribute(old->name()); 
+        else if (!old && !value.isNull()) 
+            namedAttrMap->addAttribute(ownerElement->createAttribute(attrName, value));
+        else if (old && !value.isNull()) 
+            old->setValue(value); 
+    }
+};
+
+template<>
+struct SVGAnimatedPropertySynchronizer<false> {
+    static void synchronize(SVGElement*, const QualifiedName&, const AtomicString&)
+    {
+        // no-op, for types not inheriting from Element, thus nothing to synchronize
+    }
+};
+
+};
+
+#endif
+#endif
diff --git a/WebCore/svg/SVGAnimatedPropertyTraits.h b/WebCore/svg/SVGAnimatedPropertyTraits.h
new file mode 100644 (file)
index 0000000..4e34dbe
--- /dev/null
@@ -0,0 +1,186 @@
+/*
+    Copyright (C) Research In Motion Limited 2010. All rights reserved.
+    Copyright (C) 2004, 2005, 2006, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#ifndef SVGAnimatedPropertyTraits_h
+#define SVGAnimatedPropertyTraits_h
+
+#if ENABLE(SVG)
+#include "FloatRect.h"
+#include "PlatformString.h"
+#include "SVGAngle.h"
+#include "SVGLength.h"
+#include "SVGLengthList.h"
+#include "SVGNumberList.h"
+#include "SVGPreserveAspectRatio.h"
+#include "SVGTransformList.h"
+
+namespace WebCore {
+
+template<typename Type>
+struct SVGAnimatedPropertyTraits : public Noncopyable { };
+
+// SVGAnimatedAngle
+template<>
+struct SVGAnimatedPropertyTraits<SVGAngle> : public Noncopyable {
+    typedef const SVGAngle& PassType;
+    typedef SVGAngle ReturnType;
+    typedef SVGAngle StoredType;
+
+    static ReturnType null() { return SVGAngle(); }
+    static ReturnType toReturnType(const StoredType& type) { return type; }
+    static String toString(PassType type) { return type.valueAsString(); }
+};
+
+// SVGAnimatedBoolean
+template<>
+struct SVGAnimatedPropertyTraits<bool> : public Noncopyable {
+    typedef const bool& PassType;
+    typedef bool ReturnType;
+    typedef bool StoredType;
+
+    static ReturnType null() { return false; }
+    static ReturnType toReturnType(const StoredType& type) { return type; }
+    static String toString(PassType type) { return type ? "true" : "false"; }
+};
+
+// SVGAnimatedEnumeration
+template<>
+struct SVGAnimatedPropertyTraits<int> : public Noncopyable {
+    typedef const int& PassType;
+    typedef int ReturnType;
+    typedef int StoredType;
+
+    static ReturnType null() { return 0; }
+    static ReturnType toReturnType(const StoredType& type) { return type; }
+    static String toString(PassType type) { return String::number(type); }
+};
+
+// SVGAnimatedInteger
+template<>
+struct SVGAnimatedPropertyTraits<long> : public Noncopyable {
+    typedef const long& PassType;
+    typedef long ReturnType;
+    typedef long StoredType;
+
+    static ReturnType null() { return 0l; }
+    static ReturnType toReturnType(const StoredType& type) { return type; }
+    static String toString(PassType type) { return String::number(type); }
+};
+
+// SVGAnimatedLength
+template<>
+struct SVGAnimatedPropertyTraits<SVGLength> : public Noncopyable {
+    typedef const SVGLength& PassType;
+    typedef SVGLength ReturnType;
+    typedef SVGLength StoredType;
+
+    static ReturnType null() { return SVGLength(); }
+    static ReturnType toReturnType(const StoredType& type) { return type; }
+    static String toString(PassType type) { return type.valueAsString(); }
+};
+
+// SVGAnimatedLengthList
+template<>
+struct SVGAnimatedPropertyTraits<SVGLengthList*> : public Noncopyable {
+    typedef SVGLengthList* PassType;
+    typedef SVGLengthList* ReturnType;
+    typedef RefPtr<SVGLengthList> StoredType;
+
+    static ReturnType null() { return 0; }
+    static ReturnType toReturnType(const StoredType& type) { return type.get(); }
+    static String toString(PassType type) { return type ? type->valueAsString() : String(); }
+};
+
+// SVGAnimatedNumber
+template<>
+struct SVGAnimatedPropertyTraits<float> : public Noncopyable {
+    typedef const float& PassType;
+    typedef float ReturnType;
+    typedef float StoredType;
+
+    static ReturnType null() { return 0.0f; }
+    static ReturnType toReturnType(const StoredType& type) { return type; }
+    static String toString(PassType type) { return String::number(type); }
+};
+
+// SVGAnimatedNumberList
+template<>
+struct SVGAnimatedPropertyTraits<SVGNumberList*> : public Noncopyable {
+    typedef SVGNumberList* PassType;
+    typedef SVGNumberList* ReturnType;
+    typedef RefPtr<SVGNumberList> StoredType;
+
+    static ReturnType null() { return 0; }
+    static ReturnType toReturnType(const StoredType& type) { return type.get(); }
+    static String toString(PassType type) { return type ? type->valueAsString() : String(); }
+};
+
+// SVGAnimatedPreserveAspectRatio
+template<>
+struct SVGAnimatedPropertyTraits<SVGPreserveAspectRatio> : public Noncopyable {
+    typedef const SVGPreserveAspectRatio& PassType;
+    typedef SVGPreserveAspectRatio ReturnType;
+    typedef SVGPreserveAspectRatio StoredType;
+
+    static ReturnType null() { return SVGPreserveAspectRatio(); }
+    static ReturnType toReturnType(const StoredType& type) { return type; }
+    static String toString(PassType type) { return type.valueAsString(); }
+};
+
+// SVGAnimatedRect
+template<>
+struct SVGAnimatedPropertyTraits<FloatRect> : public Noncopyable {
+    typedef const FloatRect& PassType;
+    typedef FloatRect ReturnType;
+    typedef FloatRect StoredType;
+
+    static ReturnType null() { return FloatRect(); }
+    static ReturnType toReturnType(const StoredType& type) { return type; }
+    static String toString(PassType type) { return String::format("%f %f %f %f", type.x(), type.y(), type.width(), type.height()); }
+};
+
+// SVGAnimatedString
+template<>
+struct SVGAnimatedPropertyTraits<String> : public Noncopyable {
+    typedef const String& PassType;
+    typedef String ReturnType;
+    typedef String StoredType;
+
+    static ReturnType null() { return String(); }
+    static ReturnType toReturnType(const StoredType& type) { return type; }
+    static String toString(PassType type) { return type; }
+};
+
+// SVGAnimatedTransformList
+template<>
+struct SVGAnimatedPropertyTraits<SVGTransformList*> : public Noncopyable {
+    typedef SVGTransformList* PassType;
+    typedef SVGTransformList* ReturnType;
+    typedef RefPtr<SVGTransformList> StoredType;
+
+    static ReturnType null() { return 0; }
+    static ReturnType toReturnType(const StoredType& type) { return type.get(); }
+    static String toString(PassType type) { return type ? type->valueAsString() : String(); }
+};
+
+}
+
+#endif
+#endif
index 99215ad..589d724 100644 (file)
 #define SVGAnimatedTemplate_h
 
 #if ENABLE(SVG)
-#include "AtomicString.h"
-#include "FloatRect.h"
-#include "SVGAngle.h"
-#include "SVGLength.h"
-#include "SVGPreserveAspectRatio.h"
+#include "SVGAnimatedPropertyTraits.h"
 #include <wtf/HashMap.h>
 
 namespace WebCore {
@@ -103,18 +99,23 @@ namespace WebCore {
         }
     };
  
-    template<typename BareType>
-    class SVGAnimatedTemplate : public RefCounted<SVGAnimatedTemplate<BareType> > {
+    template<typename AnimatedType>
+    class SVGAnimatedTemplate : public RefCounted<SVGAnimatedTemplate<AnimatedType> > {
     public:
+        typedef typename SVGAnimatedPropertyTraits<AnimatedType>::PassType PassType;
+        typedef typename SVGAnimatedPropertyTraits<AnimatedType>::ReturnType ReturnType;
+
         virtual ~SVGAnimatedTemplate() { forgetWrapper(this); }
 
-        virtual BareType baseVal() const = 0;
-        virtual void setBaseVal(BareType) = 0;
+        virtual ReturnType baseVal() const = 0;
+        virtual void setBaseVal(PassType) = 0;
+
+        virtual ReturnType animVal() const = 0;
+        virtual void setAnimVal(PassType) = 0;
 
-        virtual BareType animVal() const = 0;
-        virtual void setAnimVal(BareType) = 0;
+        virtual const QualifiedName& associatedAttributeName() const = 0;
 
-        typedef HashMap<SVGAnimatedTypeWrapperKey, SVGAnimatedTemplate<BareType>*, SVGAnimatedTypeWrapperKeyHash, SVGAnimatedTypeWrapperKeyHashTraits > ElementToWrapperMap;
+        typedef HashMap<SVGAnimatedTypeWrapperKey, SVGAnimatedTemplate<AnimatedType>*, SVGAnimatedTypeWrapperKeyHash, SVGAnimatedTypeWrapperKeyHashTraits > ElementToWrapperMap;
         typedef typename ElementToWrapperMap::const_iterator ElementToWrapperMapIterator;
 
         static ElementToWrapperMap* wrapperCache()
@@ -123,7 +124,7 @@ namespace WebCore {
             return s_wrapperCache;
         }
 
-        static void forgetWrapper(SVGAnimatedTemplate<BareType>* wrapper)
+        static void forgetWrapper(SVGAnimatedTemplate<AnimatedType>* wrapper)
         {
             ElementToWrapperMap* cache = wrapperCache();
             ElementToWrapperMapIterator itr = cache->begin();
@@ -135,129 +136,25 @@ namespace WebCore {
                 }
             }
         }
-
-        const QualifiedName& associatedAttributeName() const { return m_associatedAttributeName; }
-
-    protected:
-        SVGAnimatedTemplate(const QualifiedName& attributeName)
-            : m_associatedAttributeName(attributeName)
-        {
-        }
-
-    private:
-        const QualifiedName& m_associatedAttributeName;
     };
 
-    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
+    template<typename AnimatedType>
     class SVGAnimatedProperty;
 
-    template<typename OwnerType, typename AnimatedType, const char* TagName, const char* PropertyName, typename Type, typename OwnerElement> 
-    PassRefPtr<Type> lookupOrCreateWrapper(const SVGAnimatedProperty<OwnerType, AnimatedType, TagName, PropertyName>& creator,
-                                           const OwnerElement* element, const QualifiedName& attrName, const AtomicString& attrIdentifier)
+    template<typename AnimatedType, typename AnimatedTearOff>
+    PassRefPtr<AnimatedTearOff> lookupOrCreateWrapper(SVGElement* element, SVGAnimatedProperty<AnimatedType>& creator, const QualifiedName& attrName)
     {
-        SVGAnimatedTypeWrapperKey key(element, attrIdentifier);
-        RefPtr<Type> wrapper = static_cast<Type*>(Type::wrapperCache()->get(key));
+        SVGAnimatedTypeWrapperKey key(element, attrName.localName());
+        RefPtr<AnimatedTearOff> wrapper = static_cast<AnimatedTearOff*>(AnimatedTearOff::wrapperCache()->get(key));
 
         if (!wrapper) {
-            wrapper = Type::create(creator, element, attrName);
-            element->propertyController().setPropertyNeedsSynchronization(attrName);
-            Type::wrapperCache()->set(key, wrapper.get());
+            wrapper = AnimatedTearOff::create(creator, element);
+            AnimatedTearOff::wrapperCache()->set(key, wrapper.get());
         }
 
         return wrapper.release();
     }
 
-    // Default implementation for pointer types
-    template<typename Type>
-    struct SVGAnimatedTypeValue : Noncopyable {
-        typedef RefPtr<Type> StorableType;
-        typedef Type* DecoratedType;
-
-        static Type null() { return 0; }
-        static String toString(Type type) { return type ? type->valueAsString() : String(); }
-    };
-
-    template<>
-    struct SVGAnimatedTypeValue<bool> : Noncopyable {
-        typedef bool StorableType;
-        typedef bool DecoratedType;
-
-        static bool null() { return false; }
-        static String toString(bool type) { return type ? "true" : "false"; }
-    };
-
-    template<>
-    struct SVGAnimatedTypeValue<int> : Noncopyable {
-        typedef int StorableType;
-        typedef int DecoratedType;
-
-        static int null() { return 0; }
-        static String toString(int type) { return String::number(type); }
-    };
-
-    template<>
-    struct SVGAnimatedTypeValue<long> : Noncopyable {
-        typedef long StorableType;
-        typedef long DecoratedType;
-
-        static long null() { return 0l; }
-        static String toString(long type) { return String::number(type); }
-    };
-
-    template<>
-    struct SVGAnimatedTypeValue<SVGAngle> : Noncopyable {
-        typedef SVGAngle StorableType;
-        typedef SVGAngle DecoratedType;
-
-        static SVGAngle null() { return SVGAngle(); }
-        static String toString(const SVGAngle& type) { return type.valueAsString(); }
-    };
-
-    template<>
-    struct SVGAnimatedTypeValue<SVGLength> : Noncopyable {
-        typedef SVGLength StorableType;
-        typedef SVGLength DecoratedType;
-
-        static SVGLength null() { return SVGLength(); }
-        static String toString(const SVGLength& type) { return type.valueAsString(); }
-    };
-
-    template<>
-    struct SVGAnimatedTypeValue<SVGPreserveAspectRatio> : Noncopyable {
-        typedef SVGPreserveAspectRatio StorableType;
-        typedef SVGPreserveAspectRatio DecoratedType;
-
-        static SVGPreserveAspectRatio null() { return SVGPreserveAspectRatio(); }
-        static String toString(const SVGPreserveAspectRatio& type) { return type.valueAsString(); }
-    };
-
-    template<>
-    struct SVGAnimatedTypeValue<float> : Noncopyable {
-        typedef float StorableType;
-        typedef float DecoratedType;
-
-        static float null() { return 0.0f; }
-        static String toString(float type) { return String::number(type); }
-    };
-
-    template<>
-    struct SVGAnimatedTypeValue<FloatRect> : Noncopyable {
-        typedef FloatRect StorableType;
-        typedef FloatRect DecoratedType;
-
-        static FloatRect null() { return FloatRect(); }
-        static String toString(const FloatRect& type) { return String::format("%f %f %f %f", type.x(), type.y(), type.width(), type.height()); }
-    };
-
-    template<>
-    struct SVGAnimatedTypeValue<String> : Noncopyable {
-        typedef String StorableType;
-        typedef String DecoratedType;
-
-        static String null() { return String(); }
-        static String toString(const String& type) { return type; }
-    };
-
     // Common type definitions, to ease IDL generation.
     typedef SVGAnimatedTemplate<SVGAngle> SVGAnimatedAngle;
     typedef SVGAnimatedTemplate<bool> SVGAnimatedBoolean;
@@ -274,5 +171,5 @@ namespace WebCore {
 
 }
 
-#endif // ENABLE(SVG)
-#endif // SVGAnimatedTemplate_h
+#endif
+#endif
index ce3670d..729fb7e 100644 (file)
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2004, 2005 Nikolas Zimmermann <wildfox@kde.org>
+    Copyright (C) 2004, 2005 Nikolas Zimmermann <zimmermann@kde.org>
                   2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
     Copyright (C) 2007 Eric Seidel <eric@webkit.org>
     Copyright (C) 2008 Apple Inc. All rights reserved.
@@ -51,7 +51,6 @@ SVGAnimationElement::SVGAnimationElement(const QualifiedName& tagName, Document*
     : SVGSMILElement(tagName, doc)
     , SVGTests()
     , SVGExternalResourcesRequired() 
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
     , m_animationValid(false)
 {
 }
@@ -59,7 +58,7 @@ SVGAnimationElement::SVGAnimationElement(const QualifiedName& tagName, Document*
 SVGAnimationElement::~SVGAnimationElement()
 {
 }
-    
+
 static void parseKeyTimes(const String& parse, Vector<float>& result, bool verifyOrder)
 {
     result.clear();
@@ -141,6 +140,14 @@ void SVGAnimationElement::attributeChanged(Attribute* attr, bool preserveDecls)
     SVGSMILElement::attributeChanged(attr, preserveDecls);
 }
 
+void SVGAnimationElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGSMILElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName() || SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+}
+
 float SVGAnimationElement::getStartTime() const
 {
     return narrowPrecisionToFloat(intervalBegin().value());
index b0b091b..27cec88 100644 (file)
@@ -46,9 +46,10 @@ namespace WebCore {
     public:
         SVGAnimationElement(const QualifiedName&, Document*);
         virtual ~SVGAnimationElement();
-        
+
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void attributeChanged(Attribute*, bool preserveDecls);
+        virtual void synchronizeProperty(const QualifiedName&);
 
         // SVGAnimationElement
         float getStartTime() const;
@@ -106,9 +107,7 @@ namespace WebCore {
         
     protected:
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGAnimationElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGAnimationElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
 
         bool m_animationValid;
 
index d96842a..10da742 100644 (file)
@@ -36,10 +36,9 @@ SVGCircleElement::SVGCircleElement(const QualifiedName& tagName, Document* doc)
     , SVGTests()
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
-    , m_cx(this, SVGNames::cxAttr, LengthModeWidth)
-    , m_cy(this, SVGNames::cyAttr, LengthModeHeight)
-    , m_r(this, SVGNames::rAttr, LengthModeOther)
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
+    , m_cx(LengthModeWidth)
+    , m_cy(LengthModeHeight)
+    , m_r(LengthModeOther)
 {
 }
 
@@ -84,6 +83,28 @@ void SVGCircleElement::svgAttributeChanged(const QualifiedName& attrName)
         renderer()->setNeedsLayout(true);
 }
 
+void SVGCircleElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledTransformableElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeCx();
+        synchronizeCy();
+        synchronizeR();
+        synchronizeExternalResourcesRequired();
+        return;
+    }
+
+    if (attrName == SVGNames::cxAttr)
+        synchronizeCx();
+    else if (attrName == SVGNames::cyAttr)
+        synchronizeCy();
+    else if (attrName == SVGNames::rAttr)
+        synchronizeR();
+    else if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+}
+
 Path SVGCircleElement::toPathData() const
 {
     return Path::createCircle(FloatPoint(cx().value(this), cy().value(this)), r().value(this));
index 69b015d..027918c 100644 (file)
@@ -41,6 +41,7 @@ namespace WebCore {
 
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
 
         virtual Path toPathData() const;
 
@@ -48,14 +49,12 @@ namespace WebCore {
         virtual bool hasRelativeValues() const;
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGCircleElement, SVGNames::circleTagString, SVGNames::cxAttrString, SVGLength, Cx, cx)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGCircleElement, SVGNames::circleTagString, SVGNames::cyAttrString, SVGLength, Cy, cy)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGCircleElement, SVGNames::circleTagString, SVGNames::rAttrString, SVGLength, R, r)
+        DECLARE_ANIMATED_PROPERTY(SVGCircleElement, SVGNames::cxAttr, SVGLength, Cx, cx)
+        DECLARE_ANIMATED_PROPERTY(SVGCircleElement, SVGNames::cyAttr, SVGLength, Cy, cy)
+        DECLARE_ANIMATED_PROPERTY(SVGCircleElement, SVGNames::rAttr, SVGLength, R, r)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGCircleElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGCircleElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
     };
 
 } // namespace WebCore
index 78311d3..0fa12ff 100644 (file)
@@ -38,8 +38,7 @@ SVGClipPathElement::SVGClipPathElement(const QualifiedName& tagName, Document* d
     , SVGTests()
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
-    , m_clipPathUnits(this, SVGNames::clipPathUnitsAttr, SVGUnitTypes::SVG_UNIT_TYPE_USERSPACEONUSE)
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
+    , m_clipPathUnits(SVGUnitTypes::SVG_UNIT_TYPE_USERSPACEONUSE)
 {
 }
 
@@ -80,6 +79,22 @@ void SVGClipPathElement::svgAttributeChanged(const QualifiedName& attrName)
         m_clipper->invalidate();
 }
 
+void SVGClipPathElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledTransformableElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeClipPathUnits();
+        synchronizeExternalResourcesRequired();
+        return;
+    }
+
+    if (attrName == SVGNames::clipPathUnitsAttr)
+        synchronizeClipPathUnits();
+    else if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+}
+
 void SVGClipPathElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
 {
     SVGStyledTransformableElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
index ef6e629..cf7ff2b 100644 (file)
@@ -43,18 +43,17 @@ namespace WebCore {
 
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
 
         virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
         virtual SVGResource* canvasResource(const RenderObject*);
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGClipPathElement, SVGNames::clipPathTagString, SVGNames::clipPathUnitsAttrString, int, ClipPathUnits, clipPathUnits)
+        DECLARE_ANIMATED_PROPERTY(SVGClipPathElement, SVGNames::clipPathUnitsAttr, int, ClipPathUnits, clipPathUnits)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGClipPathElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGClipPathElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
 
         RefPtr<SVGResourceClipper> m_clipper;
     };
index bb08ebb..f61b2ea 100644 (file)
 
 namespace WebCore {
 
-char SVGComponentTransferFunctionElementIdentifier[] = "SVGComponentTransferFunctionElement";
-
 SVGComponentTransferFunctionElement::SVGComponentTransferFunctionElement(const QualifiedName& tagName, Document* doc)
     : SVGElement(tagName, doc)
-    , m_type(this, SVGNames::typeAttr, FECOMPONENTTRANSFER_TYPE_UNKNOWN)
-    , m_tableValues(this, SVGNames::tableValuesAttr, SVGNumberList::create(SVGNames::tableValuesAttr))
-    , m_slope(this, SVGNames::slopeAttr, 1.0f)
-    , m_intercept(this, SVGNames::interceptAttr)
-    , m_amplitude(this, SVGNames::amplitudeAttr, 1.0f)
-    , m_exponent(this, SVGNames::exponentAttr, 1.0f)
-    , m_offset(this, SVGNames::offsetAttr)
+    , m_type(FECOMPONENTTRANSFER_TYPE_UNKNOWN)
+    , m_tableValues(SVGNumberList::create(SVGNames::tableValuesAttr))
+    , m_slope(1.0f)
+    , m_amplitude(1.0f)
+    , m_exponent(1.0f)
 {
 }
 
@@ -51,8 +47,7 @@ SVGComponentTransferFunctionElement::~SVGComponentTransferFunctionElement()
 void SVGComponentTransferFunctionElement::parseMappedAttribute(MappedAttribute* attr)
 {
     const String& value = attr->value();
-    if (attr->name() == SVGNames::typeAttr)
-    {
+    if (attr->name() == SVGNames::typeAttr) {
         if (value == "identity")
             setTypeBaseValue(FECOMPONENTTRANSFER_TYPE_IDENTITY);
         else if (value == "table")
@@ -80,6 +75,37 @@ void SVGComponentTransferFunctionElement::parseMappedAttribute(MappedAttribute*
         SVGElement::parseMappedAttribute(attr);
 }
 
+void SVGComponentTransferFunctionElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeType();
+        synchronizeTableValues();
+        synchronizeSlope();
+        synchronizeIntercept();
+        synchronizeAmplitude();
+        synchronizeExponent();
+        synchronizeOffset();
+        return;
+    }
+
+    if (attrName == SVGNames::typeAttr)
+        synchronizeType();
+    else if (attrName == SVGNames::tableValuesAttr)
+        synchronizeTableValues();
+    else if (attrName == SVGNames::slopeAttr)
+        synchronizeSlope();
+    else if (attrName == SVGNames::interceptAttr)
+        synchronizeIntercept();
+    else if (attrName == SVGNames::amplitudeAttr)
+        synchronizeAmplitude();
+    else if (attrName == SVGNames::exponentAttr)
+        synchronizeExponent();
+    else if (attrName == SVGNames::offsetAttr)
+        synchronizeOffset();
+}
+
 ComponentTransferFunction SVGComponentTransferFunctionElement::transferFunction() const
 {
     ComponentTransferFunction func;
@@ -100,6 +126,4 @@ ComponentTransferFunction SVGComponentTransferFunctionElement::transferFunction(
 
 }
 
-// vim:ts=4:noet
 #endif // ENABLE(SVG)
-
index c955df5..9862a99 100644 (file)
 
 namespace WebCore {
 
-    extern char SVGComponentTransferFunctionElementIdentifier[];
-
     class SVGComponentTransferFunctionElement : public SVGElement {
     public:
         SVGComponentTransferFunctionElement(const QualifiedName&, Document*);
         virtual ~SVGComponentTransferFunctionElement();
 
-        virtual void parseMappedAttribute(MappedAttribute* attr);
+        virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
         
         ComponentTransferFunction transferFunction() const;
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGComponentTransferFunctionElement, SVGComponentTransferFunctionElementIdentifier, SVGNames::typeAttrString, int, Type, type)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGComponentTransferFunctionElement, SVGComponentTransferFunctionElementIdentifier, SVGNames::tableValuesAttrString, SVGNumberList, TableValues, tableValues)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGComponentTransferFunctionElement, SVGComponentTransferFunctionElementIdentifier, SVGNames::slopeAttrString, float, Slope, slope)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGComponentTransferFunctionElement, SVGComponentTransferFunctionElementIdentifier, SVGNames::interceptAttrString, float, Intercept, intercept)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGComponentTransferFunctionElement, SVGComponentTransferFunctionElementIdentifier, SVGNames::amplitudeAttrString, float, Amplitude, amplitude)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGComponentTransferFunctionElement, SVGComponentTransferFunctionElementIdentifier, SVGNames::exponentAttrString, float, Exponent, exponent)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGComponentTransferFunctionElement, SVGComponentTransferFunctionElementIdentifier, SVGNames::offsetAttrString, float, Offset, offset)
+        DECLARE_ANIMATED_PROPERTY(SVGComponentTransferFunctionElement, SVGNames::typeAttr, int, Type, type)
+        DECLARE_ANIMATED_PROPERTY(SVGComponentTransferFunctionElement, SVGNames::tableValuesAttr, SVGNumberList*, TableValues, tableValues)
+        DECLARE_ANIMATED_PROPERTY(SVGComponentTransferFunctionElement, SVGNames::slopeAttr, float, Slope, slope)
+        DECLARE_ANIMATED_PROPERTY(SVGComponentTransferFunctionElement, SVGNames::interceptAttr, float, Intercept, intercept)
+        DECLARE_ANIMATED_PROPERTY(SVGComponentTransferFunctionElement, SVGNames::amplitudeAttr, float, Amplitude, amplitude)
+        DECLARE_ANIMATED_PROPERTY(SVGComponentTransferFunctionElement, SVGNames::exponentAttr, float, Exponent, exponent)
+        DECLARE_ANIMATED_PROPERTY(SVGComponentTransferFunctionElement, SVGNames::offsetAttr, float, Offset, offset)
     };
 
 } // namespace WebCore
index f5aa615..e904516 100644 (file)
@@ -36,10 +36,8 @@ SVGCursorElement::SVGCursorElement(const QualifiedName& tagName, Document* doc)
     , SVGTests()
     , SVGExternalResourcesRequired()
     , SVGURIReference()
-    , m_x(this, SVGNames::xAttr, LengthModeWidth)
-    , m_y(this, SVGNames::yAttr, LengthModeHeight)
-    , m_href(this, XLinkNames::hrefAttr)
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
+    , m_x(LengthModeWidth)
+    , m_y(LengthModeHeight)
 {
 }
 
@@ -96,6 +94,28 @@ void SVGCursorElement::svgAttributeChanged(const QualifiedName& attrName)
     }
 }
 
+void SVGCursorElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeX();
+        synchronizeY();
+        synchronizeExternalResourcesRequired();
+        synchronizeHref();
+        return;
+    }
+
+    if (attrName == SVGNames::xAttr)
+        synchronizeX();
+    else if (attrName == SVGNames::yAttr)
+        synchronizeY();
+    else if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+    else if (SVGURIReference::isKnownAttribute(attrName))
+        synchronizeHref();
+}
+
 void SVGCursorElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
 {
     SVGElement::addSubresourceAttributeURLs(urls);
index ee919a4..0978124 100644 (file)
@@ -45,20 +45,19 @@ namespace WebCore {
 
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
 
         virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const;
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGCursorElement, SVGNames::cursorTagString, SVGNames::xAttrString, SVGLength, X, x)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGCursorElement, SVGNames::cursorTagString, SVGNames::yAttrString, SVGLength, Y, y)
+        DECLARE_ANIMATED_PROPERTY(SVGCursorElement, SVGNames::xAttr, SVGLength, X, x)
+        DECLARE_ANIMATED_PROPERTY(SVGCursorElement, SVGNames::yAttr, SVGLength, Y, y)
 
         // SVGURIReference
-        ANIMATED_PROPERTY_DECLARATIONS(SVGCursorElement, SVGURIReferenceIdentifier, XLinkNames::hrefAttrString, String, Href, href)
+        DECLARE_ANIMATED_PROPERTY(SVGCursorElement, XLinkNames::hrefAttr, String, Href, href)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGCursorElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGCursorElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
 
         HashSet<SVGElement*> m_clients;
     };
index 051edeb..e7bf51d 100644 (file)
@@ -32,7 +32,6 @@ SVGDefsElement::SVGDefsElement(const QualifiedName& tagName, Document* doc)
     , SVGTests()
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
 {
 }
 
@@ -50,6 +49,14 @@ RenderObject* SVGDefsElement::createRenderer(RenderArena* arena, RenderStyle*)
     return new (arena) RenderSVGHiddenContainer(this);
 }
 
+void SVGDefsElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledTransformableElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName() || SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+}
+
 }
 
 #endif // ENABLE(SVG)
index 4bb206e..cb62d45 100644 (file)
@@ -40,12 +40,11 @@ namespace WebCore {
         virtual bool isValid() const;
 
         virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
+        virtual void synchronizeProperty(const QualifiedName&);
 
     private:
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGDefsElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGDefsElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
     };
 
 } // namespace WebCore
index b66e2dc..050e6f6 100644 (file)
 
 #include "StringHash.h"
 #include "StringImpl.h"
-#include "SVGAnimatedTemplate.h"
 
 namespace WebCore {
 
 class Document;
-class EventListener;
-class Node;
 class String;
-class SVGElementInstance;
 class SVGStyledElement;
 class SVGSMILElement;
 class SVGSVGElement;
@@ -68,13 +64,6 @@ private:
     SVGDocumentExtensions(const SVGDocumentExtensions&);
     SVGDocumentExtensions& operator=(const SVGDocumentExtensions&);
 
-    template<typename ValueType>
-    HashMap<const SVGElement*, HashMap<StringImpl*, ValueType>*>* baseValueMap() const
-    {
-        static HashMap<const SVGElement*, HashMap<StringImpl*, ValueType>*>* s_baseValueMap = new HashMap<const SVGElement*, HashMap<StringImpl*, ValueType>*>();
-        return s_baseValueMap;
-    }
-
 public:
     // This HashMap contains a list of pending resources. Pending resources, are such
     // which are referenced by any object in the SVG document, but do NOT exist yet.
@@ -82,52 +71,9 @@ public:
     void addPendingResource(const AtomicString& id, SVGStyledElement*);
     bool isPendingResource(const AtomicString& id) const;
     std::auto_ptr<HashSet<SVGStyledElement*> > removePendingResource(const AtomicString& id);
-
-    // Used by the ANIMATED_PROPERTY_* macros
-    template<typename ValueType>
-    ValueType baseValue(const SVGElement* element, const AtomicString& propertyName) const
-    {
-        HashMap<StringImpl*, ValueType>* propertyMap = baseValueMap<ValueType>()->get(element);
-        if (propertyMap)
-            return propertyMap->get(propertyName.impl());
-
-        return SVGAnimatedTypeValue<ValueType>::null();
-    }
-
-    template<typename ValueType>
-    void setBaseValue(const SVGElement* element, const AtomicString& propertyName, ValueType newValue)
-    {
-        HashMap<StringImpl*, ValueType>* propertyMap = baseValueMap<ValueType>()->get(element);
-        if (!propertyMap) {
-            propertyMap = new HashMap<StringImpl*, ValueType>();
-            baseValueMap<ValueType>()->set(element, propertyMap);
-        }
-
-        propertyMap->set(propertyName.impl(), newValue);
-    }
-
-    template<typename ValueType>
-    void removeBaseValue(const SVGElement* element, const AtomicString& propertyName)
-    {
-        HashMap<StringImpl*, ValueType>* propertyMap = baseValueMap<ValueType>()->get(element);
-        if (!propertyMap)
-            return;
-
-        propertyMap->remove(propertyName.impl());
-    }
-
-    template<typename ValueType>
-    bool hasBaseValue(const SVGElement* element, const AtomicString& propertyName) const
-    {
-        HashMap<StringImpl*, ValueType>* propertyMap = baseValueMap<ValueType>()->get(element);
-        if (propertyMap)
-            return propertyMap->contains(propertyName.impl());
-
-        return false;
-    }
 };
 
 }
 
-#endif // ENABLE(SVG)
+#endif
 #endif
index d039a4f..c2cc36a 100644 (file)
@@ -38,7 +38,6 @@
 #include "RegisteredEventListener.h"
 #include "RenderObject.h"
 #include "SVGCursorElement.h"
-#include "SVGDocumentExtensions.h"
 #include "SVGElementInstance.h"
 #include "SVGNames.h"
 #include "SVGResource.h"
@@ -259,7 +258,7 @@ void SVGElement::attributeChanged(Attribute* attr, bool preserveDecls)
     svgAttributeChanged(attr->name());
 }
 
-void SVGElement::updateAnimatedSVGAttribute(const String& name) const
+void SVGElement::updateAnimatedSVGAttribute(const QualifiedName& name) const
 {
     ASSERT(!m_areSVGAttributesValid);
 
@@ -268,20 +267,13 @@ void SVGElement::updateAnimatedSVGAttribute(const String& name) const
 
     m_synchronizingSVGAttributes = true;
 
-    if (name.isEmpty()) {
-        m_propertyController.synchronizeAllProperties();
-        setSynchronizedSVGAttributes(true);
-    } else
-        m_propertyController.synchronizeProperty(name);
+    const_cast<SVGElement*>(this)->synchronizeProperty(name);
+    if (name == anyQName())
+        m_areSVGAttributesValid = true;
 
     m_synchronizingSVGAttributes = false;
 }
 
-void SVGElement::setSynchronizedSVGAttributes(bool value) const
-{
-    m_areSVGAttributesValid = value;
-}
-
 ContainerNode* SVGElement::eventParentNode()
 {
     if (Node* shadowParent = shadowParentNode()) {
index 4e7f498..89e533a 100644 (file)
 #define SVGElement_h
 
 #if ENABLE(SVG)
+#include "SVGDocumentExtensions.h"
 #include "StyledElement.h"
-#include "SVGAnimatedProperty.h"
-#include "SynchronizablePropertyController.h"
 
 namespace WebCore {
 
     class CSSCursorImageValue;
     class Document;
     class SVGCursorElement;
-    class SVGDocumentExtensions;
     class SVGElementInstance;
     class SVGSVGElement;
     class TransformationMatrix;
@@ -67,27 +65,26 @@ namespace WebCore {
         virtual bool childShouldCreateRenderer(Node*) const;
 
         virtual void svgAttributeChanged(const QualifiedName&) { }
+        virtual void synchronizeProperty(const QualifiedName&) { }
 
         void sendSVGLoadEventIfPossible(bool sendParentLoadEvents = false);
         
         virtual TransformationMatrix* supplementalTransform() { return 0; }
 
-        virtual void setSynchronizedSVGAttributes(bool) const;
+        void setSynchronizedSVGAttributes(bool value) { m_areSVGAttributesValid = value; }
 
         HashSet<SVGElementInstance*> instancesForElement() const;
 
         void setCursorElement(SVGCursorElement* cursorElement) { m_cursorElement = cursorElement; }
         void setCursorImageValue(CSSCursorImageValue* cursorImageValue) { m_cursorImageValue = cursorImageValue; }
 
-        SynchronizablePropertyController& propertyController() const { return m_propertyController; }
-
     protected:
         SVGElement(const QualifiedName&, Document*);
 
         virtual void finishParsingChildren();
         virtual void insertedIntoDocument();
         virtual void attributeChanged(Attribute*, bool preserveDecls = false);
-        virtual void updateAnimatedSVGAttribute(const String&) const;
+        virtual void updateAnimatedSVGAttribute(const QualifiedName&) const;
 
     private:
         friend class SVGElementInstance;
@@ -103,15 +100,16 @@ namespace WebCore {
 
         virtual bool haveLoadedRequiredResources();
 
-        mutable SynchronizablePropertyController m_propertyController;
-
         SVGCursorElement* m_cursorElement;
         CSSCursorImageValue* m_cursorImageValue;
 
         HashSet<SVGElementInstance*> m_elementInstances;
     };
 
-} // namespace WebCore 
+}
+
+// This file needs to be included after the SVGElement declaration
+#include "SVGAnimatedProperty.h"
 
-#endif // ENABLE(SVG)
-#endif // SVGElement_h
+#endif
+#endif
index 3946fb9..a7400fa 100644 (file)
@@ -36,11 +36,10 @@ SVGEllipseElement::SVGEllipseElement(const QualifiedName& tagName, Document* doc
     , SVGTests()
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
-    , m_cx(this, SVGNames::cxAttr, LengthModeWidth)
-    , m_cy(this, SVGNames::cyAttr, LengthModeHeight)
-    , m_rx(this, SVGNames::rxAttr, LengthModeWidth)
-    , m_ry(this, SVGNames::ryAttr, LengthModeHeight)
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
+    , m_cx(LengthModeWidth)
+    , m_cy(LengthModeHeight)
+    , m_rx(LengthModeWidth)
+    , m_ry(LengthModeHeight)
 {
 }    
 
@@ -89,6 +88,31 @@ void SVGEllipseElement::svgAttributeChanged(const QualifiedName& attrName)
         renderer()->setNeedsLayout(true);
 }
 
+void SVGEllipseElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledTransformableElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeCx();
+        synchronizeCy();
+        synchronizeRx();
+        synchronizeRy();
+        synchronizeExternalResourcesRequired();
+        return;
+    }
+
+    if (attrName == SVGNames::cxAttr)
+        synchronizeCx();
+    else if (attrName == SVGNames::cyAttr)
+        synchronizeCy();
+    else if (attrName == SVGNames::rxAttr)
+        synchronizeRx();
+    else if (attrName == SVGNames::ryAttr)
+        synchronizeRy();
+    else if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+}
+
 Path SVGEllipseElement::toPathData() const
 {
     return Path::createEllipse(FloatPoint(cx().value(this), cy().value(this)),
index 5b54fd5..adaa0d2 100644 (file)
@@ -41,6 +41,7 @@ namespace WebCore {
 
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
 
         virtual Path toPathData() const;
 
@@ -48,15 +49,13 @@ namespace WebCore {
         virtual bool hasRelativeValues() const;
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGEllipseElement, SVGNames::ellipseTagString, SVGNames::cxAttrString, SVGLength, Cx, cx)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGEllipseElement, SVGNames::ellipseTagString, SVGNames::cyAttrString, SVGLength, Cy, cy)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGEllipseElement, SVGNames::ellipseTagString, SVGNames::rxAttrString, SVGLength, Rx, rx)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGEllipseElement, SVGNames::ellipseTagString, SVGNames::ryAttrString, SVGLength, Ry, ry)
+        DECLARE_ANIMATED_PROPERTY(SVGEllipseElement, SVGNames::cxAttr, SVGLength, Cx, cx)
+        DECLARE_ANIMATED_PROPERTY(SVGEllipseElement, SVGNames::cyAttr, SVGLength, Cy, cy)
+        DECLARE_ANIMATED_PROPERTY(SVGEllipseElement, SVGNames::rxAttr, SVGLength, Rx, rx)
+        DECLARE_ANIMATED_PROPERTY(SVGEllipseElement, SVGNames::ryAttr, SVGLength, Ry, ry)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGEllipseElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGEllipseElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
     };
 
 } // namespace WebCore
index b6b62d1..99bc5eb 100644 (file)
@@ -30,8 +30,6 @@
 
 namespace WebCore {
 
-char SVGExternalResourcesRequiredIdentifier[] = "SVGExternalResourcesRequired";
-
 SVGExternalResourcesRequired::SVGExternalResourcesRequired()
 {
 }
index f088c82..b2a741d 100644 (file)
@@ -27,7 +27,6 @@
 
 namespace WebCore {
 
-    extern char SVGExternalResourcesRequiredIdentifier[];
     class MappedAttribute;
 
     // Notes on a SVG 1.1 spec discrepancy:
@@ -44,7 +43,7 @@ namespace WebCore {
         bool isKnownAttribute(const QualifiedName&);
 
     protected:
-        virtual void setExternalResourcesRequiredBaseValue(SVGAnimatedTypeValue<bool>::DecoratedType type) = 0;
+        virtual void setExternalResourcesRequiredBaseValue(SVGAnimatedPropertyTraits<bool>::PassType) = 0;
     };
 
 } // namespace WebCore
index 03c5795..46c412c 100644 (file)
@@ -30,9 +30,7 @@ namespace WebCore {
 
 SVGFEBlendElement::SVGFEBlendElement(const QualifiedName& tagName, Document* doc)
     : SVGFilterPrimitiveStandardAttributes(tagName, doc)
-    , m_in1(this, SVGNames::inAttr)
-    , m_in2(this, SVGNames::in2Attr)
-    , m_mode(this, SVGNames::modeAttr, FEBLEND_MODE_NORMAL)
+    , m_mode(FEBLEND_MODE_NORMAL)
 {
 }
 
@@ -62,6 +60,25 @@ void SVGFEBlendElement::parseMappedAttribute(MappedAttribute* attr)
         SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(attr);
 }
 
+void SVGFEBlendElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGFilterPrimitiveStandardAttributes::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeMode();
+        synchronizeIn1();
+        synchronizeIn2();
+        return;
+    }
+
+    if (attrName == SVGNames::modeAttr)
+        synchronizeMode();
+    else if (attrName == SVGNames::inAttr)
+        synchronizeIn1();
+    else if (attrName == SVGNames::in2Attr)
+        synchronizeIn2();
+}
+
 bool SVGFEBlendElement::build(SVGResourceFilter* filterResource)
 {
     FilterEffect* input1 = filterResource->builder()->getEffectById(in1());
index c32eabd..7e32244 100644 (file)
@@ -32,12 +32,13 @@ namespace WebCore {
         virtual ~SVGFEBlendElement();
 
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual bool build(SVGResourceFilter*);
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEBlendElement, SVGNames::feBlendTagString, SVGNames::inAttrString, String, In1, in1)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEBlendElement, SVGNames::feBlendTagString, SVGNames::in2AttrString, String, In2, in2)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEBlendElement, SVGNames::feBlendTagString, SVGNames::modeAttrString, int, Mode, mode)
+        DECLARE_ANIMATED_PROPERTY(SVGFEBlendElement, SVGNames::inAttr, String, In1, in1)
+        DECLARE_ANIMATED_PROPERTY(SVGFEBlendElement, SVGNames::in2Attr, String, In2, in2)
+        DECLARE_ANIMATED_PROPERTY(SVGFEBlendElement, SVGNames::modeAttr, int, Mode, mode)
     };
 
 } // namespace WebCore
index 88a0d66..e27ad86 100644 (file)
@@ -32,9 +32,8 @@ namespace WebCore {
 
 SVGFEColorMatrixElement::SVGFEColorMatrixElement(const QualifiedName& tagName, Document* doc)
     : SVGFilterPrimitiveStandardAttributes(tagName, doc)
-    , m_in1(this, SVGNames::inAttr)
-    , m_type(this, SVGNames::typeAttr, FECOLORMATRIX_TYPE_UNKNOWN)
-    , m_values(this, SVGNames::valuesAttr, SVGNumberList::create(SVGNames::valuesAttr))
+    , m_type(FECOLORMATRIX_TYPE_UNKNOWN)
+    , m_values(SVGNumberList::create(SVGNames::valuesAttr))
 {
 }
 
@@ -63,6 +62,25 @@ void SVGFEColorMatrixElement::parseMappedAttribute(MappedAttribute* attr)
         SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(attr);
 }
 
+void SVGFEColorMatrixElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGFilterPrimitiveStandardAttributes::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeType();
+        synchronizeIn1();
+        synchronizeValues();
+        return;
+    }
+
+    if (attrName == SVGNames::typeAttr)
+        synchronizeType();
+    else if (attrName == SVGNames::inAttr)
+        synchronizeIn1();
+    else if (attrName == SVGNames::valuesAttr)
+        synchronizeValues();
+}
+
 bool SVGFEColorMatrixElement::build(SVGResourceFilter* filterResource)
 {
     FilterEffect* input1 = filterResource->builder()->getEffectById(in1());
index f3329e4..811494d 100644 (file)
@@ -34,12 +34,13 @@ namespace WebCore {
         virtual ~SVGFEColorMatrixElement();
 
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual bool build(SVGResourceFilter*);
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEColorMatrixElement, SVGNames::feColorMatrixTagString, SVGNames::inAttrString, String, In1, in1)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEColorMatrixElement, SVGNames::feColorMatrixTagString, SVGNames::typeAttrString, int, Type, type)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEColorMatrixElement, SVGNames::feColorMatrixTagString, SVGNames::valuesAttrString, SVGNumberList, Values, values)
+        DECLARE_ANIMATED_PROPERTY(SVGFEColorMatrixElement, SVGNames::inAttr, String, In1, in1)
+        DECLARE_ANIMATED_PROPERTY(SVGFEColorMatrixElement, SVGNames::typeAttr, int, Type, type)
+        DECLARE_ANIMATED_PROPERTY(SVGFEColorMatrixElement, SVGNames::valuesAttr, SVGNumberList*, Values, values)
     };
 
 } // namespace WebCore
index f1df08c..4cda9c9 100644 (file)
@@ -37,7 +37,6 @@ namespace WebCore {
 
 SVGFEComponentTransferElement::SVGFEComponentTransferElement(const QualifiedName& tagName, Document* doc)
     : SVGFilterPrimitiveStandardAttributes(tagName, doc)
-    , m_in1(this, SVGNames::inAttr)
 {
 }
 
@@ -54,6 +53,14 @@ void SVGFEComponentTransferElement::parseMappedAttribute(MappedAttribute* attr)
         SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(attr);
 }
 
+void SVGFEComponentTransferElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGFilterPrimitiveStandardAttributes::synchronizeProperty(attrName);
+
+    if (attrName == anyQName() || attrName == SVGNames::inAttr)
+        synchronizeIn1();
+}
+
 bool SVGFEComponentTransferElement::build(SVGResourceFilter* filterResource)
 {
     FilterEffect* input1 = filterResource->builder()->getEffectById(in1());
index 46d6d9d..b1d9373 100644 (file)
@@ -33,10 +33,11 @@ namespace WebCore {
         virtual ~SVGFEComponentTransferElement();
 
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual bool build(SVGResourceFilter*);
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEComponentTransferElement, SVGNames::feComponentTransferTagString, SVGNames::inAttrString, String, In1, in1)
+        DECLARE_ANIMATED_PROPERTY(SVGFEComponentTransferElement, SVGNames::inAttr, String, In1, in1)
     };
 
 } // namespace WebCore
index a2dd05a..734c2fe 100644 (file)
@@ -31,13 +31,7 @@ namespace WebCore {
 
 SVGFECompositeElement::SVGFECompositeElement(const QualifiedName& tagName, Document* doc)
     : SVGFilterPrimitiveStandardAttributes(tagName, doc)
-    , m_in1(this, SVGNames::inAttr)
-    , m_in2(this, SVGNames::in2Attr)
-    , m__operator(this, SVGNames::operatorAttr, FECOMPOSITE_OPERATOR_OVER)
-    , m_k1(this, SVGNames::k1Attr)
-    , m_k2(this, SVGNames::k2Attr)
-    , m_k3(this, SVGNames::k3Attr)
-    , m_k4(this, SVGNames::k4Attr)
+    , m__operator(FECOMPOSITE_OPERATOR_OVER)
 {
 }
 
@@ -61,8 +55,7 @@ void SVGFECompositeElement::parseMappedAttribute(MappedAttribute *attr)
             set_operatorBaseValue(FECOMPOSITE_OPERATOR_XOR);
         else if (value == "arithmetic")
             set_operatorBaseValue(FECOMPOSITE_OPERATOR_ARITHMETIC);
-    }
-    else if (attr->name() == SVGNames::inAttr)
+    } else if (attr->name() == SVGNames::inAttr)
         setIn1BaseValue(value);
     else if (attr->name() == SVGNames::in2Attr)
         setIn2BaseValue(value);
@@ -78,6 +71,37 @@ void SVGFECompositeElement::parseMappedAttribute(MappedAttribute *attr)
         SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(attr);
 }
 
+void SVGFECompositeElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGFilterPrimitiveStandardAttributes::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronize_operator();
+        synchronizeIn1();
+        synchronizeIn2();
+        synchronizeK1();
+        synchronizeK2();
+        synchronizeK3();
+        synchronizeK4();
+        return;
+    }
+
+    if (attrName == SVGNames::operatorAttr)
+        synchronize_operator();
+    else if (attrName == SVGNames::inAttr)
+        synchronizeIn1();
+    else if (attrName == SVGNames::in2Attr)
+        synchronizeIn2();
+    else if (attrName == SVGNames::k1Attr)
+        synchronizeK1();
+    else if (attrName == SVGNames::k2Attr)
+        synchronizeK2();
+    else if (attrName == SVGNames::k3Attr)
+        synchronizeK3();
+    else if (attrName == SVGNames::k4Attr)
+        synchronizeK4();
+}
+
 bool SVGFECompositeElement::build(SVGResourceFilter* filterResource)
 {
     FilterEffect* input1 = filterResource->builder()->getEffectById(in1());
index 1bb6b05..c9fecc8 100644 (file)
@@ -33,16 +33,17 @@ namespace WebCore {
         virtual ~SVGFECompositeElement();
 
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual bool build(SVGResourceFilter*);
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFECompositeElement, SVGNames::feCompositeTagString, SVGNames::inAttrString, String, In1, in1)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFECompositeElement, SVGNames::feCompositeTagString, SVGNames::in2AttrString, String, In2, in2)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFECompositeElement, SVGNames::feCompositeTagString, SVGNames::operatorAttrString, int, _operator, _operator)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFECompositeElement, SVGNames::feCompositeTagString, SVGNames::k1AttrString, float, K1, k1)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFECompositeElement, SVGNames::feCompositeTagString, SVGNames::k2AttrString, float, K2, k2)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFECompositeElement, SVGNames::feCompositeTagString, SVGNames::k3AttrString, float, K3, k3)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFECompositeElement, SVGNames::feCompositeTagString, SVGNames::k4AttrString, float, K4, k4)
+        DECLARE_ANIMATED_PROPERTY(SVGFECompositeElement, SVGNames::inAttr, String, In1, in1)
+        DECLARE_ANIMATED_PROPERTY(SVGFECompositeElement, SVGNames::in2Attr, String, In2, in2)
+        DECLARE_ANIMATED_PROPERTY(SVGFECompositeElement, SVGNames::operatorAttr, int, _operator, _operator)
+        DECLARE_ANIMATED_PROPERTY(SVGFECompositeElement, SVGNames::k1Attr, float, K1, k1)
+        DECLARE_ANIMATED_PROPERTY(SVGFECompositeElement, SVGNames::k2Attr, float, K2, k2)
+        DECLARE_ANIMATED_PROPERTY(SVGFECompositeElement, SVGNames::k3Attr, float, K3, k3)
+        DECLARE_ANIMATED_PROPERTY(SVGFECompositeElement, SVGNames::k4Attr, float, K4, k4)
     };
 
 } // namespace WebCore
index ed6e353..a3db66d 100644 (file)
@@ -40,11 +40,8 @@ char SVGKernelUnitLengthYIdentifier[] = "SVGKernelUnitLengthY";
 
 SVGFEDiffuseLightingElement::SVGFEDiffuseLightingElement(const QualifiedName& tagName, Document* doc)
     : SVGFilterPrimitiveStandardAttributes(tagName, doc)
-    , m_in1(this, SVGNames::inAttr)
-    , m_diffuseConstant(this, SVGNames::diffuseConstantAttr, 1.0f)
-    , m_surfaceScale(this, SVGNames::surfaceScaleAttr, 1.0f)
-    , m_kernelUnitLengthX(this, SVGNames::kernelUnitLengthAttr)
-    , m_kernelUnitLengthY(this, SVGNames::kernelUnitLengthAttr)
+    , m_diffuseConstant(1.0f)
+    , m_surfaceScale(1.0f)
 {
 }
 
@@ -71,6 +68,31 @@ void SVGFEDiffuseLightingElement::parseMappedAttribute(MappedAttribute *attr)
         SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(attr);
 }
 
+void SVGFEDiffuseLightingElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGFilterPrimitiveStandardAttributes::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeIn1();
+        synchronizeSurfaceScale();
+        synchronizeDiffuseConstant();
+        synchronizeKernelUnitLengthX();
+        synchronizeKernelUnitLengthY();
+        return;
+    }
+
+    if (attrName == SVGNames::inAttr)
+        synchronizeIn1();
+    else if (attrName == SVGNames::surfaceScaleAttr)
+        synchronizeSurfaceScale();
+    else if (attrName == SVGNames::diffuseConstantAttr)
+        synchronizeDiffuseConstant();
+    else if (attrName == SVGNames::kernelUnitLengthAttr) {
+        synchronizeKernelUnitLengthX();
+        synchronizeKernelUnitLengthY();
+    }
+}
+
 bool SVGFEDiffuseLightingElement::build(SVGResourceFilter* filterResource)
 {
     FilterEffect* input1 = filterResource->builder()->getEffectById(in1());
index ed117a4..2e1b8cf 100644 (file)
@@ -40,14 +40,15 @@ namespace WebCore {
         virtual ~SVGFEDiffuseLightingElement();
 
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual bool build(SVGResourceFilter*);
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEDiffuseLightingElement, SVGNames::feDiffuseLightingTagString, SVGNames::inAttrString, String, In1, in1)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEDiffuseLightingElement, SVGNames::feDiffuseLightingTagString, SVGNames::diffuseConstantAttrString, float, DiffuseConstant, diffuseConstant)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEDiffuseLightingElement, SVGNames::feDiffuseLightingTagString, SVGNames::surfaceScaleAttrString, float, SurfaceScale, surfaceScale)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEDiffuseLightingElement, SVGNames::feDiffuseLightingTagString, SVGKernelUnitLengthXIdentifier, float, KernelUnitLengthX, kernelUnitLengthX)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEDiffuseLightingElement, SVGNames::feDiffuseLightingTagString, SVGKernelUnitLengthYIdentifier, float, KernelUnitLengthY, kernelUnitLengthY)
+        DECLARE_ANIMATED_PROPERTY(SVGFEDiffuseLightingElement, SVGNames::inAttr, String, In1, in1)
+        DECLARE_ANIMATED_PROPERTY(SVGFEDiffuseLightingElement, SVGNames::diffuseConstantAttr, float, DiffuseConstant, diffuseConstant)
+        DECLARE_ANIMATED_PROPERTY(SVGFEDiffuseLightingElement, SVGNames::surfaceScaleAttr, float, SurfaceScale, surfaceScale)
+        DECLARE_ANIMATED_PROPERTY_MULTIPLE_WRAPPERS(SVGFEDiffuseLightingElement, SVGNames::kernelUnitLengthAttr, SVGKernelUnitLengthXIdentifier, float, KernelUnitLengthX, kernelUnitLengthX)
+        DECLARE_ANIMATED_PROPERTY_MULTIPLE_WRAPPERS(SVGFEDiffuseLightingElement, SVGNames::kernelUnitLengthAttr, SVGKernelUnitLengthYIdentifier, float, KernelUnitLengthY, kernelUnitLengthY)
 
         PassRefPtr<LightSource> findLights() const;
     };
index adf02fe..b4fcb92 100644 (file)
@@ -29,11 +29,8 @@ namespace WebCore {
 
 SVGFEDisplacementMapElement::SVGFEDisplacementMapElement(const QualifiedName& tagName, Document* doc)
     : SVGFilterPrimitiveStandardAttributes(tagName, doc)
-    , m_in1(this, SVGNames::inAttr)
-    , m_in2(this, SVGNames::in2Attr)
-    , m_xChannelSelector(this, SVGNames::xChannelSelectorAttr, CHANNEL_A)
-    , m_yChannelSelector(this, SVGNames::yChannelSelectorAttr, CHANNEL_A)
-    , m_scale(this, SVGNames::scaleAttr)
+    , m_xChannelSelector(CHANNEL_A)
+    , m_yChannelSelector(CHANNEL_A)
 {
 }
 
@@ -72,6 +69,31 @@ void SVGFEDisplacementMapElement::parseMappedAttribute(MappedAttribute* attr)
         SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(attr);
 }
 
+void SVGFEDisplacementMapElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGFilterPrimitiveStandardAttributes::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeXChannelSelector();
+        synchronizeYChannelSelector();
+        synchronizeIn1();
+        synchronizeIn2();
+        synchronizeScale();
+        return;
+    }
+
+    if (attrName == SVGNames::xChannelSelectorAttr)
+        synchronizeXChannelSelector();
+    else if (attrName == SVGNames::yChannelSelectorAttr)
+        synchronizeYChannelSelector();
+    else if (attrName == SVGNames::inAttr)
+        synchronizeIn1();
+    else if (attrName == SVGNames::in2Attr)
+        synchronizeIn2();
+    else if (attrName == SVGNames::scaleAttr)
+        synchronizeScale();
+}
+
 bool SVGFEDisplacementMapElement::build(SVGResourceFilter* filterResource)
 {
     FilterEffect* input1 = filterResource->builder()->getEffectById(in1());
index 48e6930..95c6672 100644 (file)
@@ -34,14 +34,15 @@ namespace WebCore {
         static ChannelSelectorType stringToChannel(const String&);
         
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual bool build(SVGResourceFilter*);
         
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEDisplacementMapElement, SVGNames::feDisplacementMapTagString, SVGNames::inAttrString, String, In1, in1)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEDisplacementMapElement, SVGNames::feDisplacementMapTagString, SVGNames::in2AttrString, String, In2, in2)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEDisplacementMapElement, SVGNames::feDisplacementMapTagString, SVGNames::xChannelSelectorAttrString, int, XChannelSelector, xChannelSelector)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEDisplacementMapElement, SVGNames::feDisplacementMapTagString, SVGNames::yChannelSelectorAttrString, int, YChannelSelector, yChannelSelector)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEDisplacementMapElement, SVGNames::feDisplacementMapTagString, SVGNames::scaleAttrString, float, Scale, scale)
+        DECLARE_ANIMATED_PROPERTY(SVGFEDisplacementMapElement, SVGNames::inAttr, String, In1, in1)
+        DECLARE_ANIMATED_PROPERTY(SVGFEDisplacementMapElement, SVGNames::in2Attr, String, In2, in2)
+        DECLARE_ANIMATED_PROPERTY(SVGFEDisplacementMapElement, SVGNames::xChannelSelectorAttr, int, XChannelSelector, xChannelSelector)
+        DECLARE_ANIMATED_PROPERTY(SVGFEDisplacementMapElement, SVGNames::yChannelSelectorAttr, int, YChannelSelector, yChannelSelector)
+        DECLARE_ANIMATED_PROPERTY(SVGFEDisplacementMapElement, SVGNames::scaleAttr, float, Scale, scale)
     };
 
 } // namespace WebCore
index b2970b3..fd49fe7 100644 (file)
@@ -35,9 +35,6 @@ char SVGStdDeviationYAttrIdentifier[] = "SVGStdDeviationYAttr";
 
 SVGFEGaussianBlurElement::SVGFEGaussianBlurElement(const QualifiedName& tagName, Document* doc)
     : SVGFilterPrimitiveStandardAttributes(tagName, doc)
-    , m_in1(this, SVGNames::inAttr)
-    , m_stdDeviationX(this, SVGNames::stdDeviationAttr)
-    , m_stdDeviationY(this, SVGNames::stdDeviationAttr)
 {
 }
 
@@ -65,6 +62,24 @@ void SVGFEGaussianBlurElement::parseMappedAttribute(MappedAttribute* attr)
         SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(attr);
 }
 
+void SVGFEGaussianBlurElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGFilterPrimitiveStandardAttributes::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeStdDeviationX();
+        synchronizeStdDeviationY();
+        synchronizeIn1();
+        return;
+    }
+
+    if (attrName == SVGNames::stdDeviationAttr) {
+        synchronizeStdDeviationX();
+        synchronizeStdDeviationY();
+    } else if (attrName == SVGNames::inAttr)
+        synchronizeIn1();
+}
+
 bool SVGFEGaussianBlurElement::build(SVGResourceFilter* filterResource)
 {
     FilterEffect* input1 = filterResource->builder()->getEffectById(in1());
index 9a5c058..a03b9df 100644 (file)
@@ -38,12 +38,13 @@ namespace WebCore {
         void setStdDeviation(float stdDeviationX, float stdDeviationY);
 
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual bool build(SVGResourceFilter*);
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEGaussianBlurElement, SVGNames::feGaussianBlurTagString, SVGNames::inAttrString, String, In1, in1)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEGaussianBlurElement, SVGNames::feGaussianBlurTagString, SVGStdDeviationXAttrIdentifier, float, StdDeviationX, stdDeviationX)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEGaussianBlurElement, SVGNames::feGaussianBlurTagString, SVGStdDeviationYAttrIdentifier, float, StdDeviationY, stdDeviationY)
+        DECLARE_ANIMATED_PROPERTY(SVGFEGaussianBlurElement, SVGNames::inAttr, String, In1, in1)
+        DECLARE_ANIMATED_PROPERTY_MULTIPLE_WRAPPERS(SVGFEGaussianBlurElement, SVGNames::stdDeviationAttr, SVGStdDeviationXAttrIdentifier, float, StdDeviationX, stdDeviationX)
+        DECLARE_ANIMATED_PROPERTY_MULTIPLE_WRAPPERS(SVGFEGaussianBlurElement, SVGNames::stdDeviationAttr, SVGStdDeviationYAttrIdentifier, float, StdDeviationY, stdDeviationY)
     };
 
 } // namespace WebCore
index 04c98ea..7be972c 100644 (file)
@@ -42,9 +42,6 @@ SVGFEImageElement::SVGFEImageElement(const QualifiedName& tagName, Document* doc
     , SVGURIReference()
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
-    , m_preserveAspectRatio(this, SVGNames::preserveAspectRatioAttr)
-    , m_href(this, XLinkNames::hrefAttr)
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
 {
 }
 
@@ -90,6 +87,25 @@ void SVGFEImageElement::parseMappedAttribute(MappedAttribute* attr)
     }
 }
 
+void SVGFEImageElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGFilterPrimitiveStandardAttributes::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizePreserveAspectRatio();
+        synchronizeHref();
+        synchronizeExternalResourcesRequired();
+        return;
+    }
+
+    if (attrName == SVGNames::preserveAspectRatioAttr)
+        synchronizePreserveAspectRatio();
+    else if (SVGURIReference::isKnownAttribute(attrName))
+        synchronizeHref();
+    else if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+}
+
 void SVGFEImageElement::notifyFinished(CachedResource*)
 {
     SVGStyledElement::invalidateResourcesInAncestorChain();
index 8446e09..72cd949 100644 (file)
@@ -43,6 +43,7 @@ namespace WebCore {
         virtual ~SVGFEImageElement();
 
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual void notifyFinished(CachedResource*);
 
         virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const;
@@ -51,15 +52,13 @@ namespace WebCore {
     private:
         void requestImageResource();
 
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEImageElement, SVGNames::feImageTagString, SVGNames::preserveAspectRatioAttrString, SVGPreserveAspectRatio, PreserveAspectRatio, preserveAspectRatio)
+        DECLARE_ANIMATED_PROPERTY(SVGFEImageElement, SVGNames::preserveAspectRatioAttr, SVGPreserveAspectRatio, PreserveAspectRatio, preserveAspectRatio)
 
         // SVGURIReference
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEImageElement, SVGURIReferenceIdentifier, XLinkNames::hrefAttrString, String, Href, href)
+        DECLARE_ANIMATED_PROPERTY(SVGFEImageElement, XLinkNames::hrefAttr, String, Href, href)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEImageElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGFEImageElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
 
         CachedResourceHandle<CachedImage> m_cachedImage;
         OwnPtr<ImageBuffer> m_targetImage;
index bb954eb..dc711cf 100644 (file)
 
 namespace WebCore {
 
-char SVGFELightElementIdentifier[] = "SVGFELightElement";
-
 SVGFELightElement::SVGFELightElement(const QualifiedName& tagName, Document* doc)
     : SVGElement(tagName, doc)
-    , m_azimuth(this, SVGNames::azimuthAttr)
-    , m_elevation(this, SVGNames::elevationAttr)
-    , m_x(this, SVGNames::xAttr)
-    , m_y(this, SVGNames::yAttr)
-    , m_z(this, SVGNames::zAttr)
-    , m_pointsAtX(this, SVGNames::pointsAtXAttr)
-    , m_pointsAtY(this, SVGNames::pointsAtYAttr)
-    , m_pointsAtZ(this, SVGNames::pointsAtZAttr)
-    , m_specularExponent(this, SVGNames::specularExponentAttr, 1.0f)
-    , m_limitingConeAngle(this, SVGNames::limitingConeAngleAttr)
+    , m_specularExponent(1.0f)
 {
 }
 
@@ -77,8 +66,46 @@ void SVGFELightElement::parseMappedAttribute(MappedAttribute* attr)
         SVGElement::parseMappedAttribute(attr);
 }
 
+void SVGFELightElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeAzimuth();
+        synchronizeElevation();
+        synchronizeX();
+        synchronizeY();
+        synchronizeZ();
+        synchronizePointsAtX();
+        synchronizePointsAtY();
+        synchronizePointsAtZ();
+        synchronizeSpecularExponent();
+        synchronizeLimitingConeAngle();
+        return;
+    }
+
+    if (attrName == SVGNames::azimuthAttr)
+        synchronizeAzimuth();
+    else if (attrName == SVGNames::elevationAttr)
+        synchronizeElevation();
+    else if (attrName == SVGNames::xAttr)
+        synchronizeX();
+    else if (attrName == SVGNames::yAttr)
+        synchronizeY();
+    else if (attrName == SVGNames::zAttr)
+        synchronizeZ();
+    else if (attrName == SVGNames::pointsAtXAttr)
+        synchronizePointsAtX();
+    else if (attrName == SVGNames::pointsAtYAttr)
+        synchronizePointsAtY();
+    else if (attrName == SVGNames::pointsAtZAttr)
+        synchronizePointsAtZ();
+    else if (attrName == SVGNames::specularExponentAttr)
+        synchronizeSpecularExponent();
+    else if (attrName == SVGNames::limitingConeAngleAttr)
+        synchronizeLimitingConeAngle();
 }
 
-#endif // ENABLE(SVG)
+}
 
-// vim:ts=4:noet
+#endif // ENABLE(SVG)
index 705eeaa..4e9c389 100644 (file)
@@ -29,8 +29,6 @@
 
 namespace WebCore {
 
-    extern char SVGFELightElementIdentifier[];
-
     class SVGFELightElement : public SVGElement {
     public:
         SVGFELightElement(const QualifiedName&, Document*);
@@ -38,18 +36,19 @@ namespace WebCore {
         
         virtual PassRefPtr<LightSource> lightSource() const = 0;
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFELightElement, SVGFELightElementIdentifier, SVGNames::azimuthAttrString, float, Azimuth, azimuth)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFELightElement, SVGFELightElementIdentifier, SVGNames::elevationAttrString, float, Elevation, elevation)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFELightElement, SVGFELightElementIdentifier, SVGNames::xAttrString, float, X, x)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFELightElement, SVGFELightElementIdentifier, SVGNames::yAttrString, float, Y, y)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFELightElement, SVGFELightElementIdentifier, SVGNames::zAttrString, float, Z, z)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFELightElement, SVGFELightElementIdentifier, SVGNames::pointsAtXAttrString, float, PointsAtX, pointsAtX)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFELightElement, SVGFELightElementIdentifier, SVGNames::pointsAtYAttrString, float, PointsAtY, pointsAtY)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFELightElement, SVGFELightElementIdentifier, SVGNames::pointsAtZAttrString, float, PointsAtZ, pointsAtZ)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFELightElement, SVGFELightElementIdentifier, SVGNames::specularExponentAttrString, float, SpecularExponent, specularExponent)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFELightElement, SVGFELightElementIdentifier, SVGNames::limitingConeAngleAttrString, float, LimitingConeAngle, limitingConeAngle)
+        DECLARE_ANIMATED_PROPERTY(SVGFELightElement, SVGNames::azimuthAttr, float, Azimuth, azimuth)
+        DECLARE_ANIMATED_PROPERTY(SVGFELightElement, SVGNames::elevationAttr, float, Elevation, elevation)
+        DECLARE_ANIMATED_PROPERTY(SVGFELightElement, SVGNames::xAttr, float, X, x)
+        DECLARE_ANIMATED_PROPERTY(SVGFELightElement, SVGNames::yAttr, float, Y, y)
+        DECLARE_ANIMATED_PROPERTY(SVGFELightElement, SVGNames::zAttr, float, Z, z)
+        DECLARE_ANIMATED_PROPERTY(SVGFELightElement, SVGNames::pointsAtXAttr, float, PointsAtX, pointsAtX)
+        DECLARE_ANIMATED_PROPERTY(SVGFELightElement, SVGNames::pointsAtYAttr, float, PointsAtY, pointsAtY)
+        DECLARE_ANIMATED_PROPERTY(SVGFELightElement, SVGNames::pointsAtZAttr, float, PointsAtZ, pointsAtZ)
+        DECLARE_ANIMATED_PROPERTY(SVGFELightElement, SVGNames::specularExponentAttr, float, SpecularExponent, specularExponent)
+        DECLARE_ANIMATED_PROPERTY(SVGFELightElement, SVGNames::limitingConeAngleAttr, float, LimitingConeAngle, limitingConeAngle)
     };
 
 } // namespace WebCore
index 4161de8..9551d29 100644 (file)
@@ -29,7 +29,6 @@ namespace WebCore {
 
 SVGFEMergeNodeElement::SVGFEMergeNodeElement(const QualifiedName& tagName, Document* doc)
     : SVGElement(tagName, doc)
-    , m_in1(this, SVGNames::inAttr)
 {
 }
 
@@ -46,6 +45,14 @@ void SVGFEMergeNodeElement::parseMappedAttribute(MappedAttribute* attr)
         SVGElement::parseMappedAttribute(attr);
 }
 
+void SVGFEMergeNodeElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName() || attrName == SVGNames::inAttr)
+        synchronizeIn1();
+}
+
 }
 
 #endif // ENABLE(SVG)
index cdec8d2..5ccfe94 100644 (file)
@@ -33,9 +33,10 @@ namespace WebCore {
         virtual ~SVGFEMergeNodeElement();
 
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEMergeNodeElement, SVGNames::feMergeNodeTagString, SVGNames::inAttrString, String, In1, in1)
+        DECLARE_ANIMATED_PROPERTY(SVGFEMergeNodeElement, SVGNames::inAttr, String, In1, in1)
     };
 
 } // namespace WebCore
index 4a06188..1f37c08 100644 (file)
@@ -34,10 +34,7 @@ char SVGRadiusYAttrIdentifier[] = "SVGRadiusYAttr";
 
 SVGFEMorphologyElement::SVGFEMorphologyElement(const QualifiedName& tagName, Document* document)
     : SVGFilterPrimitiveStandardAttributes(tagName, document)
-    , m_in1(this, SVGNames::inAttr)
-    , m__operator(this, SVGNames::operatorAttr, FEMORPHOLOGY_OPERATOR_ERODE)
-    , m_radiusX(this, SVGNames::radiusAttr)
-    , m_radiusY(this, SVGNames::radiusAttr)
+    , m__operator(FEMORPHOLOGY_OPERATOR_ERODE)
 {
 }
 
@@ -70,6 +67,28 @@ void SVGFEMorphologyElement::parseMappedAttribute(MappedAttribute* attr)
         SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(attr);
 }
 
+void SVGFEMorphologyElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGFilterPrimitiveStandardAttributes::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronize_operator();
+        synchronizeIn1();
+        synchronizeRadiusX();
+        synchronizeRadiusY();
+        return;
+    }
+
+    if (attrName == SVGNames::operatorAttr)
+        synchronize_operator();
+    else if (attrName == SVGNames::inAttr)
+        synchronizeIn1();
+    else if (attrName == SVGNames::radiusAttr) {
+        synchronizeRadiusX();
+        synchronizeRadiusY();
+    }
+}
+
 bool SVGFEMorphologyElement::build(SVGResourceFilter* filterResource)
 {
     FilterEffect* input1 = filterResource->builder()->getEffectById(in1());
index 6c1aec1..c7e3f6f 100644 (file)
@@ -37,13 +37,14 @@ namespace WebCore {
         void setRadius(float radiusX, float radiusY);
 
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual bool build(SVGResourceFilter*);
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEMorphologyElement, SVGNames::feMorphologyTagString, SVGNames::inAttrString, String, In1, in1)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEMorphologyElement, SVGNames::feMorphologyTagString, SVGNames::operatorAttrString, int, _operator, _operator)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEMorphologyElement, SVGNames::feMorphologyTagString, SVGRadiusXAttrIdentifier, float, RadiusX, radiusX)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEMorphologyElement, SVGNames::feMorphologyTagString, SVGRadiusYAttrIdentifier, float, RadiusY, radiusY)
+        DECLARE_ANIMATED_PROPERTY(SVGFEMorphologyElement, SVGNames::inAttr, String, In1, in1)
+        DECLARE_ANIMATED_PROPERTY(SVGFEMorphologyElement, SVGNames::operatorAttr, int, _operator, _operator)
+        DECLARE_ANIMATED_PROPERTY_MULTIPLE_WRAPPERS(SVGFEMorphologyElement, SVGNames::radiusAttr, SVGRadiusXAttrIdentifier, float, RadiusX, radiusX)
+        DECLARE_ANIMATED_PROPERTY_MULTIPLE_WRAPPERS(SVGFEMorphologyElement, SVGNames::radiusAttr, SVGRadiusYAttrIdentifier, float, RadiusY, radiusY)
     };
 
 } // namespace WebCore
index 95cbc8d..28955c0 100644 (file)
@@ -31,9 +31,6 @@ namespace WebCore {
 
 SVGFEOffsetElement::SVGFEOffsetElement(const QualifiedName& tagName, Document* doc)
     : SVGFilterPrimitiveStandardAttributes(tagName, doc)
-    , m_in1(this, SVGNames::inAttr)
-    , m_dx(this, SVGNames::dxAttr)
-    , m_dy(this, SVGNames::dyAttr)
 {
 }
 
@@ -54,6 +51,25 @@ void SVGFEOffsetElement::parseMappedAttribute(MappedAttribute* attr)
         SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(attr);
 }
 
+void SVGFEOffsetElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGFilterPrimitiveStandardAttributes::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeDx();
+        synchronizeDy();
+        synchronizeIn1();
+        return;
+    }
+
+    if (attrName == SVGNames::dxAttr)
+        synchronizeDx();
+    else if (attrName == SVGNames::dyAttr)
+        synchronizeDy();
+    else if (attrName == SVGNames::inAttr)
+        synchronizeIn1();
+}
+
 bool SVGFEOffsetElement::build(SVGResourceFilter* filterResource)
 {
     FilterEffect* input1 = filterResource->builder()->getEffectById(in1());
index ae07ed8..df61a9c 100644 (file)
@@ -33,12 +33,13 @@ namespace WebCore {
         virtual ~SVGFEOffsetElement();
 
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual bool build(SVGResourceFilter*);
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEOffsetElement, SVGNames::feOffsetTagString, SVGNames::inAttrString, String, In1, in1)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEOffsetElement, SVGNames::feOffsetTagString, SVGNames::dxAttrString, float, Dx, dx)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFEOffsetElement, SVGNames::feOffsetTagString, SVGNames::dyAttrString, float, Dy, dy)
+        DECLARE_ANIMATED_PROPERTY(SVGFEOffsetElement, SVGNames::inAttr, String, In1, in1)
+        DECLARE_ANIMATED_PROPERTY(SVGFEOffsetElement, SVGNames::dxAttr, float, Dx, dx)
+        DECLARE_ANIMATED_PROPERTY(SVGFEOffsetElement, SVGNames::dyAttr, float, Dy, dy)
     };
 
 } // namespace WebCore
index 90e9cb3..0602103 100644 (file)
@@ -36,12 +36,9 @@ namespace WebCore {
 
 SVGFESpecularLightingElement::SVGFESpecularLightingElement(const QualifiedName& tagName, Document* doc)
     : SVGFilterPrimitiveStandardAttributes(tagName, doc)
-    , m_in1(this, SVGNames::inAttr)
-    , m_specularConstant(this, SVGNames::specularConstantAttr, 1.0f)
-    , m_specularExponent(this, SVGNames::specularExponentAttr, 1.0f)
-    , m_surfaceScale(this, SVGNames::surfaceScaleAttr, 1.0f)
-    , m_kernelUnitLengthX(this, SVGNames::kernelUnitLengthAttr)
-    , m_kernelUnitLengthY(this, SVGNames::kernelUnitLengthAttr)
+    , m_specularConstant(1.0f)
+    , m_specularExponent(1.0f)
+    , m_surfaceScale(1.0f)
 {
 }
 
@@ -70,6 +67,34 @@ void SVGFESpecularLightingElement::parseMappedAttribute(MappedAttribute* attr)
         SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(attr);
 }
 
+void SVGFESpecularLightingElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGFilterPrimitiveStandardAttributes::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeIn1();
+        synchronizeSurfaceScale();
+        synchronizeSpecularConstant();
+        synchronizeSpecularExponent();
+        synchronizeKernelUnitLengthX();
+        synchronizeKernelUnitLengthY();
+        return;
+    }
+
+    if (attrName == SVGNames::inAttr)
+        synchronizeIn1();
+    else if (attrName == SVGNames::surfaceScaleAttr)
+        synchronizeSurfaceScale();
+    else if (attrName == SVGNames::specularConstantAttr)
+        synchronizeSpecularConstant();
+    else if (attrName == SVGNames::specularExponentAttr)
+        synchronizeSpecularExponent();
+    else if (attrName == SVGNames::kernelUnitLengthAttr) {
+        synchronizeKernelUnitLengthX();
+        synchronizeKernelUnitLengthY();
+    }
+}
+
 PassRefPtr<LightSource> SVGFESpecularLightingElement::findLights() const
 {
     for (Node* n = firstChild(); n; n = n->nextSibling()) {
index b3771fe..fe56980 100644 (file)
@@ -31,23 +31,22 @@ namespace WebCore {
     extern char SVGKernelUnitLengthXIdentifier[];
     extern char SVGKernelUnitLengthYIdentifier[];
 
-    class SVGColor;
-    
     class SVGFESpecularLightingElement : public SVGFilterPrimitiveStandardAttributes {
     public:
         SVGFESpecularLightingElement(const QualifiedName&, Document*);
         virtual ~SVGFESpecularLightingElement();
         
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual bool build(SVGResourceFilter*);
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFESpecularLightingElement, SVGNames::feSpecularLightingTagString, SVGNames::inAttrString, String, In1, in1)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFESpecularLightingElement, SVGNames::feSpecularLightingTagString, SVGNames::specularConstantAttrString, float, SpecularConstant, specularConstant)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFESpecularLightingElement, SVGNames::feSpecularLightingTagString, SVGNames::specularExponentAttrString, float, SpecularExponent, specularExponent)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFESpecularLightingElement, SVGNames::feSpecularLightingTagString, SVGNames::surfaceScaleAttrString, float, SurfaceScale, surfaceScale)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFESpecularLightingElement, SVGNames::feSpecularLightingTagString, SVGKernelUnitLengthXIdentifier, float, KernelUnitLengthX, kernelUnitLengthX)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFESpecularLightingElement, SVGNames::feSpecularLightingTagString, SVGKernelUnitLengthYIdentifier, float, KernelUnitLengthY, kernelUnitLengthY)
+        DECLARE_ANIMATED_PROPERTY(SVGFESpecularLightingElement, SVGNames::inAttr, String, In1, in1)
+        DECLARE_ANIMATED_PROPERTY(SVGFESpecularLightingElement, SVGNames::specularConstantAttr, float, SpecularConstant, specularConstant)
+        DECLARE_ANIMATED_PROPERTY(SVGFESpecularLightingElement, SVGNames::specularExponentAttr, float, SpecularExponent, specularExponent)
+        DECLARE_ANIMATED_PROPERTY(SVGFESpecularLightingElement, SVGNames::surfaceScaleAttr, float, SurfaceScale, surfaceScale)
+        DECLARE_ANIMATED_PROPERTY_MULTIPLE_WRAPPERS(SVGFESpecularLightingElement, SVGNames::kernelUnitLengthAttr, SVGKernelUnitLengthXIdentifier, float, KernelUnitLengthX, kernelUnitLengthX)
+        DECLARE_ANIMATED_PROPERTY_MULTIPLE_WRAPPERS(SVGFESpecularLightingElement, SVGNames::kernelUnitLengthAttr, SVGKernelUnitLengthYIdentifier, float, KernelUnitLengthY, kernelUnitLengthY)
 
         PassRefPtr<LightSource> findLights() const;
     };
index 8894d4b..94c8e74 100644 (file)
@@ -32,7 +32,6 @@ namespace WebCore {
 
 SVGFETileElement::SVGFETileElement(const QualifiedName& tagName, Document* doc)
     : SVGFilterPrimitiveStandardAttributes(tagName, doc)
-    , m_in1(this, SVGNames::inAttr)
 {
 }
 
@@ -49,6 +48,14 @@ void SVGFETileElement::parseMappedAttribute(MappedAttribute* attr)
         SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(attr);
 }
 
+void SVGFETileElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGFilterPrimitiveStandardAttributes::synchronizeProperty(attrName);
+
+    if (attrName == anyQName() || attrName == SVGNames::inAttr)
+        synchronizeIn1();
+}
+
 bool SVGFETileElement::build(SVGResourceFilter* filterResource)
 {
     FilterEffect* input1 = filterResource->builder()->getEffectById(in1());
index 142a797..2c86abd 100644 (file)
@@ -33,10 +33,11 @@ namespace WebCore {
         virtual ~SVGFETileElement();
 
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual bool build(SVGResourceFilter*);
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFETileElement, SVGNames::feTileTagString, SVGNames::inAttrString, String, In1, in1)
+        DECLARE_ANIMATED_PROPERTY(SVGFETileElement, SVGNames::inAttr, String, In1, in1)
     };
 
 } // namespace WebCore
index 57114a3..622971c 100644 (file)
@@ -34,12 +34,9 @@ char SVGBaseFrequencyYIdentifier[] = "SVGBaseFrequencyY";
 
 SVGFETurbulenceElement::SVGFETurbulenceElement(const QualifiedName& tagName, Document* doc)
     : SVGFilterPrimitiveStandardAttributes(tagName, doc)
-    , m_baseFrequencyX(this, SVGNames::baseFrequencyAttr)
-    , m_baseFrequencyY(this, SVGNames::baseFrequencyAttr)
-    , m_numOctaves(this, SVGNames::numOctavesAttr, 1)
-    , m_seed(this, SVGNames::seedAttr)
-    , m_stitchTiles(this, SVGNames::stitchTilesAttr, SVG_STITCHTYPE_NOSTITCH)
-    , m_type(this, SVGNames::typeAttr, FETURBULENCE_TYPE_TURBULENCE)
+    , m_numOctaves(1)
+    , m_stitchTiles(SVG_STITCHTYPE_NOSTITCH)
+    , m_type(FETURBULENCE_TYPE_TURBULENCE)
 {
 }
 
@@ -74,6 +71,33 @@ void SVGFETurbulenceElement::parseMappedAttribute(MappedAttribute* attr)
         SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(attr);
 }
 
+void SVGFETurbulenceElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGFilterPrimitiveStandardAttributes::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeType();
+        synchronizeStitchTiles();
+        synchronizeBaseFrequencyX();
+        synchronizeBaseFrequencyY();
+        synchronizeSeed();
+        synchronizeNumOctaves();
+        return;
+    }
+
+    if (attrName == SVGNames::typeAttr)
+        synchronizeType();
+    else if (attrName == SVGNames::stitchTilesAttr)
+        synchronizeStitchTiles();
+    else if (attrName == SVGNames::baseFrequencyAttr) {
+        synchronizeBaseFrequencyX();
+        synchronizeBaseFrequencyY();
+    } else if (attrName == SVGNames::seedAttr)
+        synchronizeSeed();
+    else if (attrName == SVGNames::numOctavesAttr)
+        synchronizeNumOctaves();
+}
+
 bool SVGFETurbulenceElement::build(SVGResourceFilter* filterResource)
 {
     RefPtr<FilterEffect> effect = FETurbulence::create(static_cast<TurbulanceType>(type()), baseFrequencyX(), 
index f024f57..464ce25 100644 (file)
@@ -42,15 +42,16 @@ namespace WebCore {
         virtual ~SVGFETurbulenceElement();
 
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual bool build(SVGResourceFilter*);
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFETurbulenceElement, SVGNames::feTurbulenceTagString, SVGBaseFrequencyXIdentifier, float, BaseFrequencyX, baseFrequencyX)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFETurbulenceElement, SVGNames::feTurbulenceTagString, SVGBaseFrequencyYIdentifier, float, BaseFrequencyY, baseFrequencyY)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFETurbulenceElement, SVGNames::feTurbulenceTagString, SVGNames::numOctavesAttrString, long, NumOctaves, numOctaves)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFETurbulenceElement, SVGNames::feTurbulenceTagString, SVGNames::seedAttrString, float, Seed, seed)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFETurbulenceElement, SVGNames::feTurbulenceTagString, SVGNames::stitchTilesAttrString, int, StitchTiles, stitchTiles)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFETurbulenceElement, SVGNames::feTurbulenceTagString, SVGNames::typeAttrString, int, Type, type)
+        DECLARE_ANIMATED_PROPERTY_MULTIPLE_WRAPPERS(SVGFETurbulenceElement, SVGNames::baseFrequencyAttr, SVGBaseFrequencyXIdentifier, float, BaseFrequencyX, baseFrequencyX)
+        DECLARE_ANIMATED_PROPERTY_MULTIPLE_WRAPPERS(SVGFETurbulenceElement, SVGNames::baseFrequencyAttr, SVGBaseFrequencyYIdentifier, float, BaseFrequencyY, baseFrequencyY)
+        DECLARE_ANIMATED_PROPERTY(SVGFETurbulenceElement, SVGNames::numOctavesAttr, long, NumOctaves, numOctaves)
+        DECLARE_ANIMATED_PROPERTY(SVGFETurbulenceElement, SVGNames::seedAttr, float, Seed, seed)
+        DECLARE_ANIMATED_PROPERTY(SVGFETurbulenceElement, SVGNames::stitchTilesAttr, int, StitchTiles, stitchTiles)
+        DECLARE_ANIMATED_PROPERTY(SVGFETurbulenceElement, SVGNames::typeAttr, int, Type, type)
     };
 
 } // namespace WebCore
index 3f6f8c7..60375fb 100644 (file)
@@ -47,16 +47,12 @@ SVGFilterElement::SVGFilterElement(const QualifiedName& tagName, Document* doc)
     , SVGURIReference()
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
-    , m_filterUnits(this, SVGNames::filterUnitsAttr, SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
-    , m_primitiveUnits(this, SVGNames::primitiveUnitsAttr, SVGUnitTypes::SVG_UNIT_TYPE_USERSPACEONUSE)
-    , m_x(this, SVGNames::xAttr, LengthModeWidth, "-10%")
-    , m_y(this, SVGNames::yAttr, LengthModeHeight, "-10%")
-    , m_width(this, SVGNames::widthAttr, LengthModeWidth, "120%")
-    , m_height(this, SVGNames::heightAttr, LengthModeHeight, "120%")
-    , m_filterResX(this, SVGNames::filterResAttr)
-    , m_filterResY(this, SVGNames::filterResAttr)
-    , m_href(this, XLinkNames::hrefAttr)
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
+    , m_filterUnits(SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
+    , m_primitiveUnits(SVGUnitTypes::SVG_UNIT_TYPE_USERSPACEONUSE)
+    , m_x(LengthModeWidth, "-10%")
+    , m_y(LengthModeHeight, "-10%")
+    , m_width(LengthModeWidth, "120%")
+    , m_height(LengthModeHeight, "120%")
 {
     // Spec: If the x/y attribute is not specified, the effect is as if a value of "-10%" were specified.
     // Spec: If the width/height attribute is not specified, the effect is as if a value of "120%" were specified.
@@ -109,6 +105,45 @@ void SVGFilterElement::parseMappedAttribute(MappedAttribute* attr)
     }
 }
 
+void SVGFilterElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeX();
+        synchronizeY();
+        synchronizeWidth();
+        synchronizeHeight();
+        synchronizeFilterUnits();
+        synchronizePrimitiveUnits();
+        synchronizeFilterResX();
+        synchronizeFilterResY();
+        synchronizeExternalResourcesRequired();
+        synchronizeHref();
+        return;
+    }
+
+    if (attrName == SVGNames::xAttr)
+        synchronizeX();
+    else if (attrName == SVGNames::yAttr)
+        synchronizeY();
+    else if (attrName == SVGNames::widthAttr)
+        synchronizeWidth();
+    else if (attrName == SVGNames::heightAttr)
+        synchronizeHeight();
+    else if (attrName == SVGNames::filterUnitsAttr)
+        synchronizeFilterUnits();
+    else if (attrName == SVGNames::primitiveUnitsAttr)
+        synchronizePrimitiveUnits();
+    else if (attrName == SVGNames::filterResAttr) {
+        synchronizeFilterResX();
+        synchronizeFilterResY();
+    } else if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+    else if (SVGURIReference::isKnownAttribute(attrName))
+        synchronizeHref();
+}
+
 FloatRect SVGFilterElement::filterBoundingBox(const FloatRect& objectBoundingBox) const
 {
     FloatRect filterBBox;
index 0f2c711..c89352b 100644 (file)
@@ -50,25 +50,24 @@ namespace WebCore {
         void setFilterRes(unsigned long filterResX, unsigned long filterResY) const;
 
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual bool rendererIsNeeded(RenderStyle*) { return false; }
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFilterElement, SVGNames::filterTagString, SVGNames::filterUnitsAttrString, int, FilterUnits, filterUnits)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFilterElement, SVGNames::filterTagString, SVGNames::primitiveUnitsAttrString, int, PrimitiveUnits, primitiveUnits)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFilterElement, SVGNames::filterTagString, SVGNames::xAttrString, SVGLength, X, x)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFilterElement, SVGNames::filterTagString, SVGNames::yAttrString, SVGLength, Y, y)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFilterElement, SVGNames::filterTagString, SVGNames::widthAttrString, SVGLength, Width, width)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFilterElement, SVGNames::filterTagString, SVGNames::heightAttrString, SVGLength, Height, height)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFilterElement, SVGNames::filterTagString, SVGFilterResXIdentifier, long, FilterResX, filterResX)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFilterElement, SVGNames::filterTagString, SVGFilterResYIdentifier, long, FilterResY, filterResY)
+        DECLARE_ANIMATED_PROPERTY(SVGFilterElement, SVGNames::filterUnitsAttr, int, FilterUnits, filterUnits)
+        DECLARE_ANIMATED_PROPERTY(SVGFilterElement, SVGNames::primitiveUnitsAttr, int, PrimitiveUnits, primitiveUnits)
+        DECLARE_ANIMATED_PROPERTY(SVGFilterElement, SVGNames::xAttr, SVGLength, X, x)
+        DECLARE_ANIMATED_PROPERTY(SVGFilterElement, SVGNames::yAttr, SVGLength, Y, y)
+        DECLARE_ANIMATED_PROPERTY(SVGFilterElement, SVGNames::widthAttr, SVGLength, Width, width)
+        DECLARE_ANIMATED_PROPERTY(SVGFilterElement, SVGNames::heightAttr, SVGLength, Height, height)
+        DECLARE_ANIMATED_PROPERTY_MULTIPLE_WRAPPERS(SVGFilterElement, SVGNames::filterResAttr, SVGFilterResXIdentifier, long, FilterResX, filterResX)
+        DECLARE_ANIMATED_PROPERTY_MULTIPLE_WRAPPERS(SVGFilterElement, SVGNames::filterResAttr, SVGFilterResYIdentifier, long, FilterResY, filterResY)
 
         // SVGURIReference
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFilterElement, SVGURIReferenceIdentifier, XLinkNames::hrefAttrString, String, Href, href)
+        DECLARE_ANIMATED_PROPERTY(SVGFilterElement, XLinkNames::hrefAttr, String, Href, href)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFilterElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGFilterElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
 
         mutable RefPtr<SVGResourceFilter> m_filter;
 
index 08559b4..0a95522 100644 (file)
 
 namespace WebCore {
 
-char SVGFilterPrimitiveStandardAttributesIdentifierIdentifier[] = "SVGFilterPrimitiveStandardAttributesIdentifier";
-
 SVGFilterPrimitiveStandardAttributes::SVGFilterPrimitiveStandardAttributes(const QualifiedName& tagName, Document* doc)
     : SVGStyledElement(tagName, doc)
-    , m_x(this, SVGNames::xAttr, LengthModeWidth, "0%")
-    , m_y(this, SVGNames::yAttr, LengthModeHeight, "0%")
-    , m_width(this, SVGNames::widthAttr, LengthModeWidth, "100%")
-    , m_height(this, SVGNames::heightAttr, LengthModeHeight, "100%")
-    , m_result(this, SVGNames::resultAttr)
+    , m_x(LengthModeWidth, "0%")
+    , m_y(LengthModeHeight, "0%")
+    , m_width(LengthModeWidth, "100%")
+    , m_height(LengthModeHeight, "100%")
 {
     // Spec: If the x/y attribute is not specified, the effect is as if a value of "0%" were specified.
     // Spec: If the width/height attribute is not specified, the effect is as if a value of "100%" were specified.
@@ -68,6 +65,31 @@ void SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(MappedAttribute*
         return SVGStyledElement::parseMappedAttribute(attr);
 }
 
+void SVGFilterPrimitiveStandardAttributes::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeX();
+        synchronizeY();
+        synchronizeWidth();
+        synchronizeHeight();
+        synchronizeResult();
+        return;
+    }
+
+    if (attrName == SVGNames::xAttr)
+        synchronizeX();
+    else if (attrName == SVGNames::yAttr)
+        synchronizeY();
+    else if (attrName == SVGNames::widthAttr)
+        synchronizeWidth();
+    else if (attrName == SVGNames::heightAttr)
+        synchronizeHeight();
+    else if (attrName == SVGNames::resultAttr)
+        synchronizeResult();
+}
+
 void SVGFilterPrimitiveStandardAttributes::setStandardAttributes(SVGResourceFilter* resourceFilter, FilterEffect* filterEffect) const
 {
     ASSERT(filterEffect);
index cb8ec1c..fb8e5f2 100644 (file)
@@ -29,8 +29,6 @@
 
 namespace WebCore {
 
-    extern char SVGFilterPrimitiveStandardAttributesIdentifier[];
-
     class SVGResourceFilter;
 
     class SVGFilterPrimitiveStandardAttributes : public SVGStyledElement {
@@ -41,6 +39,7 @@ namespace WebCore {
         virtual bool isFilterEffect() const { return true; }
 
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual bool build(SVGResourceFilter*) = 0;
 
         virtual bool rendererIsNeeded(RenderStyle*) { return false; }
@@ -50,11 +49,11 @@ namespace WebCore {
         void setStandardAttributes(SVGResourceFilter*, FilterEffect*) const;
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFilterPrimitiveStandardAttributes, SVGFilterPrimitiveStandardAttributesIdentifier, SVGNames::xAttrString, SVGLength, X, x)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFilterPrimitiveStandardAttributes, SVGFilterPrimitiveStandardAttributesIdentifier, SVGNames::yAttrString, SVGLength, Y, y)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFilterPrimitiveStandardAttributes, SVGFilterPrimitiveStandardAttributesIdentifier, SVGNames::widthAttrString, SVGLength, Width, width)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFilterPrimitiveStandardAttributes, SVGFilterPrimitiveStandardAttributesIdentifier, SVGNames::heightAttrString, SVGLength, Height, height)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFilterPrimitiveStandardAttributes, SVGFilterPrimitiveStandardAttributesIdentifier, SVGNames::resultAttrString, String, Result, result)
+        DECLARE_ANIMATED_PROPERTY(SVGFilterPrimitiveStandardAttributes, SVGNames::xAttr, SVGLength, X, x)
+        DECLARE_ANIMATED_PROPERTY(SVGFilterPrimitiveStandardAttributes, SVGNames::yAttr, SVGLength, Y, y)
+        DECLARE_ANIMATED_PROPERTY(SVGFilterPrimitiveStandardAttributes, SVGNames::widthAttr, SVGLength, Width, width)
+        DECLARE_ANIMATED_PROPERTY(SVGFilterPrimitiveStandardAttributes, SVGNames::heightAttr, SVGLength, Height, height)
+        DECLARE_ANIMATED_PROPERTY(SVGFilterPrimitiveStandardAttributes, SVGNames::resultAttr, String, Result, result)
     };
 
 } // namespace WebCore
index 561bf59..80dead6 100644 (file)
@@ -35,8 +35,6 @@
 
 namespace WebCore {
 
-char SVGFitToViewBoxIdentifier[] = "SVGFitToViewBox";
-
 SVGFitToViewBox::SVGFitToViewBox()
 {
 }
index 2c31fa0..20fb7c1 100644 (file)
@@ -27,8 +27,6 @@
 
 namespace WebCore {
 
-    extern char SVGFitToViewBoxIdentifier[];
-
     class TransformationMatrix;
 
     class SVGFitToViewBox {
@@ -42,8 +40,8 @@ namespace WebCore {
         bool parseMappedAttribute(Document*, MappedAttribute*);
         bool isKnownAttribute(const QualifiedName&);
 
-        virtual void setViewBoxBaseValue(SVGAnimatedTypeValue<FloatRect>::DecoratedType) = 0;
-        virtual void setPreserveAspectRatioBaseValue(SVGAnimatedTypeValue<SVGPreserveAspectRatio>::DecoratedType) = 0;
+        virtual void setViewBoxBaseValue(SVGAnimatedPropertyTraits<FloatRect>::PassType) = 0;
+        virtual void setPreserveAspectRatioBaseValue(SVGAnimatedPropertyTraits<SVGPreserveAspectRatio>::PassType) = 0;
     };
 
 } // namespace WebCore
index 7d62b8c..91d222c 100644 (file)
@@ -40,7 +40,6 @@ using namespace SVGNames;
 
 SVGFontElement::SVGFontElement(const QualifiedName& tagName, Document* doc)
     : SVGStyledElement(tagName, doc) 
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
     , m_isGlyphCacheValid(false)
 {
 }
@@ -49,6 +48,14 @@ SVGFontElement::~SVGFontElement()
 {
 }
 
+void SVGFontElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName() || SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+}
+
 void SVGFontElement::invalidateGlyphCache()
 {
     if (m_isGlyphCacheValid) {
index 1fc5136..90641a8 100644 (file)
@@ -37,6 +37,7 @@ namespace WebCore {
         SVGFontElement(const QualifiedName&, Document*);
         virtual ~SVGFontElement();
 
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual bool rendererIsNeeded(RenderStyle*) { return false; }    
 
         void invalidateGlyphCache();
@@ -49,9 +50,7 @@ namespace WebCore {
 
     private:
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGFontElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGFontElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
 
         void ensureGlyphCache() const;
 
index 1e75741..e9118ef 100644 (file)
@@ -39,12 +39,10 @@ SVGForeignObjectElement::SVGForeignObjectElement(const QualifiedName& tagName, D
     , SVGTests()
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
-    , m_x(this, SVGNames::xAttr, LengthModeWidth)
-    , m_y(this, SVGNames::yAttr, LengthModeHeight)
-    , m_width(this, SVGNames::widthAttr, LengthModeWidth)
-    , m_height(this, SVGNames::heightAttr, LengthModeHeight)
-    , m_href(this, XLinkNames::hrefAttr)
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
+    , m_x(LengthModeWidth)
+    , m_y(LengthModeHeight)
+    , m_width(LengthModeWidth)
+    , m_height(LengthModeHeight)
 {
 }
 
@@ -153,6 +151,34 @@ void SVGForeignObjectElement::svgAttributeChanged(const QualifiedName& attrName)
         renderer()->setNeedsLayout(true);
 }
 
+void SVGForeignObjectElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledTransformableElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeX();
+        synchronizeY();
+        synchronizeWidth();
+        synchronizeHeight();
+        synchronizeExternalResourcesRequired();
+        synchronizeHref();
+        return;
+    }
+
+    if (attrName == SVGNames::xAttr)
+        synchronizeX();
+    else if (attrName == SVGNames::yAttr)
+        synchronizeY();
+    else if (attrName == SVGNames::widthAttr)
+        synchronizeWidth();
+    else if (attrName == SVGNames::heightAttr)
+        synchronizeHeight();
+    else if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+    else if (SVGURIReference::isKnownAttribute(attrName))
+        synchronizeHref();
+}
+
 RenderObject* SVGForeignObjectElement::createRenderer(RenderArena* arena, RenderStyle*)
 {
     return new (arena) RenderForeignObject(this);
index 1848e2b..fe36a20 100644 (file)
@@ -42,23 +42,22 @@ namespace WebCore {
         virtual bool isValid() const { return SVGTests::isValid(); }
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
 
         bool childShouldCreateRenderer(Node*) const;
         virtual RenderObject* createRenderer(RenderArena* arena, RenderStyle* style);
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGForeignObjectElement, SVGNames::foreignObjectTagString, SVGNames::xAttrString, SVGLength, X, x)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGForeignObjectElement, SVGNames::foreignObjectTagString, SVGNames::yAttrString, SVGLength, Y, y)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGForeignObjectElement, SVGNames::foreignObjectTagString, SVGNames::widthAttrString, SVGLength, Width, width)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGForeignObjectElement, SVGNames::foreignObjectTagString, SVGNames::heightAttrString, SVGLength, Height, height)
+        DECLARE_ANIMATED_PROPERTY(SVGForeignObjectElement, SVGNames::xAttr, SVGLength, X, x)
+        DECLARE_ANIMATED_PROPERTY(SVGForeignObjectElement, SVGNames::yAttr, SVGLength, Y, y)
+        DECLARE_ANIMATED_PROPERTY(SVGForeignObjectElement, SVGNames::widthAttr, SVGLength, Width, width)
+        DECLARE_ANIMATED_PROPERTY(SVGForeignObjectElement, SVGNames::heightAttr, SVGLength, Height, height)
 
         // SVGURIReference
-        ANIMATED_PROPERTY_DECLARATIONS(SVGForeignObjectElement, SVGURIReferenceIdentifier, XLinkNames::hrefAttrString, String, Href, href)
+        DECLARE_ANIMATED_PROPERTY(SVGForeignObjectElement, XLinkNames::hrefAttr, String, Href, href)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGForeignObjectElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGForeignObjectElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
     };
 
 } // namespace WebCore
index ef46af4..0fd329f 100644 (file)
@@ -32,7 +32,6 @@ SVGGElement::SVGGElement(const QualifiedName& tagName, Document* doc)
     , SVGTests()
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
 {
 }
 
@@ -66,6 +65,14 @@ void SVGGElement::svgAttributeChanged(const QualifiedName& attrName)
         renderer()->setNeedsLayout(true);
 }
 
+void SVGGElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledTransformableElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName() || SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+}
+
 void SVGGElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
 {
     SVGStyledTransformableElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
index 4827a84..3e0dd8e 100644 (file)
@@ -42,15 +42,14 @@ namespace WebCore {
 
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
 
         virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
 
     private:
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGGElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGGElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
     };
 
 } // namespace WebCore
index 4f66505..f573265 100644 (file)
 
 namespace WebCore {
 
-char SVGGradientElementIdentifier[] = "SVGGradientElement";
-
 SVGGradientElement::SVGGradientElement(const QualifiedName& tagName, Document* doc)
     : SVGStyledElement(tagName, doc)
     , SVGURIReference()
     , SVGExternalResourcesRequired()
-    , m_spreadMethod(this, SVGNames::spreadMethodAttr)
-    , m_gradientUnits(this, SVGNames::gradientUnitsAttr, SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
-    , m_gradientTransform(this, SVGNames::gradientTransformAttr, SVGTransformList::create(SVGNames::gradientTransformAttr))
-    , m_href(this, XLinkNames::hrefAttr)
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
+    , m_gradientUnits(SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
+    , m_gradientTransform(SVGTransformList::create(SVGNames::gradientTransformAttr))
 {
 }
 
@@ -101,6 +96,31 @@ void SVGGradientElement::svgAttributeChanged(const QualifiedName& attrName)
         m_resource->invalidate();
 }
 
+void SVGGradientElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeGradientUnits();
+        synchronizeGradientTransform();
+        synchronizeSpreadMethod();
+        synchronizeExternalResourcesRequired();
+        synchronizeHref();
+        return;
+    }
+
+    if (attrName == SVGNames::gradientUnitsAttr)
+        synchronizeGradientUnits();
+    else if (attrName == SVGNames::gradientTransformAttr)
+        synchronizeGradientTransform();
+    else if (attrName == SVGNames::spreadMethodAttr)
+        synchronizeSpreadMethod();
+    else if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+    else if (SVGURIReference::isKnownAttribute(attrName))
+        synchronizeHref();
+}
+
 void SVGGradientElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
 {
     SVGStyledElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
index 4974e6b..122e1d9 100644 (file)
@@ -31,8 +31,6 @@
 
 namespace WebCore {
 
-    extern char SVGGradientElementIdentifier[];
-
     class SVGGradientElement : public SVGStyledElement,
                                public SVGURIReference,
                                public SVGExternalResourcesRequired {
@@ -42,6 +40,7 @@ namespace WebCore {
 
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
 
         virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
         virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
@@ -60,17 +59,15 @@ namespace WebCore {
         mutable RefPtr<SVGPaintServerGradient> m_resource;
  
     protected:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGGradientElement, SVGGradientElementIdentifier, SVGNames::spreadMethodAttrString, int, SpreadMethod, spreadMethod)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGGradientElement, SVGGradientElementIdentifier, SVGNames::gradientUnitsAttrString, int, GradientUnits, gradientUnits)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGGradientElement, SVGGradientElementIdentifier, SVGNames::gradientTransformAttrString, SVGTransformList, GradientTransform, gradientTransform)
+        DECLARE_ANIMATED_PROPERTY(SVGGradientElement, SVGNames::spreadMethodAttr, int, SpreadMethod, spreadMethod)
+        DECLARE_ANIMATED_PROPERTY(SVGGradientElement, SVGNames::gradientUnitsAttr, int, GradientUnits, gradientUnits)
+        DECLARE_ANIMATED_PROPERTY(SVGGradientElement, SVGNames::gradientTransformAttr, SVGTransformList*, GradientTransform, gradientTransform)
 
         // SVGURIReference
-        ANIMATED_PROPERTY_DECLARATIONS(SVGGradientElement, SVGURIReferenceIdentifier, XLinkNames::hrefAttrString, String, Href, href)
+        DECLARE_ANIMATED_PROPERTY(SVGGradientElement, XLinkNames::hrefAttr, String, Href, href)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGGradientElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGGradientElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
     };
 
 } // namespace WebCore
index a636ff6..4055533 100644 (file)
@@ -41,13 +41,10 @@ SVGImageElement::SVGImageElement(const QualifiedName& tagName, Document* doc)
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
     , SVGURIReference()
-    , m_x(this, SVGNames::xAttr, LengthModeWidth)
-    , m_y(this, SVGNames::yAttr, LengthModeHeight)
-    , m_width(this, SVGNames::widthAttr, LengthModeWidth)
-    , m_height(this, SVGNames::heightAttr, LengthModeHeight)
-    , m_preserveAspectRatio(this, SVGNames::preserveAspectRatioAttr)
-    , m_href(this, XLinkNames::hrefAttr)
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
+    , m_x(LengthModeWidth)
+    , m_y(LengthModeHeight)
+    , m_width(LengthModeWidth)
+    , m_height(LengthModeHeight)
     , m_imageLoader(this)
 {
 }
@@ -108,6 +105,37 @@ void SVGImageElement::svgAttributeChanged(const QualifiedName& attrName)
     }
 }
 
+void SVGImageElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledTransformableElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeX();
+        synchronizeY();
+        synchronizeWidth();
+        synchronizeHeight();
+        synchronizePreserveAspectRatio();
+        synchronizeExternalResourcesRequired();
+        synchronizeHref();
+        return;
+    }
+
+    if (attrName == SVGNames::xAttr)
+        synchronizeX();
+    else if (attrName == SVGNames::yAttr)
+        synchronizeY();
+    else if (attrName == SVGNames::widthAttr)
+        synchronizeWidth();
+    else if (attrName == SVGNames::heightAttr)
+        synchronizeHeight();
+    else if (attrName == SVGNames::preserveAspectRatioAttr)
+        synchronizePreserveAspectRatio();
+    else if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+    else if (SVGURIReference::isKnownAttribute(attrName))
+        synchronizeHref();
+}
+
 bool SVGImageElement::hasRelativeValues() const
 {
     return (x().isRelative() || width().isRelative() ||
index 1bdcdba..3fa0e3f 100644 (file)
@@ -47,6 +47,7 @@ namespace WebCore {
 
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
 
         virtual void attach();
         virtual void insertedIntoDocument();
@@ -61,19 +62,17 @@ namespace WebCore {
         virtual bool hasRelativeValues() const;
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGImageElement, SVGNames::imageTagString, SVGNames::xAttrString, SVGLength, X, x)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGImageElement, SVGNames::imageTagString, SVGNames::yAttrString, SVGLength, Y, y)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGImageElement, SVGNames::imageTagString, SVGNames::widthAttrString, SVGLength, Width, width)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGImageElement, SVGNames::imageTagString, SVGNames::heightAttrString, SVGLength, Height, height)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGImageElement, SVGNames::imageTagString, SVGNames::preserveAspectRatioAttrString, SVGPreserveAspectRatio, PreserveAspectRatio, preserveAspectRatio)
+        DECLARE_ANIMATED_PROPERTY(SVGImageElement, SVGNames::xAttr, SVGLength, X, x)
+        DECLARE_ANIMATED_PROPERTY(SVGImageElement, SVGNames::yAttr, SVGLength, Y, y)
+        DECLARE_ANIMATED_PROPERTY(SVGImageElement, SVGNames::widthAttr, SVGLength, Width, width)
+        DECLARE_ANIMATED_PROPERTY(SVGImageElement, SVGNames::heightAttr, SVGLength, Height, height)
+        DECLARE_ANIMATED_PROPERTY(SVGImageElement, SVGNames::preserveAspectRatioAttr, SVGPreserveAspectRatio, PreserveAspectRatio, preserveAspectRatio)
 
         // SVGURIReference
-        ANIMATED_PROPERTY_DECLARATIONS(SVGImageElement, SVGURIReferenceIdentifier, XLinkNames::hrefAttrString, String, Href, href)
+        DECLARE_ANIMATED_PROPERTY(SVGImageElement, XLinkNames::hrefAttr, String, Href, href)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGImageElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGImageElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
 
         SVGImageLoader m_imageLoader;
     };
index a359698..6c8a16b 100644 (file)
@@ -36,11 +36,10 @@ SVGLineElement::SVGLineElement(const QualifiedName& tagName, Document* doc)
     , SVGTests()
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
-    , m_x1(this, SVGNames::x1Attr, LengthModeWidth)
-    , m_y1(this, SVGNames::y1Attr, LengthModeHeight)
-    , m_x2(this, SVGNames::x2Attr, LengthModeWidth)
-    , m_y2(this, SVGNames::y2Attr, LengthModeHeight)
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
+    , m_x1(LengthModeWidth)
+    , m_y1(LengthModeHeight)
+    , m_x2(LengthModeWidth)
+    , m_y2(LengthModeHeight)
 {
 }
 
@@ -85,6 +84,31 @@ void SVGLineElement::svgAttributeChanged(const QualifiedName& attrName)
         renderer()->setNeedsLayout(true);
 }
 
+void SVGLineElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledTransformableElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeX1();
+        synchronizeY1();
+        synchronizeX2();
+        synchronizeY2();
+        synchronizeExternalResourcesRequired();
+        return;
+    }
+
+    if (attrName == SVGNames::x1Attr)
+        synchronizeX1();
+    else if (attrName == SVGNames::y1Attr)
+        synchronizeY1();
+    else if (attrName == SVGNames::x2Attr)
+        synchronizeX2();
+    else if (attrName == SVGNames::y2Attr)
+        synchronizeY2();
+    else if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+}
+
 Path SVGLineElement::toPathData() const
 {
     return Path::createLine(FloatPoint(x1().value(this), y1().value(this)),
index a24e009..c5ecafa 100644 (file)
@@ -43,6 +43,7 @@ namespace WebCore {
 
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
 
         virtual Path toPathData() const;
 
@@ -52,15 +53,13 @@ namespace WebCore {
         virtual bool hasRelativeValues() const;
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGLineElement, SVGNames::lineTagString, SVGNames::x1AttrString, SVGLength, X1, x1)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGLineElement, SVGNames::lineTagString, SVGNames::y1AttrString, SVGLength, Y1, y1)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGLineElement, SVGNames::lineTagString, SVGNames::x2AttrString, SVGLength, X2, x2)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGLineElement, SVGNames::lineTagString, SVGNames::y2AttrString, SVGLength, Y2, y2)
+        DECLARE_ANIMATED_PROPERTY(SVGLineElement, SVGNames::x1Attr, SVGLength, X1, x1)
+        DECLARE_ANIMATED_PROPERTY(SVGLineElement, SVGNames::y1Attr, SVGLength, Y1, y1)
+        DECLARE_ANIMATED_PROPERTY(SVGLineElement, SVGNames::x2Attr, SVGLength, X2, x2)
+        DECLARE_ANIMATED_PROPERTY(SVGLineElement, SVGNames::y2Attr, SVGLength, Y2, y2)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGLineElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGLineElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
     };
 
 } // namespace WebCore
index f5c8cee..665a1da 100644 (file)
@@ -40,10 +40,10 @@ namespace WebCore {
 
 SVGLinearGradientElement::SVGLinearGradientElement(const QualifiedName& tagName, Document* doc)
     : SVGGradientElement(tagName, doc)
-    , m_x1(this, SVGNames::x1Attr, LengthModeWidth)
-    , m_y1(this, SVGNames::y1Attr, LengthModeHeight)
-    , m_x2(this, SVGNames::x2Attr, LengthModeWidth, "100%")
-    , m_y2(this, SVGNames::y2Attr, LengthModeHeight)
+    , m_x1(LengthModeWidth)
+    , m_y1(LengthModeHeight)
+    , m_x2(LengthModeWidth, "100%")
+    , m_y2(LengthModeHeight)
 {
     // Spec: If the x2 attribute is not specified, the effect is as if a value of "100%" were specified.
 }
@@ -78,6 +78,28 @@ void SVGLinearGradientElement::svgAttributeChanged(const QualifiedName& attrName
         m_resource->invalidate();
 }
 
+void SVGLinearGradientElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGGradientElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeX1();
+        synchronizeY1();
+        synchronizeX2();
+        synchronizeY2();
+        return;
+    }
+
+    if (attrName == SVGNames::x1Attr)
+        synchronizeX1();
+    else if (attrName == SVGNames::y1Attr)
+        synchronizeY1();
+    else if (attrName == SVGNames::x2Attr)
+        synchronizeX2();
+    else if (attrName == SVGNames::y2Attr)
+        synchronizeY2();
+}
+
 void SVGLinearGradientElement::buildGradient() const
 {
     LinearGradientAttributes attributes = collectGradientProperties();
index 492c366..0308c0e 100644 (file)
@@ -36,6 +36,7 @@ namespace WebCore {
 
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
 
     protected:
         virtual void buildGradient() const;
@@ -44,10 +45,10 @@ namespace WebCore {
         LinearGradientAttributes collectGradientProperties() const;
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGLinearGradientElement, SVGNames::linearGradientTagString, SVGNames::x1AttrString, SVGLength, X1, x1)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGLinearGradientElement, SVGNames::linearGradientTagString, SVGNames::y1AttrString, SVGLength, Y1, y1)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGLinearGradientElement, SVGNames::linearGradientTagString, SVGNames::x2AttrString, SVGLength, X2, x2)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGLinearGradientElement, SVGNames::linearGradientTagString, SVGNames::y2AttrString, SVGLength, Y2, y2)
+        DECLARE_ANIMATED_PROPERTY(SVGLinearGradientElement, SVGNames::x1Attr, SVGLength, X1, x1)
+        DECLARE_ANIMATED_PROPERTY(SVGLinearGradientElement, SVGNames::y1Attr, SVGLength, Y1, y1)
+        DECLARE_ANIMATED_PROPERTY(SVGLinearGradientElement, SVGNames::x2Attr, SVGLength, X2, x2)
+        DECLARE_ANIMATED_PROPERTY(SVGLinearGradientElement, SVGNames::y2Attr, SVGLength, Y2, y2)
     };
 
 } // namespace WebCore
index 8fb3bc1..e1249e2 100644 (file)
@@ -176,7 +176,7 @@ namespace WebCore {
 
         // Updating facilities, used by JSSVGPODTypeWrapperCreatorForList
         Item value() const { return m_item; }
-        void setValue(Item newItem) { m_item = newItem; }
+        void setValue(const Item& newItem) { m_item = newItem; }
 
     private:
         SVGPODListItem() : m_item() { }
index b8c862a..dfe7e99 100644 (file)
@@ -31,8 +31,6 @@ namespace WebCore {
 
 SVGMPathElement::SVGMPathElement(const QualifiedName& qname, Document* doc)
     : SVGElement(qname, doc)
-    , m_href(this, XLinkNames::hrefAttr)
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
 {
 }
 
@@ -47,6 +45,22 @@ void SVGMPathElement::parseMappedAttribute(MappedAttribute* attr)
     SVGElement::parseMappedAttribute(attr);
 }
 
+void SVGMPathElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeExternalResourcesRequired();
+        synchronizeHref();
+        return;
+    }
+
+    if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+    else if (SVGURIReference::isKnownAttribute(attrName))
+        synchronizeHref();
+}
+
 SVGPathElement* SVGMPathElement::pathElement()
 {
     Element* target = document()->getElementById(getTarget(href()));
index ded6cdf..50a7dd1 100644 (file)
@@ -36,17 +36,16 @@ namespace WebCore {
         virtual ~SVGMPathElement();
         
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
         
         SVGPathElement* pathElement();
         
     private:
         // SVGURIReference
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMPathElement, SVGURIReferenceIdentifier, XLinkNames::hrefAttrString, String, Href, href)
+        DECLARE_ANIMATED_PROPERTY(SVGMPathElement, XLinkNames::hrefAttr, String, Href, href)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMPathElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGMPathElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
     };
 
 } // namespace WebCore
index 01cd294..ca57fa6 100644 (file)
@@ -42,16 +42,12 @@ SVGMarkerElement::SVGMarkerElement(const QualifiedName& tagName, Document* doc)
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
     , SVGFitToViewBox()
-    , m_refX(this, SVGNames::refXAttr, LengthModeWidth)
-    , m_refY(this, SVGNames::refYAttr, LengthModeHeight)
-    , m_markerWidth(this, SVGNames::markerWidthAttr, LengthModeWidth, "3")
-    , m_markerHeight(this, SVGNames::markerHeightAttr, LengthModeHeight, "3") 
-    , m_markerUnits(this, SVGNames::markerUnitsAttr, SVG_MARKERUNITS_STROKEWIDTH)
-    , m_orientType(this, SVGNames::orientAttr, SVG_MARKER_ORIENT_ANGLE)
-    , m_orientAngle(this, SVGNames::orientAttr)
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
-    , m_viewBox(this, SVGNames::viewBoxAttr)
-    , m_preserveAspectRatio(this, SVGNames::preserveAspectRatioAttr)
+    , m_refX(LengthModeWidth)
+    , m_refY(LengthModeHeight)
+    , m_markerWidth(LengthModeWidth, "3")
+    , m_markerHeight(LengthModeHeight, "3") 
+    , m_markerUnits(SVG_MARKERUNITS_STROKEWIDTH)
+    , m_orientType(SVG_MARKER_ORIENT_ANGLE)
 {
     // Spec: If the markerWidth/markerHeight attribute is not specified, the effect is as if a value of "3" were specified.
 }
@@ -124,6 +120,45 @@ void SVGMarkerElement::svgAttributeChanged(const QualifiedName& attrName)
     }
 }
 
+void SVGMarkerElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeMarkerUnits();
+        synchronizeRefX();
+        synchronizeRefY();
+        synchronizeMarkerWidth();
+        synchronizeMarkerHeight();
+        synchronizeOrientAngle();
+        synchronizeOrientType();
+        synchronizeExternalResourcesRequired();
+        synchronizeViewBox();
+        synchronizePreserveAspectRatio();
+        return;
+    }
+
+    if (attrName == SVGNames::markerUnitsAttr)
+        synchronizeMarkerUnits();
+    else if (attrName == SVGNames::refXAttr)
+        synchronizeRefX();
+    else if (attrName == SVGNames::refYAttr)
+        synchronizeRefY();
+    else if (attrName == SVGNames::markerWidthAttr)
+        synchronizeMarkerWidth();
+    else if (attrName == SVGNames::markerHeightAttr)
+        synchronizeMarkerHeight();
+    else if (attrName == SVGNames::orientAttr) {
+        synchronizeOrientAngle();
+        synchronizeOrientType();
+    } else if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+    else if (SVGFitToViewBox::isKnownAttribute(attrName)) {
+        synchronizeViewBox();
+        synchronizePreserveAspectRatio();
+    }
+}
+
 void SVGMarkerElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
 {
     SVGStyledElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
index 10d4b1a..8a25cba 100644 (file)
@@ -64,28 +64,27 @@ namespace WebCore {
 
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
 
         virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
         virtual SVGResource* canvasResource(const RenderObject*);
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMarkerElement, SVGNames::markerTagString, SVGNames::refXAttrString, SVGLength, RefX, refX)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMarkerElement, SVGNames::markerTagString, SVGNames::refYAttrString, SVGLength, RefY, refY)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMarkerElement, SVGNames::markerTagString, SVGNames::markerWidthAttrString, SVGLength, MarkerWidth, markerWidth)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMarkerElement, SVGNames::markerTagString, SVGNames::markerHeightAttrString, SVGLength, MarkerHeight, markerHeight)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMarkerElement, SVGNames::markerTagString, SVGNames::markerUnitsAttrString, int, MarkerUnits, markerUnits)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMarkerElement, SVGNames::markerTagString, SVGOrientTypeAttrIdentifier, int, OrientType, orientType)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMarkerElement, SVGNames::markerTagString, SVGOrientAngleAttrIdentifier, SVGAngle, OrientAngle, orientAngle)
+        DECLARE_ANIMATED_PROPERTY(SVGMarkerElement, SVGNames::refXAttr, SVGLength, RefX, refX)
+        DECLARE_ANIMATED_PROPERTY(SVGMarkerElement, SVGNames::refYAttr, SVGLength, RefY, refY)
+        DECLARE_ANIMATED_PROPERTY(SVGMarkerElement, SVGNames::markerWidthAttr, SVGLength, MarkerWidth, markerWidth)
+        DECLARE_ANIMATED_PROPERTY(SVGMarkerElement, SVGNames::markerHeightAttr, SVGLength, MarkerHeight, markerHeight)
+        DECLARE_ANIMATED_PROPERTY(SVGMarkerElement, SVGNames::markerUnitsAttr, int, MarkerUnits, markerUnits)
+        DECLARE_ANIMATED_PROPERTY_MULTIPLE_WRAPPERS(SVGMarkerElement, SVGNames::orientAttr, SVGOrientTypeAttrIdentifier, int, OrientType, orientType)
+        DECLARE_ANIMATED_PROPERTY_MULTIPLE_WRAPPERS(SVGMarkerElement, SVGNames::orientAttr, SVGOrientAngleAttrIdentifier, SVGAngle, OrientAngle, orientAngle)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMarkerElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGMarkerElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
 
         // SVGFitToViewBox
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMarkerElement, SVGFitToViewBoxIdentifier, SVGNames::viewBoxAttrString, FloatRect, ViewBox, viewBox)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMarkerElement, SVGFitToViewBoxIdentifier, SVGNames::preserveAspectRatioAttrString, SVGPreserveAspectRatio, PreserveAspectRatio, preserveAspectRatio)
+        DECLARE_ANIMATED_PROPERTY(SVGMarkerElement, SVGNames::viewBoxAttr, FloatRect, ViewBox, viewBox)
+        DECLARE_ANIMATED_PROPERTY(SVGMarkerElement, SVGNames::preserveAspectRatioAttr, SVGPreserveAspectRatio, PreserveAspectRatio, preserveAspectRatio)
  
         RefPtr<SVGResourceMarker> m_marker;
     };
index 63bd9e6..75f3dcd 100644 (file)
@@ -53,14 +53,12 @@ SVGMaskElement::SVGMaskElement(const QualifiedName& tagName, Document* doc)
     , SVGTests()
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
-    , m_maskUnits(this, SVGNames::maskUnitsAttr, SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
-    , m_maskContentUnits(this, SVGNames::maskContentUnitsAttr, SVGUnitTypes::SVG_UNIT_TYPE_USERSPACEONUSE)
-    , m_x(this, SVGNames::xAttr, LengthModeWidth, "-10%")
-    , m_y(this, SVGNames::yAttr, LengthModeHeight, "-10%")
-    , m_width(this, SVGNames::widthAttr, LengthModeWidth, "120%")
-    , m_height(this, SVGNames::heightAttr, LengthModeHeight, "120%")
-    , m_href(this, XLinkNames::hrefAttr)
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
+    , m_maskUnits(SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
+    , m_maskContentUnits(SVGUnitTypes::SVG_UNIT_TYPE_USERSPACEONUSE)
+    , m_x(LengthModeWidth, "-10%")
+    , m_y(LengthModeHeight, "-10%")
+    , m_width(LengthModeWidth, "120%")
+    , m_height(LengthModeHeight, "120%")
 {
     // Spec: If the x/y attribute is not specified, the effect is as if a value of "-10%" were specified.
     // Spec: If the width/height attribute is not specified, the effect is as if a value of "120%" were specified.
@@ -122,6 +120,34 @@ void SVGMaskElement::svgAttributeChanged(const QualifiedName& attrName)
             it->second->invalidate();
 }
 
+void SVGMaskElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeMaskUnits();
+        synchronizeMaskContentUnits();
+        synchronizeX();
+        synchronizeY();
+        synchronizeExternalResourcesRequired();
+        synchronizeHref();
+        return;
+    }
+
+    if (attrName == SVGNames::maskUnitsAttr)
+        synchronizeMaskUnits();
+    else if (attrName == SVGNames::maskContentUnitsAttr)
+        synchronizeMaskContentUnits();
+    else if (attrName == SVGNames::xAttr)
+        synchronizeX();
+    else if (attrName == SVGNames::yAttr)
+        synchronizeY();
+    else if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+    else if (SVGURIReference::isKnownAttribute(attrName))
+        synchronizeHref();
+}
+
 void SVGMaskElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
 {
     SVGStyledElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
index fadcbba..3abc08b 100644 (file)
@@ -49,6 +49,7 @@ namespace WebCore {
         FloatRect maskBoundingBox(const FloatRect&) const;
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
 
         virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
@@ -57,20 +58,18 @@ namespace WebCore {
         PassOwnPtr<ImageBuffer> drawMaskerContent(const RenderObject*, FloatRect& maskRect, bool& emptyMask) const;
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMaskElement, SVGNames::maskTagString, SVGNames::maskUnitsAttrString, int, MaskUnits, maskUnits)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMaskElement, SVGNames::maskTagString, SVGNames::maskContentUnitsAttrString, int, MaskContentUnits, maskContentUnits)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMaskElement, SVGNames::maskTagString, SVGNames::xAttrString, SVGLength, X, x)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMaskElement, SVGNames::maskTagString, SVGNames::yAttrString, SVGLength, Y, y)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMaskElement, SVGNames::maskTagString, SVGNames::widthAttrString, SVGLength, Width, width)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMaskElement, SVGNames::maskTagString, SVGNames::heightAttrString, SVGLength, Height, height)
+        DECLARE_ANIMATED_PROPERTY(SVGMaskElement, SVGNames::maskUnitsAttr, int, MaskUnits, maskUnits)
+        DECLARE_ANIMATED_PROPERTY(SVGMaskElement, SVGNames::maskContentUnitsAttr, int, MaskContentUnits, maskContentUnits)
+        DECLARE_ANIMATED_PROPERTY(SVGMaskElement, SVGNames::xAttr, SVGLength, X, x)
+        DECLARE_ANIMATED_PROPERTY(SVGMaskElement, SVGNames::yAttr, SVGLength, Y, y)
+        DECLARE_ANIMATED_PROPERTY(SVGMaskElement, SVGNames::widthAttr, SVGLength, Width, width)
+        DECLARE_ANIMATED_PROPERTY(SVGMaskElement, SVGNames::heightAttr, SVGLength, Height, height)
 
         // SVGURIReference
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMaskElement, SVGURIReferenceIdentifier, XLinkNames::hrefAttrString, String, Href, href)
+        DECLARE_ANIMATED_PROPERTY(SVGMaskElement, XLinkNames::hrefAttr, String, Href, href)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGMaskElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGMaskElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
 
         HashMap<const RenderObject*, RefPtr<SVGResourceMasker> > m_masker;
     };
index d53fbb2..f6e7867 100644 (file)
@@ -47,8 +47,6 @@ SVGPathElement::SVGPathElement(const QualifiedName& tagName, Document* doc)
     , SVGTests()
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
-    , m_pathLength(this, SVGNames::pathLengthAttr, 0.0f)
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
 {
 }
 
@@ -206,6 +204,22 @@ void SVGPathElement::svgAttributeChanged(const QualifiedName& attrName)
         renderer()->setNeedsLayout(true);
 }
 
+void SVGPathElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledTransformableElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizePathLength();
+        synchronizeExternalResourcesRequired();
+        return;
+    }
+
+    if (attrName == SVGNames::pathLengthAttr)
+        synchronizePathLength();
+    else if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+}
+
 SVGPathSegList* SVGPathElement::pathSegList() const
 {
     if (!m_pathSegList)
index 266bfdd..e46ed92 100644 (file)
@@ -92,6 +92,7 @@ namespace WebCore {
 
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
 
         virtual Path toPathData() const;
 
@@ -100,12 +101,10 @@ namespace WebCore {
     private:
         mutable RefPtr<SVGPathSegList> m_pathSegList;
 
-        ANIMATED_PROPERTY_DECLARATIONS(SVGPathElement, SVGNames::pathTagString, SVGNames::pathLengthAttrString, float, PathLength, pathLength)
+        DECLARE_ANIMATED_PROPERTY(SVGPathElement, SVGNames::pathLengthAttr, float, PathLength, pathLength)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGPathElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGPathElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
     };
 
 } // namespace WebCore
index 6423c18..b3c040b 100644 (file)
@@ -55,17 +55,13 @@ SVGPatternElement::SVGPatternElement(const QualifiedName& tagName, Document* doc
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
     , SVGFitToViewBox()
-    , m_x(this, SVGNames::xAttr, LengthModeWidth)
-    , m_y(this, SVGNames::yAttr, LengthModeHeight)
-    , m_width(this, SVGNames::widthAttr, LengthModeWidth)
-    , m_height(this, SVGNames::heightAttr, LengthModeHeight)
-    , m_patternUnits(this, SVGNames::patternUnitsAttr, SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
-    , m_patternContentUnits(this, SVGNames::patternContentUnitsAttr, SVGUnitTypes::SVG_UNIT_TYPE_USERSPACEONUSE)
-    , m_patternTransform(this, SVGNames::patternTransformAttr, SVGTransformList::create(SVGNames::patternTransformAttr))
-    , m_href(this, XLinkNames::hrefAttr)
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
-    , m_viewBox(this, SVGNames::viewBoxAttr)
-    , m_preserveAspectRatio(this, SVGNames::preserveAspectRatioAttr)
+    , m_x(LengthModeWidth)
+    , m_y(LengthModeHeight)
+    , m_width(LengthModeWidth)
+    , m_height(LengthModeHeight)
+    , m_patternUnits(SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX)
+    , m_patternContentUnits(SVGUnitTypes::SVG_UNIT_TYPE_USERSPACEONUSE)
+    , m_patternTransform(SVGTransformList::create(SVGNames::patternTransformAttr))
 {
 }
 
@@ -138,6 +134,48 @@ void SVGPatternElement::svgAttributeChanged(const QualifiedName& attrName)
         m_resource->invalidate();
 }
 
+void SVGPatternElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizePatternUnits();
+        synchronizePatternContentUnits();
+        synchronizePatternTransform();
+        synchronizeX();
+        synchronizeY();
+        synchronizeWidth();
+        synchronizeHeight();
+        synchronizeExternalResourcesRequired();
+        synchronizeViewBox();
+        synchronizePreserveAspectRatio();
+        synchronizeHref();
+        return;
+    }
+
+    if (attrName == SVGNames::patternUnitsAttr)
+        synchronizePatternUnits();
+    else if (attrName == SVGNames::patternContentUnitsAttr)
+        synchronizePatternContentUnits();
+    else if (attrName == SVGNames::patternTransformAttr)
+        synchronizePatternTransform();
+    else if (attrName == SVGNames::xAttr)
+        synchronizeX();
+    else if (attrName == SVGNames::yAttr)
+        synchronizeY();
+    else if (attrName == SVGNames::widthAttr)
+        synchronizeWidth();
+    else if (attrName == SVGNames::heightAttr)
+        synchronizeHeight();
+    else if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+    else if (SVGFitToViewBox::isKnownAttribute(attrName)) {
+        synchronizeViewBox();
+        synchronizePreserveAspectRatio();
+    } else if (SVGURIReference::isKnownAttribute(attrName))
+        synchronizeHref();
+}
+
 void SVGPatternElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
 {
     SVGStyledElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
index 2e7deed..fffbbca 100644 (file)
@@ -52,31 +52,30 @@ namespace WebCore {
 
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
 
         virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
         virtual SVGResource* canvasResource(const RenderObject*);
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGPatternElement, SVGNames::patternTagString, SVGNames::xAttrString, SVGLength, X, x)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGPatternElement, SVGNames::patternTagString, SVGNames::yAttrString, SVGLength, Y, y)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGPatternElement, SVGNames::patternTagString, SVGNames::widthAttrString, SVGLength, Width, width)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGPatternElement, SVGNames::patternTagString, SVGNames::heightAttrString, SVGLength, Height, height)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGPatternElement, SVGNames::patternTagString, SVGNames::patternUnitsAttrString, int, PatternUnits, patternUnits)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGPatternElement, SVGNames::patternTagString, SVGNames::patternContentUnitsAttrString, int, PatternContentUnits, patternContentUnits)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGPatternElement, SVGNames::patternTagString, SVGNames::patternTransformAttrString, SVGTransformList, PatternTransform, patternTransform)
+        DECLARE_ANIMATED_PROPERTY(SVGPatternElement, SVGNames::xAttr, SVGLength, X, x)
+        DECLARE_ANIMATED_PROPERTY(SVGPatternElement, SVGNames::yAttr, SVGLength, Y, y)
+        DECLARE_ANIMATED_PROPERTY(SVGPatternElement, SVGNames::widthAttr, SVGLength, Width, width)
+        DECLARE_ANIMATED_PROPERTY(SVGPatternElement, SVGNames::heightAttr, SVGLength, Height, height)
+        DECLARE_ANIMATED_PROPERTY(SVGPatternElement, SVGNames::patternUnitsAttr, int, PatternUnits, patternUnits)
+        DECLARE_ANIMATED_PROPERTY(SVGPatternElement, SVGNames::patternContentUnitsAttr, int, PatternContentUnits, patternContentUnits)
+        DECLARE_ANIMATED_PROPERTY(SVGPatternElement, SVGNames::patternTransformAttr, SVGTransformList*, PatternTransform, patternTransform)
 
         // SVGURIReference
-        ANIMATED_PROPERTY_DECLARATIONS(SVGPatternElement, SVGURIReferenceIdentifier, XLinkNames::hrefAttrString, String, Href, href)
+        DECLARE_ANIMATED_PROPERTY(SVGPatternElement, XLinkNames::hrefAttr, String, Href, href)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGPatternElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGPatternElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
 
         // SVGPatternElement
-        ANIMATED_PROPERTY_DECLARATIONS(SVGPatternElement, SVGFitToViewBoxIdentifier, SVGNames::viewBoxAttrString, FloatRect, ViewBox, viewBox)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGPatternElement, SVGFitToViewBoxIdentifier, SVGNames::preserveAspectRatioAttrString, SVGPreserveAspectRatio, PreserveAspectRatio, preserveAspectRatio)
+        DECLARE_ANIMATED_PROPERTY(SVGPatternElement, SVGNames::viewBoxAttr, FloatRect, ViewBox, viewBox)
+        DECLARE_ANIMATED_PROPERTY(SVGPatternElement, SVGNames::preserveAspectRatioAttr, SVGPreserveAspectRatio, PreserveAspectRatio, preserveAspectRatio)
  
         mutable RefPtr<SVGPaintServerPattern> m_resource;
 
index 61725b5..800bdfa 100644 (file)
@@ -27,7 +27,6 @@
 #include "FloatPoint.h"
 #include "MappedAttribute.h"
 #include "RenderPath.h"
-#include "SVGAnimatedProperty.h"
 #include "SVGNames.h"
 #include "SVGParserUtilities.h"
 #include "SVGPointList.h"
@@ -40,7 +39,6 @@ SVGPolyElement::SVGPolyElement(const QualifiedName& tagName, Document* doc)
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
     , SVGAnimatedPoints()
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
 {
 }
 
@@ -88,41 +86,35 @@ void SVGPolyElement::svgAttributeChanged(const QualifiedName& attrName)
 {
     SVGStyledTransformableElement::svgAttributeChanged(attrName);
 
-    if (!renderer())
-        return;
-
-    if (attrName == SVGNames::pointsAttr) {
+    // The points property is not a regular SVGAnimatedProperty, still we use the same SVG<->XML DOM synchronization framework.
+    if (attrName == SVGNames::pointsAttr)
         setSynchronizedSVGAttributes(false);
-        renderer()->setNeedsLayout(true);
+
+    if (!renderer())
         return;
-    }
 
-    if (SVGTests::isKnownAttribute(attrName) ||
-        SVGLangSpace::isKnownAttribute(attrName) ||
-        SVGExternalResourcesRequired::isKnownAttribute(attrName) ||
-        SVGStyledTransformableElement::isKnownAttribute(attrName))
+    if (attrName == SVGNames::pointsAttr
+        || SVGTests::isKnownAttribute(attrName)
+        || SVGLangSpace::isKnownAttribute(attrName)
+        || SVGExternalResourcesRequired::isKnownAttribute(attrName)
+        || SVGStyledTransformableElement::isKnownAttribute(attrName))
         renderer()->setNeedsLayout(true);
 }
 
-// Custom SVG<->XML synchronization logic, as SVGPoly*Element doesn't use animated
-// properties for this, but a special solution: SVGAnimatedPoints inheritance.
-void SVGPolyElement::updateAnimatedSVGAttribute(const String& name) const
+void SVGPolyElement::synchronizeProperty(const QualifiedName& attrName)
 {
-    ASSERT(!m_areSVGAttributesValid);
-
-    if (m_synchronizingSVGAttributes)
-        return;
-
-    if (name == SVGNames::pointsAttr.localName()) {
-        m_synchronizingSVGAttributes = true;
+    SVGStyledTransformableElement::synchronizeProperty(attrName);
 
-        PropertySynchronizer<SVGPolyElement, SVGPointList*, true>::synchronize(this, SVGNames::pointsAttr, m_points.get());
-        setSynchronizedSVGAttributes(true);
-        m_synchronizingSVGAttributes = false;
+    if (attrName == anyQName()) {
+        synchronizeExternalResourcesRequired();
+        SVGAnimatedPropertySynchronizer<true>::synchronize(this, SVGNames::pointsAttr, points()->valueAsString());
         return;
     }
 
-    SVGStyledTransformableElement::updateAnimatedSVGAttribute(name);
+    if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+    else if (attrName == SVGNames::pointsAttr)
+        SVGAnimatedPropertySynchronizer<true>::synchronize(this, attrName, points()->valueAsString());
 }
 
 }
index 2ffd150..b881ca2 100644 (file)
@@ -46,17 +46,14 @@ namespace WebCore {
 
         virtual void parseMappedAttribute(MappedAttribute*); 
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
 
         virtual bool rendererIsNeeded(RenderStyle* style) { return StyledElement::rendererIsNeeded(style); }
         virtual bool supportsMarkers() const { return true; }
 
-        virtual void updateAnimatedSVGAttribute(const String&) const;
-
     private:
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGPolyElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGPolyElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
 
         mutable RefPtr<SVGPointList> m_points;
     };
index 1367c90..b153c0f 100644 (file)
@@ -42,11 +42,11 @@ namespace WebCore {
 
 SVGRadialGradientElement::SVGRadialGradientElement(const QualifiedName& tagName, Document* doc)
     : SVGGradientElement(tagName, doc)
-    , m_cx(this, SVGNames::cxAttr, LengthModeWidth, "50%")
-    , m_cy(this, SVGNames::cyAttr, LengthModeHeight, "50%")
-    , m_r(this, SVGNames::rAttr, LengthModeOther, "50%")
-    , m_fx(this, SVGNames::fxAttr, LengthModeWidth)
-    , m_fy(this, SVGNames::fyAttr, LengthModeHeight)
+    , m_cx(LengthModeWidth, "50%")
+    , m_cy(LengthModeHeight, "50%")
+    , m_r(LengthModeOther, "50%")
+    , m_fx(LengthModeWidth)
+    , m_fy(LengthModeHeight)
 {
     // Spec: If the cx/cy/r attribute is not specified, the effect is as if a value of "50%" were specified.
 }
@@ -86,6 +86,31 @@ void SVGRadialGradientElement::svgAttributeChanged(const QualifiedName& attrName
         m_resource->invalidate();
 }
 
+void SVGRadialGradientElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGGradientElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeCx();
+        synchronizeCy();
+        synchronizeFx();
+        synchronizeFy();
+        synchronizeR();
+        return;
+    }
+
+    if (attrName == SVGNames::cxAttr)
+        synchronizeCx();
+    else if (attrName == SVGNames::cyAttr)
+        synchronizeCy();
+    else if (attrName == SVGNames::fxAttr)
+        synchronizeFx();
+    else if (attrName == SVGNames::fyAttr)
+        synchronizeFy();
+    else if (attrName == SVGNames::rAttr)
+        synchronizeR();
+}
+
 void SVGRadialGradientElement::buildGradient() const
 {
     RadialGradientAttributes attributes = collectGradientProperties();
index 61f56f5..180948f 100644 (file)
@@ -36,6 +36,7 @@ namespace WebCore {
 
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
 
     protected:
         virtual void buildGradient() const;
@@ -44,11 +45,11 @@ namespace WebCore {
         RadialGradientAttributes collectGradientProperties() const;
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGRadialGradientElement, SVGNames::radialGradientTagString, SVGNames::cxAttrString, SVGLength, Cx, cx)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGRadialGradientElement, SVGNames::radialGradientTagString, SVGNames::cyAttrString, SVGLength, Cy, cy)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGRadialGradientElement, SVGNames::radialGradientTagString, SVGNames::rAttrString, SVGLength, R, r)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGRadialGradientElement, SVGNames::radialGradientTagString, SVGNames::fxAttrString, SVGLength, Fx, fx)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGRadialGradientElement, SVGNames::radialGradientTagString, SVGNames::fyAttrString, SVGLength, Fy, fy)
+        DECLARE_ANIMATED_PROPERTY(SVGRadialGradientElement, SVGNames::cxAttr, SVGLength, Cx, cx)
+        DECLARE_ANIMATED_PROPERTY(SVGRadialGradientElement, SVGNames::cyAttr, SVGLength, Cy, cy)
+        DECLARE_ANIMATED_PROPERTY(SVGRadialGradientElement, SVGNames::rAttr, SVGLength, R, r)
+        DECLARE_ANIMATED_PROPERTY(SVGRadialGradientElement, SVGNames::fxAttr, SVGLength, Fx, fx)
+        DECLARE_ANIMATED_PROPERTY(SVGRadialGradientElement, SVGNames::fyAttr, SVGLength, Fy, fy)
     };
 
 } // namespace WebCore
index f9b04c8..014c42f 100644 (file)
@@ -35,13 +35,12 @@ SVGRectElement::SVGRectElement(const QualifiedName& tagName, Document *doc)
     , SVGTests()
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
-    , m_x(this, SVGNames::xAttr, LengthModeWidth)
-    , m_y(this, SVGNames::yAttr, LengthModeHeight)
-    , m_width(this, SVGNames::widthAttr, LengthModeWidth)
-    , m_height(this, SVGNames::heightAttr, LengthModeHeight)
-    , m_rx(this, SVGNames::rxAttr, LengthModeWidth)
-    , m_ry(this, SVGNames::ryAttr, LengthModeHeight)
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
+    , m_x(LengthModeWidth)
+    , m_y(LengthModeHeight)
+    , m_width(LengthModeWidth)
+    , m_height(LengthModeHeight)
+    , m_rx(LengthModeWidth)
+    , m_ry(LengthModeHeight)
 {
 }
 
@@ -99,6 +98,37 @@ void SVGRectElement::svgAttributeChanged(const QualifiedName& attrName)
         renderer()->setNeedsLayout(true);
 }
 
+void SVGRectElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledTransformableElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeX();
+        synchronizeY();
+        synchronizeWidth();
+        synchronizeHeight();
+        synchronizeRx();
+        synchronizeRy();
+        synchronizeExternalResourcesRequired();
+        return;
+    }
+
+    if (attrName == SVGNames::xAttr)
+        synchronizeX();
+    else if (attrName == SVGNames::yAttr)
+        synchronizeY();
+    else if (attrName == SVGNames::widthAttr)
+        synchronizeWidth();
+    else if (attrName == SVGNames::heightAttr)
+        synchronizeHeight();
+    else if (attrName == SVGNames::rxAttr)
+        synchronizeRx();
+    else if (attrName == SVGNames::ryAttr)
+        synchronizeRy();
+    else if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+}
+
 Path SVGRectElement::toPathData() const
 {
     FloatRect rect(x().value(this), y().value(this), width().value(this), height().value(this));
index a4d859e..df382f9 100644 (file)
@@ -41,6 +41,7 @@ namespace WebCore {
 
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
 
         virtual Path toPathData() const;
 
@@ -48,17 +49,15 @@ namespace WebCore {
         virtual bool hasRelativeValues() const;
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGRectElement, SVGNames::rectTagString, SVGNames::xAttrString, SVGLength, X, x)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGRectElement, SVGNames::rectTagString, SVGNames::yAttrString, SVGLength, Y, y)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGRectElement, SVGNames::rectTagString, SVGNames::widthAttrString, SVGLength, Width, width)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGRectElement, SVGNames::rectTagString, SVGNames::heightAttrString, SVGLength, Height, height)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGRectElement, SVGNames::rectTagString, SVGNames::rxAttrString, SVGLength, Rx, rx)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGRectElement, SVGNames::rectTagString, SVGNames::ryAttrString, SVGLength, Ry, ry)
+        DECLARE_ANIMATED_PROPERTY(SVGRectElement, SVGNames::xAttr, SVGLength, X, x)
+        DECLARE_ANIMATED_PROPERTY(SVGRectElement, SVGNames::yAttr, SVGLength, Y, y)
+        DECLARE_ANIMATED_PROPERTY(SVGRectElement, SVGNames::widthAttr, SVGLength, Width, width)
+        DECLARE_ANIMATED_PROPERTY(SVGRectElement, SVGNames::heightAttr, SVGLength, Height, height)
+        DECLARE_ANIMATED_PROPERTY(SVGRectElement, SVGNames::rxAttr, SVGLength, Rx, rx)
+        DECLARE_ANIMATED_PROPERTY(SVGRectElement, SVGNames::ryAttr, SVGLength, Ry, ry)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGRectElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGRectElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
     };
 
 } // namespace WebCore
index f60aa07..eed8b54 100644 (file)
@@ -63,13 +63,10 @@ SVGSVGElement::SVGSVGElement(const QualifiedName& tagName, Document* doc)
     , SVGExternalResourcesRequired()
     , SVGFitToViewBox()
     , SVGZoomAndPan()
-    , m_x(this, SVGNames::xAttr, LengthModeWidth)
-    , m_y(this, SVGNames::yAttr, LengthModeHeight)
-    , m_width(this, SVGNames::widthAttr, LengthModeWidth, "100%")
-    , m_height(this, SVGNames::heightAttr, LengthModeHeight, "100%") 
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
-    , m_viewBox(this, SVGNames::viewBoxAttr)
-    , m_preserveAspectRatio(this, SVGNames::preserveAspectRatioAttr)
+    , m_x(LengthModeWidth)
+    , m_y(LengthModeHeight)
+    , m_width(LengthModeWidth, "100%")
+    , m_height(LengthModeHeight, "100%") 
     , m_useCurrentView(false)
     , m_timeContainer(SMILTimeContainer::create(this))
     , m_scale(1)
@@ -312,6 +309,37 @@ void SVGSVGElement::svgAttributeChanged(const QualifiedName& attrName)
         renderer()->setNeedsLayout(true);
 }
 
+void SVGSVGElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeX();
+        synchronizeY();
+        synchronizeWidth();
+        synchronizeHeight();
+        synchronizeExternalResourcesRequired();
+        synchronizeViewBox();
+        synchronizePreserveAspectRatio();
+        return;
+    }
+
+    if (attrName == SVGNames::xAttr)
+        synchronizeX();
+    else if (attrName == SVGNames::yAttr)
+        synchronizeY();
+    else if (attrName == SVGNames::widthAttr)
+        synchronizeWidth();
+    else if (attrName == SVGNames::heightAttr)
+        synchronizeHeight();
+    else if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+    else if (SVGFitToViewBox::isKnownAttribute(attrName)) {
+        synchronizeViewBox();
+        synchronizePreserveAspectRatio();
+    }
+}
+
 unsigned SVGSVGElement::suspendRedraw(unsigned /* maxWaitMilliseconds */)
 {
     // FIXME: Implement me (see bug 11275)
index 5a31d70..3d6f109 100644 (file)
@@ -125,6 +125,7 @@ namespace WebCore {
         virtual void removedFromDocument();
 
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
 
         TransformationMatrix viewBoxToViewTransform(float viewWidth, float viewHeight) const;
 
@@ -134,19 +135,17 @@ namespace WebCore {
         virtual bool hasRelativeValues() const;
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGSVGElement, SVGNames::svgTagString, SVGNames::xAttrString, SVGLength, X, x)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGSVGElement, SVGNames::svgTagString, SVGNames::yAttrString, SVGLength, Y, y)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGSVGElement, SVGNames::svgTagString, SVGNames::widthAttrString, SVGLength, Width, width)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGSVGElement, SVGNames::svgTagString, SVGNames::heightAttrString, SVGLength, Height, height)
+        DECLARE_ANIMATED_PROPERTY(SVGSVGElement, SVGNames::xAttr, SVGLength, X, x)
+        DECLARE_ANIMATED_PROPERTY(SVGSVGElement, SVGNames::yAttr, SVGLength, Y, y)
+        DECLARE_ANIMATED_PROPERTY(SVGSVGElement, SVGNames::widthAttr, SVGLength, Width, width)
+        DECLARE_ANIMATED_PROPERTY(SVGSVGElement, SVGNames::heightAttr, SVGLength, Height, height)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGSVGElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGSVGElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
 
         // SVGFitToViewBox
-        ANIMATED_PROPERTY_DECLARATIONS(SVGSVGElement, SVGFitToViewBoxIdentifier, SVGNames::viewBoxAttrString, FloatRect, ViewBox, viewBox)
-        ANIMATED_PROPERTY_DECLARATIONS(SVGSVGElement, SVGFitToViewBoxIdentifier, SVGNames::preserveAspectRatioAttrString, SVGPreserveAspectRatio, PreserveAspectRatio, preserveAspectRatio)
+        DECLARE_ANIMATED_PROPERTY(SVGSVGElement, SVGNames::viewBoxAttr, FloatRect, ViewBox, viewBox)
+        DECLARE_ANIMATED_PROPERTY(SVGSVGElement, SVGNames::preserveAspectRatioAttr, SVGPreserveAspectRatio, PreserveAspectRatio, preserveAspectRatio)
  
         virtual void documentWillBecomeInactive();
         virtual void documentDidBecomeActive();
index 7be72dc..299ab8d 100644 (file)
@@ -35,8 +35,6 @@ SVGScriptElement::SVGScriptElement(const QualifiedName& tagName, Document* doc,
     : SVGElement(tagName, doc)
     , SVGURIReference()
     , SVGExternalResourcesRequired()
-    , m_href(this, XLinkNames::hrefAttr) 
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
     , m_data(this, this)
 {
     m_data.setCreatedByParser(createdByParser);
@@ -86,6 +84,22 @@ void SVGScriptElement::svgAttributeChanged(const QualifiedName& attrName)
     }
 }
 
+void SVGScriptElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName()) {
+        synchronizeExternalResourcesRequired();
+        synchronizeHref();
+        return;
+    }
+
+    if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
+    else if (SVGURIReference::isKnownAttribute(attrName))
+        synchronizeHref();
+}
+
 void SVGScriptElement::insertedIntoDocument()
 {
     SVGElement::insertedIntoDocument();
index 699c535..396907c 100644 (file)
@@ -45,6 +45,7 @@ namespace WebCore {
         virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
 
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
         virtual bool isURLAttribute(Attribute*) const;
         virtual void finishParsingChildren();
 
@@ -71,12 +72,10 @@ namespace WebCore {
 
     private:
         // SVGURIReference
-        ANIMATED_PROPERTY_DECLARATIONS(SVGScriptElement, SVGURIReferenceIdentifier, XLinkNames::hrefAttrString, String, Href, href)
+        DECLARE_ANIMATED_PROPERTY(SVGScriptElement, XLinkNames::hrefAttr, String, Href, href)
 
         // SVGExternalResourcesRequired
-        ANIMATED_PROPERTY_DECLARATIONS(SVGScriptElement, SVGExternalResourcesRequiredIdentifier,
-                                       SVGNames::externalResourcesRequiredAttrString, bool,
-                                       ExternalResourcesRequired, externalResourcesRequired)
+        DECLARE_ANIMATED_PROPERTY(SVGScriptElement, SVGNames::externalResourcesRequiredAttr, bool, ExternalResourcesRequired, externalResourcesRequired)
 
     private:
         ScriptElementData m_data;
index 0549031..3c97827 100644 (file)
@@ -33,7 +33,7 @@ namespace WebCore {
 
 SVGStopElement::SVGStopElement(const QualifiedName& tagName, Document* doc)
     : SVGStyledElement(tagName, doc)
-    , m_offset(this, SVGNames::offsetAttr, 0.0f)
+    , m_offset(0.0f)
 {
 }
 
@@ -55,6 +55,14 @@ void SVGStopElement::parseMappedAttribute(MappedAttribute* attr)
         SVGStyledElement::parseMappedAttribute(attr);
 }
 
+void SVGStopElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName() || attrName == SVGNames::offsetAttr)
+        synchronizeOffset();
+}
+
 RenderObject* SVGStopElement::createRenderer(RenderArena* arena, RenderStyle*)
 {
     return new (arena) RenderSVGGradientStop(this);
index 5d14a40..23c09bb 100644 (file)
@@ -32,6 +32,8 @@ namespace WebCore {
         SVGStopElement(const QualifiedName&, Document*);
         virtual ~SVGStopElement();
 
+        virtual void synchronizeProperty(const QualifiedName&);
+
     private:
         virtual bool isGradientStop() const { return true; }
 
@@ -39,7 +41,7 @@ namespace WebCore {
 
         virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
 
-        ANIMATED_PROPERTY_DECLARATIONS(SVGStopElement, SVGNames::stopTagString, SVGNames::offsetAttrString, float, Offset, offset)
+        DECLARE_ANIMATED_PROPERTY(SVGStopElement, SVGNames::offsetAttr, float, Offset, offset)
     };
 
 } // namespace WebCore
index 59b4c9b..155e6c6 100644 (file)
@@ -46,8 +46,6 @@ namespace WebCore {
 
 using namespace SVGNames;
 
-char SVGStyledElementIdentifier[] = "SVGStyledElement";
-
 void mapAttributeToCSSProperty(HashMap<AtomicStringImpl*, int>* propertyNameToIdMap, const QualifiedName& attrName)
 {
     int propertyId = cssPropertyID(attrName.localName());
@@ -57,7 +55,6 @@ void mapAttributeToCSSProperty(HashMap<AtomicStringImpl*, int>* propertyNameToId
 
 SVGStyledElement::SVGStyledElement(const QualifiedName& tagName, Document* doc)
     : SVGElement(tagName, doc)
-    , m_className(this, HTMLNames::classAttr)
     , m_instanceUpdatesBlocked(false)
 {
 }
@@ -178,7 +175,7 @@ void SVGStyledElement::parseMappedAttribute(MappedAttribute* attr)
     // style updates (instead of StyledElement::parseMappedAttribute). We don't
     // tell StyledElement about the change to avoid parsing the class list twice
     if (attrName.matches(HTMLNames::classAttr))
-        setClassName(attr->value());
+        setClassNameBaseValue(attr->value());
     else
         // id is handled by StyledElement which SVGElement inherits from
         SVGElement::parseMappedAttribute(attr);
@@ -211,6 +208,14 @@ void SVGStyledElement::svgAttributeChanged(const QualifiedName& attrName)
     SVGElementInstance::invalidateAllInstancesOfElement(this);
 }
 
+void SVGStyledElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName() || attrName.matches(HTMLNames::classAttr))
+        synchronizeClassName();
+}
+
 void SVGStyledElement::invalidateResources()
 {
     RenderObject* object = renderer();
index 0f2248f..bd57ee2 100644 (file)
@@ -28,7 +28,6 @@
 
 namespace WebCore {
 
-    extern char SVGStyledElementIdentifier[];
     class SVGResource;
 
     void mapAttributeToCSSProperty(HashMap<AtomicStringImpl*, int>* propertyNameToIdMap, const QualifiedName& attrName);
@@ -54,6 +53,7 @@ namespace WebCore {
         virtual bool mapToEntry(const QualifiedName&, MappedAttributeEntry&) const;
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual void svgAttributeChanged(const QualifiedName&);
+        virtual void synchronizeProperty(const QualifiedName&);
 
         virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
 
@@ -72,7 +72,7 @@ namespace WebCore {
         static int cssPropertyIdForSVGAttributeName(const QualifiedName&);
 
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGStyledElement, SVGStyledElementIdentifier, HTMLNames::classAttrString, String, ClassName, className)
+        DECLARE_ANIMATED_PROPERTY(SVGStyledElement, HTMLNames::classAttr, String, ClassName, className)
         bool m_instanceUpdatesBlocked;
     };
 
index f952c46..6815914 100644 (file)
 
 namespace WebCore {
 
-char SVGStyledTransformableElementIdentifier[] = "SVGStyledTransformableElement";
-
 SVGStyledTransformableElement::SVGStyledTransformableElement(const QualifiedName& tagName, Document* doc)
     : SVGStyledLocatableElement(tagName, doc)
     , SVGTransformable()
-    , m_transform(this, SVGNames::transformAttr, SVGTransformList::create(SVGNames::transformAttr))
+    , m_transform(SVGTransformList::create(SVGNames::transformAttr))
 {
 }
 
@@ -80,6 +78,14 @@ void SVGStyledTransformableElement::parseMappedAttribute(MappedAttribute* attr)
         SVGStyledLocatableElement::parseMappedAttribute(attr);
 }
 
+void SVGStyledTransformableElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledLocatableElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName() || SVGTransformable::isKnownAttribute(attrName))
+        synchronizeTransform();
+}
+
 bool SVGStyledTransformableElement::isKnownAttribute(const QualifiedName& attrName)
 {
     return SVGTransformable::isKnownAttribute(attrName) ||
index 3145e6f..b6ab6dd 100644 (file)
@@ -28,8 +28,6 @@
 
 namespace WebCore {
 
-    extern char SVGStyledTransformableElementIdentifier[];
-
     class TransformationMatrix;
 
     class SVGStyledTransformableElement : public SVGStyledLocatableElement,
@@ -51,6 +49,7 @@ namespace WebCore {
         virtual FloatRect getBBox() const;
 
         virtual void parseMappedAttribute(MappedAttribute*);
+        virtual void synchronizeProperty(const QualifiedName&);
         bool isKnownAttribute(const QualifiedName&);
 
         // "base class" methods for all the elements which render as paths
@@ -59,8 +58,7 @@ namespace WebCore {
         virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
 
     protected:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGStyledTransformableElement, SVGStyledTransformableElementIdentifier,
-                                       SVGNames::transformAttrString, SVGTransformList, Transform, transform)
+        DECLARE_ANIMATED_PROPERTY(SVGStyledTransformableElement, SVGNames::transformAttr, SVGTransformList*, Transform, transform)
 
     private:
         // Used by <animateMotion>
index 6d0f5d1..3268b9a 100644 (file)
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2004, 2005 Nikolas Zimmermann <wildfox@kde.org>
+    Copyright (C) 2004, 2005 Nikolas Zimmermann <zimmermann@kde.org>
                   2004, 2005, 2006 Rob Buis <buis@kde.org>
 
     This library is free software; you can redistribute it and/or
@@ -32,7 +32,6 @@ SVGSwitchElement::SVGSwitchElement(const QualifiedName& tagName, Document* doc)
     , SVGTests()
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
-    , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
 {
 }
 
@@ -58,8 +57,14 @@ RenderObject* SVGSwitchElement::createRenderer(RenderArena* arena, RenderStyle*)
     return new (arena) RenderSVGTransformableContainer(this);
 }
 
+void SVGSwitchElement::synchronizeProperty(const QualifiedName& attrName)
+{
+    SVGStyledTransformableElement::synchronizeProperty(attrName);
+
+    if (attrName == anyQName() || SVGExternalResourcesRequired::isKnownAttribute(attrName))
+        synchronizeExternalResourcesRequired();
 }
 
-// vim:ts=4:noet
-#endif // ENABLE(SVG)
+}
 
+#endif // ENABLE(SVG)