Changeset 35094 in webkit

Timestamp:

Jul 10, 2008 12:12:23 AM (16 years ago)

Author:

oliver@apple.com

Message:

2008-07-09 Alex Mathews <​possessedpenguinbob@gmail.com>

Reviewed by Oliver Hunt.

bug 19835: WebKit needs cross-platform filter system
<​https://bugs.webkit.org/show_bug.cgi?id=19835>

More class refactoring in preparation for cross-platform filter
implementation.

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• WebCore.xcodeproj/project.pbxproj (modified) (5 diffs)
• rendering/SVGRenderTreeAsText.h (modified) (1 diff)
• svg/FilterEffect.cpp (modified) (1 diff)
• svg/FilterEffect.h (modified) (2 diffs)
• svg/SVGFEBlendElement.cpp (modified) (1 diff)
• svg/SVGFEBlendElement.h (modified) (1 diff)
• svg/SVGFEColorMatrixElement.cpp (modified) (2 diffs)
• svg/SVGFEColorMatrixElement.h (modified) (1 diff)
• svg/SVGFEComponentTransferElement.cpp (modified) (1 diff)
• svg/SVGFEComponentTransferElement.h (modified) (1 diff)
• svg/SVGFECompositeElement.cpp (modified) (1 diff)
• svg/SVGFECompositeElement.h (modified) (1 diff)
• svg/SVGFEDiffuseLightingElement.cpp (modified) (2 diffs)
• svg/SVGFEDiffuseLightingElement.h (modified) (3 diffs)
• svg/SVGFEDisplacementMapElement.cpp (modified) (3 diffs)
• svg/SVGFEDisplacementMapElement.h (modified) (2 diffs)
• svg/SVGFEFloodElement.cpp (modified) (1 diff)
• svg/SVGFEFloodElement.h (modified) (2 diffs)
• svg/SVGFEGaussianBlurElement.cpp (modified) (1 diff)
• svg/SVGFEGaussianBlurElement.h (modified) (2 diffs)
• svg/SVGFEImageElement.cpp (modified) (1 diff)
• svg/SVGFEImageElement.h (modified) (2 diffs)
• svg/SVGFEMergeElement.cpp (modified) (1 diff)
• svg/SVGFEMergeElement.h (modified) (2 diffs)
• svg/SVGFEOffsetElement.cpp (modified) (1 diff)
• svg/SVGFEOffsetElement.h (modified) (2 diffs)
• svg/SVGFESpecularLightingElement.cpp (modified) (2 diffs)
• svg/SVGFESpecularLightingElement.h (modified) (2 diffs)
• svg/SVGFETileElement.cpp (modified) (1 diff)
• svg/SVGFETileElement.h (modified) (2 diffs)
• svg/SVGFETurbulenceElement.cpp (modified) (3 diffs)
• svg/SVGFETurbulenceElement.h (modified) (2 diffs)
• svg/SVGFilterPrimitiveStandardAttributes.h (modified) (1 diff)
• svg/graphics/filters/SVGFEConvolveMatrix.cpp (modified) (2 diffs)
• svg/graphics/filters/SVGFEConvolveMatrix.h (modified) (1 diff)
• svg/graphics/filters/SVGFEDiffuseLighting.cpp (modified) (1 diff)
• svg/graphics/filters/SVGFEDiffuseLighting.h (modified) (1 diff)
• svg/graphics/filters/SVGFEDisplacementMap.cpp (modified) (2 diffs)
• svg/graphics/filters/SVGFEDisplacementMap.h (modified) (1 diff)
• svg/graphics/filters/SVGFEFlood.cpp (modified) (1 diff)
• svg/graphics/filters/SVGFEFlood.h (modified) (1 diff)
• svg/graphics/filters/SVGFEGaussianBlur.cpp (modified) (1 diff)
• svg/graphics/filters/SVGFEGaussianBlur.h (modified) (1 diff)
• svg/graphics/filters/SVGFEImage.cpp (modified) (3 diffs)
• svg/graphics/filters/SVGFEImage.h (modified) (1 diff)
• svg/graphics/filters/SVGFEMerge.cpp (modified) (1 diff)
• svg/graphics/filters/SVGFEMerge.h (modified) (1 diff)
• svg/graphics/filters/SVGFEMorphology.cpp (modified) (2 diffs)
• svg/graphics/filters/SVGFEMorphology.h (modified) (1 diff)
• svg/graphics/filters/SVGFEOffset.cpp (modified) (1 diff)
• svg/graphics/filters/SVGFEOffset.h (modified) (1 diff)
• svg/graphics/filters/SVGFESpecularLighting.cpp (modified) (1 diff)
• svg/graphics/filters/SVGFESpecularLighting.h (modified) (1 diff)
• svg/graphics/filters/SVGFETile.cpp (modified) (1 diff)
• svg/graphics/filters/SVGFETile.h (modified) (1 diff)
• svg/graphics/filters/SVGFETurbulence.cpp (modified) (3 diffs)
• svg/graphics/filters/SVGFETurbulence.h (modified) (1 diff)
• svg/graphics/filters/cg/SVGFEDiffuseLightingCg.mm (deleted)
• svg/graphics/filters/cg/SVGFEDisplacementMapCg.mm (deleted)
• svg/graphics/filters/cg/SVGFEFloodCg.mm (deleted)
• svg/graphics/filters/cg/SVGFEGaussianBlurCg.mm (deleted)
• svg/graphics/filters/cg/SVGFEHelpersCg.h (modified) (1 diff)
• svg/graphics/filters/cg/SVGFEHelpersCg.mm (modified) (1 diff)
• svg/graphics/filters/cg/SVGFEImageCg.mm (deleted)
• svg/graphics/filters/cg/SVGFEMergeCg.mm (deleted)
• svg/graphics/filters/cg/SVGFEOffsetCg.mm (deleted)
• svg/graphics/filters/cg/SVGFESpecularLightingCg.mm (deleted)
• svg/graphics/filters/cg/SVGFETileCg.mm (deleted)

trunk/WebCore/ChangeLog

@@ +1 @@
+2008-07-09  Alex Mathews  <possessedpenguinbob@gmail.com>
+
+        Reviewed by Oliver Hunt.
+
+        bug 19835: WebKit needs cross-platform filter system
+        <https://bugs.webkit.org/show_bug.cgi?id=19835>
+
+        More class refactoring in preparation for cross-platform filter 
+        implementation.
+
+        * WebCore.xcodeproj/project.pbxproj:
+        * rendering/SVGRenderTreeAsText.h:
+        (WebCore::operator<<):
+        * svg/FilterEffect.cpp:
+        (WebCore::FilterEffect::externalRepresentation):
+        * svg/FilterEffect.h:
+        * svg/SVGFEBlendElement.cpp:
+        (WebCore::SVGFEBlendElement::build):
+        * svg/SVGFEBlendElement.h:
+        * svg/SVGFEColorMatrixElement.cpp:
+        (WebCore::SVGFEColorMatrixElement::build):
+        * svg/SVGFEColorMatrixElement.h:
+        * svg/SVGFEComponentTransferElement.cpp:
+        (WebCore::SVGFEComponentTransferElement::build):
+        * svg/SVGFEComponentTransferElement.h:
+        * svg/SVGFECompositeElement.cpp:
+        (WebCore::SVGFECompositeElement::build):
+        * svg/SVGFECompositeElement.h:
+        * svg/SVGFEDiffuseLightingElement.cpp:
+        (WebCore::SVGFEDiffuseLightingElement::filterEffect):
+        (WebCore::SVGFEDiffuseLightingElement::build):
+        (WebCore::SVGFEDiffuseLightingElement::findLights):
+        * svg/SVGFEDiffuseLightingElement.h:
+        * svg/SVGFEDisplacementMapElement.cpp:
+        (WebCore::SVGFEDisplacementMapElement::SVGFEDisplacementMapElement):
+        (WebCore::SVGFEDisplacementMapElement::stringToChannel):
+        (WebCore::SVGFEDisplacementMapElement::filterEffect):
+        (WebCore::SVGFEDisplacementMapElement::build):
+        * svg/SVGFEDisplacementMapElement.h:
+        * svg/SVGFEFloodElement.cpp:
+        (WebCore::SVGFEFloodElement::filterEffect):
+        (WebCore::SVGFEFloodElement::build):
+        * svg/SVGFEFloodElement.h:
+        (WebCore::SVGFEFloodElement::contextElement):
+        * svg/SVGFEGaussianBlurElement.cpp:
+        (WebCore::SVGFEGaussianBlurElement::filterEffect):
+        (WebCore::SVGFEGaussianBlurElement::build):
+        * svg/SVGFEGaussianBlurElement.h:
+        * svg/SVGFEImageElement.cpp:
+        (WebCore::SVGFEImageElement::filterEffect):
+        (WebCore::SVGFEImageElement::build):
+        * svg/SVGFEImageElement.h:
+        * svg/SVGFEMergeElement.cpp:
+        (WebCore::SVGFEMergeElement::filterEffect):
+        (WebCore::SVGFEMergeElement::build):
+        * svg/SVGFEMergeElement.h:
+        (WebCore::SVGFEMergeElement::contextElement):
+        * svg/SVGFEOffsetElement.cpp:
+        (WebCore::SVGFEOffsetElement::filterEffect):
+        (WebCore::SVGFEOffsetElement::build):
+        * svg/SVGFEOffsetElement.h:
+        * svg/SVGFESpecularLightingElement.cpp:
+        (WebCore::SVGFESpecularLightingElement::filterEffect):
+        (WebCore::SVGFESpecularLightingElement::findLights):
+        (WebCore::SVGFESpecularLightingElement::build):
+        * svg/SVGFESpecularLightingElement.h:
+        * svg/SVGFETileElement.cpp:
+        (WebCore::SVGFETileElement::filterEffect):
+        (WebCore::SVGFETileElement::build):
+        * svg/SVGFETileElement.h:
+        * svg/SVGFETurbulenceElement.cpp:
+        (WebCore::SVGFETurbulenceElement::SVGFETurbulenceElement):
+        (WebCore::SVGFETurbulenceElement::parseMappedAttribute):
+        (WebCore::SVGFETurbulenceElement::filterEffect):
+        (WebCore::SVGFETurbulenceElement::build):
+        * svg/SVGFETurbulenceElement.h:
+        * svg/SVGFilterPrimitiveStandardAttributes.h:
+        * svg/graphics/filters/SVGFEConvolveMatrix.cpp:
+        (WebCore::FEConvolveMatrix::FEConvolveMatrix):
+        (WebCore::FEConvolveMatrix::create):
+        (WebCore::FEConvolveMatrix::kernelSize):
+        (WebCore::FEConvolveMatrix::setKernelSize):
+        (WebCore::FEConvolveMatrix::kernel):
+        (WebCore::FEConvolveMatrix::setKernel):
+        (WebCore::FEConvolveMatrix::divisor):
+        (WebCore::FEConvolveMatrix::setDivisor):
+        (WebCore::FEConvolveMatrix::bias):
+        (WebCore::FEConvolveMatrix::setBias):
+        (WebCore::FEConvolveMatrix::targetOffset):
+        (WebCore::FEConvolveMatrix::setTargetOffset):
+        (WebCore::FEConvolveMatrix::edgeMode):
+        (WebCore::FEConvolveMatrix::setEdgeMode):
+        (WebCore::FEConvolveMatrix::kernelUnitLength):
+        (WebCore::FEConvolveMatrix::setKernelUnitLength):
+        (WebCore::FEConvolveMatrix::preserveAlpha):
+        (WebCore::FEConvolveMatrix::setPreserveAlpha):
+        (WebCore::FEConvolveMatrix::apply):
+        (WebCore::FEConvolveMatrix::dump):
+        (WebCore::operator<<):
+        (WebCore::FEConvolveMatrix::externalRepresentation):
+        * svg/graphics/filters/SVGFEConvolveMatrix.h:
+        (WebCore::):
+        * svg/graphics/filters/SVGFEDiffuseLighting.cpp:
+        (WebCore::FEDiffuseLighting::FEDiffuseLighting):
+        (WebCore::FEDiffuseLighting::create):
+        (WebCore::FEDiffuseLighting::~FEDiffuseLighting):
+        (WebCore::FEDiffuseLighting::lightingColor):
+        (WebCore::FEDiffuseLighting::setLightingColor):
+        (WebCore::FEDiffuseLighting::surfaceScale):
+        (WebCore::FEDiffuseLighting::setSurfaceScale):
+        (WebCore::FEDiffuseLighting::diffuseConstant):
+        (WebCore::FEDiffuseLighting::setDiffuseConstant):
+        (WebCore::FEDiffuseLighting::kernelUnitLengthX):
+        (WebCore::FEDiffuseLighting::setKernelUnitLengthX):
+        (WebCore::FEDiffuseLighting::kernelUnitLengthY):
+        (WebCore::FEDiffuseLighting::setKernelUnitLengthY):
+        (WebCore::FEDiffuseLighting::lightSource):
+        (WebCore::FEDiffuseLighting::setLightSource):
+        (WebCore::FEDiffuseLighting::apply):
+        (WebCore::FEDiffuseLighting::dump):
+        (WebCore::FEDiffuseLighting::externalRepresentation):
+        * svg/graphics/filters/SVGFEDiffuseLighting.h:
+        * svg/graphics/filters/SVGFEDisplacementMap.cpp:
+        (WebCore::FEDisplacementMap::FEDisplacementMap):
+        (WebCore::FEDisplacementMap::create):
+        (WebCore::FEDisplacementMap::xChannelSelector):
+        (WebCore::FEDisplacementMap::setXChannelSelector):
+        (WebCore::FEDisplacementMap::yChannelSelector):
+        (WebCore::FEDisplacementMap::setYChannelSelector):
+        (WebCore::FEDisplacementMap::scale):
+        (WebCore::FEDisplacementMap::setScale):
+        (WebCore::FEDisplacementMap::apply):
+        (WebCore::FEDisplacementMap::dump):
+        (WebCore::operator<<):
+        (WebCore::FEDisplacementMap::externalRepresentation):
+        * svg/graphics/filters/SVGFEDisplacementMap.h:
+        (WebCore::):
+        * svg/graphics/filters/SVGFEFlood.cpp:
+        (WebCore::FEFlood::FEFlood):
+        (WebCore::FEFlood::create):
+        (WebCore::FEFlood::floodColor):
+        (WebCore::FEFlood::setFloodColor):
+        (WebCore::FEFlood::floodOpacity):
+        (WebCore::FEFlood::setFloodOpacity):
+        (WebCore::FEFlood::apply):
+        (WebCore::FEFlood::dump):
+        (WebCore::FEFlood::externalRepresentation):
+        * svg/graphics/filters/SVGFEFlood.h:
+        * svg/graphics/filters/SVGFEGaussianBlur.cpp:
+        (WebCore::FEGaussianBlur::FEGaussianBlur):
+        (WebCore::FEGaussianBlur::create):
+        (WebCore::FEGaussianBlur::stdDeviationX):
+        (WebCore::FEGaussianBlur::setStdDeviationX):
+        (WebCore::FEGaussianBlur::stdDeviationY):
+        (WebCore::FEGaussianBlur::setStdDeviationY):
+        (WebCore::FEGaussianBlur::apply):
+        (WebCore::FEGaussianBlur::dump):
+        (WebCore::FEGaussianBlur::externalRepresentation):
+        * svg/graphics/filters/SVGFEGaussianBlur.h:
+        * svg/graphics/filters/SVGFEImage.cpp:
+        (WebCore::FEImage::FEImage):
+        (WebCore::FEImage::create):
+        (WebCore::FEImage::~FEImage):
+        (WebCore::FEImage::cachedImage):
+        (WebCore::FEImage::apply):
+        (WebCore::FEImage::dump):
+        (WebCore::FEImage::externalRepresentation):
+        * svg/graphics/filters/SVGFEImage.h:
+        * svg/graphics/filters/SVGFEMerge.cpp:
+        (WebCore::FEMerge::FEMerge):
+        (WebCore::FEMerge::create):
+        (WebCore::FEMerge::mergeInputs):
+        (WebCore::FEMerge::setMergeInputs):
+        (WebCore::FEMerge::apply):
+        (WebCore::FEMerge::dump):
+        (WebCore::FEMerge::externalRepresentation):
+        * svg/graphics/filters/SVGFEMerge.h:
+        * svg/graphics/filters/SVGFEMorphology.cpp:
+        (WebCore::FEMorphology::FEMorphology):
+        (WebCore::FEMorphology::create):
+        (WebCore::FEMorphology::morphologyOperator):
+        (WebCore::FEMorphology::setMorphologyOperator):
+        (WebCore::FEMorphology::radiusX):
+        (WebCore::FEMorphology::setRadiusX):
+        (WebCore::FEMorphology::radiusY):
+        (WebCore::FEMorphology::setRadiusY):
+        (WebCore::FEMorphology::apply):
+        (WebCore::FEMorphology::dump):
+        (WebCore::operator<<):
+        (WebCore::FEMorphology::externalRepresentation):
+        * svg/graphics/filters/SVGFEMorphology.h:
+        (WebCore::):
+        * svg/graphics/filters/SVGFEOffset.cpp:
+        (WebCore::FEOffset::FEOffset):
+        (WebCore::FEOffset::create):
+        (WebCore::FEOffset::dx):
+        (WebCore::FEOffset::setDx):
+        (WebCore::FEOffset::dy):
+        (WebCore::FEOffset::setDy):
+        (WebCore::FEOffset::apply):
+        (WebCore::FEOffset::dump):
+        (WebCore::FEOffset::externalRepresentation):
+        * svg/graphics/filters/SVGFEOffset.h:
+        * svg/graphics/filters/SVGFESpecularLighting.cpp:
+        (WebCore::FESpecularLighting::FESpecularLighting):
+        (WebCore::FESpecularLighting::create):
+        (WebCore::FESpecularLighting::~FESpecularLighting):
+        (WebCore::FESpecularLighting::lightingColor):
+        (WebCore::FESpecularLighting::setLightingColor):
+        (WebCore::FESpecularLighting::surfaceScale):
+        (WebCore::FESpecularLighting::setSurfaceScale):
+        (WebCore::FESpecularLighting::specularConstant):
+        (WebCore::FESpecularLighting::setSpecularConstant):
+        (WebCore::FESpecularLighting::specularExponent):
+        (WebCore::FESpecularLighting::setSpecularExponent):
+        (WebCore::FESpecularLighting::kernelUnitLengthX):
+        (WebCore::FESpecularLighting::setKernelUnitLengthX):
+        (WebCore::FESpecularLighting::kernelUnitLengthY):
+        (WebCore::FESpecularLighting::setKernelUnitLengthY):
+        (WebCore::FESpecularLighting::lightSource):
+        (WebCore::FESpecularLighting::setLightSource):
+        (WebCore::FESpecularLighting::apply):
+        (WebCore::FESpecularLighting::dump):
+        (WebCore::FESpecularLighting::externalRepresentation):
+        * svg/graphics/filters/SVGFESpecularLighting.h:
+        * svg/graphics/filters/SVGFETile.cpp:
+        (WebCore::FETile::FETile):
+        (WebCore::FETile::create):
+        (WebCore::FETile::apply):
+        (WebCore::FETile::dump):
+        (WebCore::FETile::externalRepresentation):
+        * svg/graphics/filters/SVGFETile.h:
+        * svg/graphics/filters/SVGFETurbulence.cpp:
+        (WebCore::FETurbulence::FETurbulence):
+        (WebCore::FETurbulence::create):
+        (WebCore::FETurbulence::type):
+        (WebCore::FETurbulence::setType):
+        (WebCore::FETurbulence::baseFrequencyY):
+        (WebCore::FETurbulence::setBaseFrequencyY):
+        (WebCore::FETurbulence::baseFrequencyX):
+        (WebCore::FETurbulence::setBaseFrequencyX):
+        (WebCore::FETurbulence::seed):
+        (WebCore::FETurbulence::setSeed):
+        (WebCore::FETurbulence::numOctaves):
+        (WebCore::FETurbulence::setNumOctaves):
+        (WebCore::FETurbulence::stitchTiles):
+        (WebCore::FETurbulence::setStitchTiles):
+        (WebCore::FETurbulence::apply):
+        (WebCore::FETurbulence::dump):
+        (WebCore::operator<<):
+        (WebCore::FETurbulence::externalRepresentation):
+        * svg/graphics/filters/SVGFETurbulence.h:
+        (WebCore::):
+        * svg/graphics/filters/cg/SVGFEDiffuseLightingCg.mm:
+        * svg/graphics/filters/cg/SVGFEDisplacementMapCg.mm:
+        * svg/graphics/filters/cg/SVGFEFloodCg.mm:
+        * svg/graphics/filters/cg/SVGFEGaussianBlurCg.mm:
+        * svg/graphics/filters/cg/SVGFEHelpersCg.h:
+        * svg/graphics/filters/cg/SVGFEHelpersCg.mm:
+        (WebCore::getVectorForChannel):
+        * svg/graphics/filters/cg/SVGFEImageCg.mm:
+        * svg/graphics/filters/cg/SVGFEMergeCg.mm:
+        * svg/graphics/filters/cg/SVGFEOffsetCg.mm:
+        * svg/graphics/filters/cg/SVGFESpecularLightingCg.mm:
+        * svg/graphics/filters/cg/SVGFETileCg.mm:
+
 2008-07-09  Mark Rowe  <mrowe@apple.com>
 

trunk/WebCore/WebCore.xcodeproj/project.pbxproj

@@ -3016 +3016 @@
                 B25599350D00D8BA00BB825C /* SVGResourceFilterCg.mm in Sources */ = {isa = PBXBuildFile; fileRef = B25598990D00D8B800BB825C /* SVGResourceFilterCg.mm */; };
                 B25599370D00D8BA00BB825C /* SVGResourceMaskerCg.mm in Sources */ = {isa = PBXBuildFile; fileRef = B255989B0D00D8B800BB825C /* SVGResourceMaskerCg.mm */; };
-                B255993C0D00D8BA00BB825C /* SVGFEDiffuseLightingCg.mm in Sources */ = {isa = PBXBuildFile; fileRef = B25598A20D00D8B800BB825C /* SVGFEDiffuseLightingCg.mm */; };
-                B255993D0D00D8BA00BB825C /* SVGFEDisplacementMapCg.mm in Sources */ = {isa = PBXBuildFile; fileRef = B25598A30D00D8B800BB825C /* SVGFEDisplacementMapCg.mm */; };
-                B255993E0D00D8BA00BB825C /* SVGFEFloodCg.mm in Sources */ = {isa = PBXBuildFile; fileRef = B25598A40D00D8B800BB825C /* SVGFEFloodCg.mm */; };
-                B255993F0D00D8BA00BB825C /* SVGFEGaussianBlurCg.mm in Sources */ = {isa = PBXBuildFile; fileRef = B25598A50D00D8B800BB825C /* SVGFEGaussianBlurCg.mm */; };
                 B25599400D00D8BA00BB825C /* SVGFEHelpersCg.h in Headers */ = {isa = PBXBuildFile; fileRef = B25598A60D00D8B800BB825C /* SVGFEHelpersCg.h */; };
                 B25599410D00D8BA00BB825C /* SVGFEHelpersCg.mm in Sources */ = {isa = PBXBuildFile; fileRef = B25598A70D00D8B800BB825C /* SVGFEHelpersCg.mm */; };
-                B25599420D00D8BA00BB825C /* SVGFEImageCg.mm in Sources */ = {isa = PBXBuildFile; fileRef = B25598A80D00D8B800BB825C /* SVGFEImageCg.mm */; };
-                B25599430D00D8BA00BB825C /* SVGFEMergeCg.mm in Sources */ = {isa = PBXBuildFile; fileRef = B25598A90D00D8B800BB825C /* SVGFEMergeCg.mm */; };
-                B25599440D00D8BA00BB825C /* SVGFEOffsetCg.mm in Sources */ = {isa = PBXBuildFile; fileRef = B25598AA0D00D8B800BB825C /* SVGFEOffsetCg.mm */; };
-                B25599450D00D8BA00BB825C /* SVGFESpecularLightingCg.mm in Sources */ = {isa = PBXBuildFile; fileRef = B25598AB0D00D8B800BB825C /* SVGFESpecularLightingCg.mm */; };
-                B25599460D00D8BA00BB825C /* SVGFETileCg.mm in Sources */ = {isa = PBXBuildFile; fileRef = B25598AC0D00D8B800BB825C /* SVGFETileCg.mm */; };
                 B25599470D00D8BA00BB825C /* SVGFilterEffectCg.mm in Sources */ = {isa = PBXBuildFile; fileRef = B25598AD0D00D8B800BB825C /* SVGFilterEffectCg.mm */; };
                 B25599480D00D8BA00BB825C /* WKArithmeticFilter.cikernel in Resources */ = {isa = PBXBuildFile; fileRef = B25598AE0D00D8B900BB825C /* WKArithmeticFilter.cikernel */; };
@@ -7370 +7361 @@
                 B25598990D00D8B800BB825C /* SVGResourceFilterCg.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; path = SVGResourceFilterCg.mm; sourceTree = "<group>"; };
                 B255989B0D00D8B800BB825C /* SVGResourceMaskerCg.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; path = SVGResourceMaskerCg.mm; sourceTree = "<group>"; };
-                B25598A20D00D8B800BB825C /* SVGFEDiffuseLightingCg.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; path = SVGFEDiffuseLightingCg.mm; sourceTree = "<group>"; };
-                B25598A30D00D8B800BB825C /* SVGFEDisplacementMapCg.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; path = SVGFEDisplacementMapCg.mm; sourceTree = "<group>"; };
-                B25598A40D00D8B800BB825C /* SVGFEFloodCg.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; path = SVGFEFloodCg.mm; sourceTree = "<group>"; };
-                B25598A50D00D8B800BB825C /* SVGFEGaussianBlurCg.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; path = SVGFEGaussianBlurCg.mm; sourceTree = "<group>"; };
                 B25598A60D00D8B800BB825C /* SVGFEHelpersCg.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SVGFEHelpersCg.h; sourceTree = "<group>"; };
                 B25598A70D00D8B800BB825C /* SVGFEHelpersCg.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; path = SVGFEHelpersCg.mm; sourceTree = "<group>"; };
-                B25598A80D00D8B800BB825C /* SVGFEImageCg.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; path = SVGFEImageCg.mm; sourceTree = "<group>"; };
-                B25598A90D00D8B800BB825C /* SVGFEMergeCg.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; path = SVGFEMergeCg.mm; sourceTree = "<group>"; };
-                B25598AA0D00D8B800BB825C /* SVGFEOffsetCg.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; path = SVGFEOffsetCg.mm; sourceTree = "<group>"; };
-                B25598AB0D00D8B800BB825C /* SVGFESpecularLightingCg.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; path = SVGFESpecularLightingCg.mm; sourceTree = "<group>"; };
-                B25598AC0D00D8B800BB825C /* SVGFETileCg.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; path = SVGFETileCg.mm; sourceTree = "<group>"; };
                 B25598AD0D00D8B800BB825C /* SVGFilterEffectCg.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; path = SVGFilterEffectCg.mm; sourceTree = "<group>"; };
                 B25598AE0D00D8B900BB825C /* WKArithmeticFilter.cikernel */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text; path = WKArithmeticFilter.cikernel; sourceTree = "<group>"; };
@@ -11963 +11945 @@
                         isa = PBXGroup;
                         children = (
-                                B25598A20D00D8B800BB825C /* SVGFEDiffuseLightingCg.mm */,
-                                B25598A30D00D8B800BB825C /* SVGFEDisplacementMapCg.mm */,
-                                B25598A40D00D8B800BB825C /* SVGFEFloodCg.mm */,
-                                B25598A50D00D8B800BB825C /* SVGFEGaussianBlurCg.mm */,
                                 B25598A60D00D8B800BB825C /* SVGFEHelpersCg.h */,
                                 B25598A70D00D8B800BB825C /* SVGFEHelpersCg.mm */,
-                                B25598A80D00D8B800BB825C /* SVGFEImageCg.mm */,
-                                B25598A90D00D8B800BB825C /* SVGFEMergeCg.mm */,
-                                B25598AA0D00D8B800BB825C /* SVGFEOffsetCg.mm */,
-                                B25598AB0D00D8B800BB825C /* SVGFESpecularLightingCg.mm */,
-                                B25598AC0D00D8B800BB825C /* SVGFETileCg.mm */,
                                 B25598AD0D00D8B800BB825C /* SVGFilterEffectCg.mm */,
                                 B25598AE0D00D8B900BB825C /* WKArithmeticFilter.cikernel */,
@@ -16592 +16565 @@
                                 B255997A0D00D8BA00BB825C /* SVGFEConvolveMatrix.cpp in Sources */,
                                 B255997C0D00D8BA00BB825C /* SVGFEDiffuseLighting.cpp in Sources */,
-                                B255993C0D00D8BA00BB825C /* SVGFEDiffuseLightingCg.mm in Sources */,
                                 B22279D30D00BF220071B782 /* SVGFEDiffuseLightingElement.cpp in Sources */,
                                 B255997E0D00D8BA00BB825C /* SVGFEDisplacementMap.cpp in Sources */,
-                                B255993D0D00D8BA00BB825C /* SVGFEDisplacementMapCg.mm in Sources */,
                                 B22279D60D00BF220071B782 /* SVGFEDisplacementMapElement.cpp in Sources */,
                                 B22279D90D00BF220071B782 /* SVGFEDistantLightElement.cpp in Sources */,
                                 B25599800D00D8BA00BB825C /* SVGFEFlood.cpp in Sources */,
-                                B255993E0D00D8BA00BB825C /* SVGFEFloodCg.mm in Sources */,
                                 B22279DC0D00BF220071B782 /* SVGFEFloodElement.cpp in Sources */,
                                 B22279DF0D00BF220071B782 /* SVGFEFuncAElement.cpp in Sources */,
@@ -16606 +16576 @@
                                 B22279E80D00BF220071B782 /* SVGFEFuncRElement.cpp in Sources */,
                                 B25599820D00D8BA00BB825C /* SVGFEGaussianBlur.cpp in Sources */,
-                                B255993F0D00D8BA00BB825C /* SVGFEGaussianBlurCg.mm in Sources */,
                                 B22279EB0D00BF220071B782 /* SVGFEGaussianBlurElement.cpp in Sources */,
                                 B25599410D00D8BA00BB825C /* SVGFEHelpersCg.mm in Sources */,
                                 B25599840D00D8BA00BB825C /* SVGFEImage.cpp in Sources */,
-                                B25599420D00D8BA00BB825C /* SVGFEImageCg.mm in Sources */,
                                 B22279EE0D00BF220071B782 /* SVGFEImageElement.cpp in Sources */,
                                 B22279F10D00BF220071B782 /* SVGFELightElement.cpp in Sources */,
                                 B25599860D00D8BA00BB825C /* SVGFEMerge.cpp in Sources */,
-                                B25599430D00D8BA00BB825C /* SVGFEMergeCg.mm in Sources */,
                                 B22279F30D00BF220071B782 /* SVGFEMergeElement.cpp in Sources */,
                                 B22279F60D00BF220071B782 /* SVGFEMergeNodeElement.cpp in Sources */,
                                 B25599880D00D8BA00BB825C /* SVGFEMorphology.cpp in Sources */,
                                 B255998A0D00D8BA00BB825C /* SVGFEOffset.cpp in Sources */,
-                                B25599440D00D8BA00BB825C /* SVGFEOffsetCg.mm in Sources */,
                                 B22279F90D00BF220071B782 /* SVGFEOffsetElement.cpp in Sources */,
                                 B22279FC0D00BF220071B782 /* SVGFEPointLightElement.cpp in Sources */,
                                 B255998C0D00D8BA00BB825C /* SVGFESpecularLighting.cpp in Sources */,
-                                B25599450D00D8BA00BB825C /* SVGFESpecularLightingCg.mm in Sources */,
                                 B22279FF0D00BF220071B782 /* SVGFESpecularLightingElement.cpp in Sources */,
                                 B2227A020D00BF220071B782 /* SVGFESpotLightElement.cpp in Sources */,
-                                B25599460D00D8BA00BB825C /* SVGFETileCg.mm in Sources */,
                                 B2227A050D00BF220071B782 /* SVGFETileElement.cpp in Sources */,
                                 B255998F0D00D8BA00BB825C /* SVGFETurbulence.cpp in Sources */,

trunk/WebCore/rendering/SVGRenderTreeAsText.h

@@ -98 +98 @@
 }
 
+template<typename Pointer>
+TextStream& operator<<(TextStream& ts, Pointer* t)
+{
+    ts << reinterpret_cast<intptr_t>(t);
+    return ts;
+}
+
 } // namespace WebCore
 

trunk/WebCore/svg/FilterEffect.cpp

@@ -33 +33 @@
 }
 
+TextStream& FilterEffect::externalRepresentation(TextStream& ts) const
+{
+    return ts;
+}
+
 } // namespace WebCore
 

trunk/WebCore/svg/FilterEffect.h

@@ -22 +22 @@
 
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
+#include "TextStream.h"
+
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefCounted.h>
@@ -35 +37 @@
         virtual void dump() = 0;
         
+        virtual TextStream& externalRepresentation(TextStream&) const;
     protected:
         FilterEffect();

trunk/WebCore/svg/SVGFEBlendElement.cpp

@@ -77 +77 @@
     FilterEffect* input1 = builder->getEffectById(in1());
     FilterEffect* input2 = builder->getEffectById(in2());
-    
+
     if(!input1 || !input2)
         return false;
 
-    RefPtr<FilterEffect> addedEffect = FEBlend::create(input1, input2, static_cast<BlendModeType> (mode()));
-    builder->add(result(), addedEffect.release());
-    
+    builder->add(result(), FEBlend::create(input1, input2, static_cast<BlendModeType> (mode())));
+
     return true;
 }

trunk/WebCore/svg/SVGFEBlendElement.h

@@ -25 +25 @@
 
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
-#include "FilterBuilder.h"
 #include "FEBlend.h"
 #include "SVGFilterPrimitiveStandardAttributes.h"

trunk/WebCore/svg/SVGFEColorMatrixElement.cpp

@@ -78 +78 @@
 {
     FilterEffect* input1 = builder->getEffectById(in1());
-    
+
     if(!input1)
         return false;
-    
+
     Vector<float> _values;
     SVGNumberList* numbers = values();
@@ -90 +90 @@
         _values.append(numbers->getItem(i, ec));
 
-    RefPtr<FilterEffect> addedEffect = FEColorMatrix::create(input1, static_cast<ColorMatrixType> (type()), _values);
-    builder->add(result(), addedEffect.release());
+    builder->add(result(), FEColorMatrix::create(input1, static_cast<ColorMatrixType> (type()), _values));
     
     return true;

trunk/WebCore/svg/SVGFEColorMatrixElement.h

@@ -25 +25 @@
 
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
-#include "FilterBuilder.h"
 #include "FEColorMatrix.h"
 #include "SVGFilterPrimitiveStandardAttributes.h"

trunk/WebCore/svg/SVGFEComponentTransferElement.cpp

@@ -87 +87 @@
     }
     
-    RefPtr<FilterEffect> addedEffect = FEComponentTransfer::create(input1, red, green, blue, alpha);
-    builder->add(result(), addedEffect.release());
+    builder->add(result(), FEComponentTransfer::create(input1, red, green, blue, alpha));
     
     return true;

trunk/WebCore/svg/SVGFEComponentTransferElement.h

@@ -25 +25 @@
 
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
-#include "FilterBuilder.h"
 #include "SVGFilterPrimitiveStandardAttributes.h"
 #include "FEComponentTransfer.h"

trunk/WebCore/svg/SVGFECompositeElement.cpp

@@ -102 +102 @@
     
     RefPtr<FilterEffect> addedEffect = FEComposite::create(input1, input2, static_cast<CompositeOperationType> (_operator()),
-        k1(), k2(), k3(), k4());
+                                        k1(), k2(), k3(), k4());
     builder->add(result(), addedEffect.release());
 

trunk/WebCore/svg/SVGFECompositeElement.h

@@ -25 +25 @@
 
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
-#include "FilterBuilder.h"
 #include "FEComposite.h"
 #include "SVGFilterPrimitiveStandardAttributes.h"

trunk/WebCore/svg/SVGFEDiffuseLightingElement.cpp

@@ -76 +76 @@
 SVGFilterEffect* SVGFEDiffuseLightingElement::filterEffect(SVGResourceFilter* filter) const
 {
-    if (!m_filterEffect) 
-        m_filterEffect = SVGFEDiffuseLighting::create(filter);
+    ASSERT_NOT_REACHED();
+    return 0;
+}
 
-    m_filterEffect->setIn(in1());
-    m_filterEffect->setDiffuseConstant(diffuseConstant());
-    m_filterEffect->setSurfaceScale(surfaceScale());
-    m_filterEffect->setKernelUnitLengthX(kernelUnitLengthX());
-    m_filterEffect->setKernelUnitLengthY(kernelUnitLengthY());
-
-    SVGFEDiffuseLightingElement* nonConstThis = const_cast<SVGFEDiffuseLightingElement*>(this);
-
-    RenderStyle* parentStyle = nonConstThis->styleForRenderer(parent()->renderer());
-    RenderStyle* filterStyle = nonConstThis->resolveStyle(parentStyle);
+bool SVGFEDiffuseLightingElement::build(FilterBuilder* builder)
+{
+    FilterEffect* input1 = builder->getEffectById(in1());
     
-    m_filterEffect->setLightingColor(filterStyle->svgStyle()->lightingColor());
-    setStandardAttributes(m_filterEffect.get());
- 
+    if(!input1)
+        return false;
+    
+    RenderStyle* parentStyle = this->styleForRenderer(parent()->renderer());
+    RenderStyle* filterStyle = this->resolveStyle(parentStyle);
+    Color color = filterStyle->svgStyle()->lightingColor();
+    
     parentStyle->deref(document()->renderArena());
     filterStyle->deref(document()->renderArena());
     
-    updateLights();
-    return m_filterEffect.get();
+    RefPtr<FilterEffect> addedEffect = FEDiffuseLighting::create(input1, color, surfaceScale(), diffuseConstant(), 
+                                            kernelUnitLengthX(), kernelUnitLengthY(), findLights());
+    builder->add(result(), addedEffect.release());
+    
+    return true;
 }
 
-void SVGFEDiffuseLightingElement::updateLights() const
+LightSource* SVGFEDiffuseLightingElement::findLights() const
 {
-    if (!m_filterEffect)
-        return;
-    
     LightSource* light = 0;
     for (Node* n = firstChild(); n; n = n->nextSibling()) {
@@ -116 +114 @@
     }
 
-    m_filterEffect->setLightSource(light);
+    return light;
 }
 

trunk/WebCore/svg/SVGFEDiffuseLightingElement.h

@@ -24 +24 @@
 
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
+#include "SVGFELightElement.h"
 #include "SVGFilterPrimitiveStandardAttributes.h"
 
 namespace WebCore {
-    class SVGFEDiffuseLighting;
+    class FEDiffuseLighting;
     class SVGColor;
 
@@ -38 +39 @@
         virtual void parseMappedAttribute(MappedAttribute*);
         virtual SVGFilterEffect* filterEffect(SVGResourceFilter*) const;
+        bool build(FilterBuilder*);
 
     protected:
@@ -49 +51 @@
         ANIMATED_PROPERTY_DECLARATIONS(SVGFEDiffuseLightingElement, float, KernelUnitLengthY, kernelUnitLengthY)
 
-        mutable RefPtr<SVGFEDiffuseLighting> m_filterEffect;
+        LightSource* findLights() const;
         
-        void updateLights() const;
+        mutable RefPtr<FEDiffuseLighting> m_filterEffect;
     };
 

trunk/WebCore/svg/SVGFEDisplacementMapElement.cpp

@@ -30 +30 @@
 SVGFEDisplacementMapElement::SVGFEDisplacementMapElement(const QualifiedName& tagName, Document* doc)
     : SVGFilterPrimitiveStandardAttributes(tagName, doc)
-    , m_xChannelSelector(SVG_CHANNEL_A)
-    , m_yChannelSelector(SVG_CHANNEL_A)
+    , m_xChannelSelector(CHANNEL_A)
+    , m_yChannelSelector(CHANNEL_A)
     , m_scale(0.0f)
     , m_filterEffect(0)
@@ -47 +47 @@
 ANIMATED_PROPERTY_DEFINITIONS(SVGFEDisplacementMapElement, float, Scale, scale, SVGNames::scaleAttr)
 
-SVGChannelSelectorType SVGFEDisplacementMapElement::stringToChannel(const String& key)
+ChannelSelectorType SVGFEDisplacementMapElement::stringToChannel(const String& key)
 {
     if (key == "R")
-        return SVG_CHANNEL_R;
+        return CHANNEL_R;
     else if (key == "G")
-        return SVG_CHANNEL_G;
+        return CHANNEL_G;
     else if (key == "B")
-        return SVG_CHANNEL_B;
+        return CHANNEL_B;
     else if (key == "A")
-        return SVG_CHANNEL_A;
+        return CHANNEL_A;
 
-    return SVG_CHANNEL_UNKNOWN;
+    return CHANNEL_UNKNOWN;
 }
 
@@ -78 +78 @@
 }
 
-SVGFEDisplacementMap* SVGFEDisplacementMapElement::filterEffect(SVGResourceFilter* filter) const
+SVGFilterEffect* SVGFEDisplacementMapElement::filterEffect(SVGResourceFilter* filter) const
 {
-    if (!m_filterEffect)
-        m_filterEffect = SVGFEDisplacementMap::create(filter);
+    ASSERT_NOT_REACHED();
+    return 0;
+}
 
-    m_filterEffect->setXChannelSelector((SVGChannelSelectorType) xChannelSelector());
-    m_filterEffect->setYChannelSelector((SVGChannelSelectorType) yChannelSelector());
-    m_filterEffect->setIn(in1());
-    m_filterEffect->setIn2(in2());
-    m_filterEffect->setScale(scale());
-
-    setStandardAttributes(m_filterEffect.get());
-    return m_filterEffect.get();
+bool SVGFEDisplacementMapElement::build(FilterBuilder* builder)
+{
+    FilterEffect* input1 = builder->getEffectById(in1());
+    FilterEffect* input2 = builder->getEffectById(in2());
+    
+    if(!input1 || !input2)
+        return false;
+        
+    
+    RefPtr<FilterEffect> addedEffect = FEDisplacementMap::create(input1, input2, static_cast<ChannelSelectorType> (xChannelSelector()), 
+                                        static_cast<ChannelSelectorType> (yChannelSelector()), scale());
+    builder->add(result(), addedEffect.release());
+    
+    return true;
 }
 

trunk/WebCore/svg/SVGFEDisplacementMapElement.h

@@ -32 +32 @@
         virtual ~SVGFEDisplacementMapElement();
         
-        static SVGChannelSelectorType stringToChannel(const String&);
+        static ChannelSelectorType stringToChannel(const String&);
         
         virtual void parseMappedAttribute(MappedAttribute*);
-        virtual SVGFEDisplacementMap* filterEffect(SVGResourceFilter*) const;
+        virtual SVGFilterEffect* filterEffect(SVGResourceFilter*) const;
+        bool build(FilterBuilder*);
         
     protected:
@@ -47 +48 @@
         ANIMATED_PROPERTY_DECLARATIONS(SVGFEDisplacementMapElement, float, Scale, scale)
 
-        mutable RefPtr<SVGFEDisplacementMap> m_filterEffect;
+        mutable RefPtr<FEDisplacementMap> m_filterEffect;
     };
 

trunk/WebCore/svg/SVGFEFloodElement.cpp

@@ -49 +49 @@
 }
 
-SVGFEFlood* SVGFEFloodElement::filterEffect(SVGResourceFilter* filter) const
+SVGFilterEffect* SVGFEFloodElement::filterEffect(SVGResourceFilter* filter) const
 {
-    if (!m_filterEffect)
-        m_filterEffect = SVGFEFlood::create(filter);
-    
-    setStandardAttributes(m_filterEffect.get());
+    ASSERT_NOT_REACHED();
+    return 0;
+}
 
-    SVGFEFloodElement* nonConstThis = const_cast<SVGFEFloodElement*>(this);
+bool SVGFEFloodElement::build(FilterBuilder* builder)
+{
+    RenderStyle* parentStyle = this->styleForRenderer(parent()->renderer());
+    RenderStyle* filterStyle = this->resolveStyle(parentStyle);
 
-    RenderStyle* parentStyle = nonConstThis->styleForRenderer(parent()->renderer());
-    RenderStyle* filterStyle = nonConstThis->resolveStyle(parentStyle);
-    
-    m_filterEffect->setFloodColor(filterStyle->svgStyle()->floodColor());
-    m_filterEffect->setFloodOpacity(filterStyle->svgStyle()->floodOpacity());
-    
+    Color color = filterStyle->svgStyle()->floodColor();
+    float opacity = filterStyle->svgStyle()->floodOpacity();
+
     parentStyle->deref(document()->renderArena());
     filterStyle->deref(document()->renderArena());
+
+    builder->add(result(), FEFlood::create(color, opacity));
     
-    return m_filterEffect.get();
+    return true;
 }
 

trunk/WebCore/svg/SVGFEFloodElement.h

@@ -37 +37 @@
 
         virtual void parseMappedAttribute(MappedAttribute*);
-        virtual SVGFEFlood* filterEffect(SVGResourceFilter*) const;
+        virtual SVGFilterEffect* filterEffect(SVGResourceFilter*) const;
+        bool build(FilterBuilder*);
 
     protected:
@@ -43 +44 @@
 
     private:
-        mutable RefPtr<SVGFEFlood> m_filterEffect;
+        mutable RefPtr<FEFlood> m_filterEffect;
     };
 

trunk/WebCore/svg/SVGFEGaussianBlurElement.cpp

@@ -67 +67 @@
 }
 
-SVGFEGaussianBlur* SVGFEGaussianBlurElement::filterEffect(SVGResourceFilter* filter) const
+SVGFilterEffect* SVGFEGaussianBlurElement::filterEffect(SVGResourceFilter* filter) const
 {
-    if (!m_filterEffect)
-        m_filterEffect = SVGFEGaussianBlur::create(filter);
-    
-    m_filterEffect->setIn(in1());
-    m_filterEffect->setStdDeviationX(stdDeviationX());
-    m_filterEffect->setStdDeviationY(stdDeviationY());
+    ASSERT_NOT_REACHED();
+    return 0;
+}
 
-    setStandardAttributes(m_filterEffect.get()); 
-    return m_filterEffect.get();
+bool SVGFEGaussianBlurElement::build(FilterBuilder* builder)
+{
+    FilterEffect* input1 = builder->getEffectById(in1());
+
+    if(!input1)
+        return false;
+
+    builder->add(result(), FEGaussianBlur::create(input1, stdDeviationX(), stdDeviationY()));
+
+    return true;
 }
 

trunk/WebCore/svg/SVGFEGaussianBlurElement.h

@@ -40 +40 @@
 
         virtual void parseMappedAttribute(MappedAttribute*);
-        virtual SVGFEGaussianBlur* filterEffect(SVGResourceFilter*) const;
+        virtual SVGFilterEffect* filterEffect(SVGResourceFilter*) const;
+        bool build(FilterBuilder*);
 
     protected:
@@ -50 +51 @@
         ANIMATED_PROPERTY_DECLARATIONS(SVGFEGaussianBlurElement, float, StdDeviationY, stdDeviationY)
 
-        mutable RefPtr<SVGFEGaussianBlur> m_filterEffect;
+        mutable RefPtr<FEGaussianBlur> m_filterEffect;
     };
 

trunk/WebCore/svg/SVGFEImageElement.cpp

@@ -90 +90 @@
 }
 
-SVGFEImage* SVGFEImageElement::filterEffect(SVGResourceFilter* filter) const
+SVGFilterEffect* SVGFEImageElement::filterEffect(SVGResourceFilter* filter) const
 {
-    if (!m_filterEffect)
-        m_filterEffect = SVGFEImage::create(filter);
-    
-    // The resource may already be loaded!
-    if (m_cachedImage)
-        m_filterEffect->setCachedImage(m_cachedImage);
+    ASSERT_NOT_REACHED();
+    return 0;
+}
 
-    setStandardAttributes(m_filterEffect.get());
-    return m_filterEffect.get();
+bool SVGFEImageElement::build(FilterBuilder* builder)
+{
+    if(!m_cachedImage)
+        return false;
+
+    builder->add(result(), FEImage::create(m_cachedImage));
+
+    return true;
 }
 

trunk/WebCore/svg/SVGFEImageElement.h

@@ -48 +48 @@
 
         virtual void getSubresourceAttributeStrings(Vector<String>&) const;
+        bool build(FilterBuilder*);
 
     protected:
-        virtual SVGFEImage* filterEffect(SVGResourceFilter*) const;
+        virtual SVGFilterEffect* filterEffect(SVGResourceFilter*) const;
 
     protected:
@@ -62 +63 @@
 
         CachedImage* m_cachedImage;
-        mutable RefPtr<SVGFEImage> m_filterEffect;
+        mutable RefPtr<FEImage> m_filterEffect;
     };
 

trunk/WebCore/svg/SVGFEMergeElement.cpp

@@ -41 +41 @@
 }
 
-SVGFEMerge* SVGFEMergeElement::filterEffect(SVGResourceFilter* filter) const
+SVGFilterEffect* SVGFEMergeElement::filterEffect(SVGResourceFilter* filter) const
 {
-    if (!m_filterEffect)
-        m_filterEffect = SVGFEMerge::create(filter);
-        
-    setStandardAttributes(m_filterEffect.get());
+    ASSERT_NOT_REACHED();
+    return 0;
+}
 
-    Vector<String> mergeInputs;
+bool SVGFEMergeElement::build(FilterBuilder* builder)
+{
+    Vector<FilterEffect*> mergeInputs;
     for (Node* n = firstChild(); n != 0; n = n->nextSibling()) {
-        if (n->hasTagName(SVGNames::feMergeNodeTag))
-            mergeInputs.append(static_cast<SVGFEMergeNodeElement*>(n)->in1());
+        if (n->hasTagName(SVGNames::feMergeNodeTag)) {
+            FilterEffect* mergeEffect = builder->getEffectById(static_cast<SVGFEMergeNodeElement*>(n)->in1());
+            mergeInputs.append(mergeEffect);
+        }
     }
 
-    m_filterEffect->setMergeInputs(mergeInputs);
-    return m_filterEffect.get();
+    if(mergeInputs.isEmpty())
+        return false;
+
+    builder->add(result(), FEMerge::create(mergeInputs));
+
+    return true;
 }
 

trunk/WebCore/svg/SVGFEMergeElement.h

@@ -36 +36 @@
         virtual ~SVGFEMergeElement();
 
-        virtual SVGFEMerge* filterEffect(SVGResourceFilter*) const;
+        virtual SVGFilterEffect* filterEffect(SVGResourceFilter*) const;
+        bool build(FilterBuilder*);
 
     protected:
@@ -42 +43 @@
 
     private:
-        mutable RefPtr<SVGFEMerge> m_filterEffect;
+        mutable RefPtr<FEMerge> m_filterEffect;
     };
 

trunk/WebCore/svg/SVGFEOffsetElement.cpp

@@ -60 +60 @@
 }
 
-SVGFEOffset* SVGFEOffsetElement::filterEffect(SVGResourceFilter* filter) const
+SVGFilterEffect* SVGFEOffsetElement::filterEffect(SVGResourceFilter* filter) const
 {
-    if (!m_filterEffect)
-        m_filterEffect = SVGFEOffset::create(filter);
-    
-    m_filterEffect->setIn(in1());
-    m_filterEffect->setDx(dx());
-    m_filterEffect->setDy(dy());
+    ASSERT_NOT_REACHED();
+    return 0;
+}
 
-    setStandardAttributes(m_filterEffect.get()); 
-    return m_filterEffect.get();
+bool SVGFEOffsetElement::build(FilterBuilder* builder)
+{
+    FilterEffect* input1 = builder->getEffectById(in1());
+
+    if(!input1)
+        return false;
+
+    builder->add(result(), FEOffset::create(input1, dx(), dy()));
+
+    return true;
 }
 

trunk/WebCore/svg/SVGFEOffsetElement.h

@@ -38 +38 @@
 
         virtual void parseMappedAttribute(MappedAttribute*);
-        virtual SVGFEOffset* filterEffect(SVGResourceFilter*) const;
+        virtual SVGFilterEffect* filterEffect(SVGResourceFilter*) const;
+        bool build(FilterBuilder*);
 
     protected:
@@ -48 +49 @@
         ANIMATED_PROPERTY_DECLARATIONS(SVGFEOffsetElement, float, Dy, dy)
 
-        mutable RefPtr<SVGFEOffset> m_filterEffect;
+        mutable RefPtr<FEOffset> m_filterEffect;
     };
 

trunk/WebCore/svg/SVGFESpecularLightingElement.cpp

@@ -77 +77 @@
 }
 
-SVGFESpecularLighting* SVGFESpecularLightingElement::filterEffect(SVGResourceFilter* filter) const
+SVGFilterEffect* SVGFESpecularLightingElement::filterEffect(SVGResourceFilter* filter) const
 {
-    if (!m_filterEffect) 
-        m_filterEffect = SVGFESpecularLighting::create(filter);
-
-    m_filterEffect->setIn(in1());
-    m_filterEffect->setSpecularConstant((specularConstant()));
-    m_filterEffect->setSpecularExponent((specularExponent()));
-    m_filterEffect->setSurfaceScale((surfaceScale()));
-    m_filterEffect->setKernelUnitLengthX((kernelUnitLengthX()));
-    m_filterEffect->setKernelUnitLengthY((kernelUnitLengthY()));
-
-    SVGFESpecularLightingElement* nonConstThis = const_cast<SVGFESpecularLightingElement*>(this);
-
-    RenderStyle* parentStyle = nonConstThis->styleForRenderer(parent()->renderer());    
-    RenderStyle* filterStyle = nonConstThis->resolveStyle(parentStyle);
-    
-    m_filterEffect->setLightingColor(filterStyle->svgStyle()->lightingColor());
-    
-    parentStyle->deref(document()->renderArena());
-    filterStyle->deref(document()->renderArena());
-
-    setStandardAttributes(m_filterEffect.get());
-
-    updateLights();
-    return m_filterEffect.get();
+    ASSERT_NOT_REACHED();
+    return 0;
 }
 
-void SVGFESpecularLightingElement::updateLights() const
+LightSource* SVGFESpecularLightingElement::findLights() const
 {
-    if (!m_filterEffect)
-        return;
-
-    LightSource* light = 0;    
+    LightSource* light = 0;
     for (Node* n = firstChild(); n; n = n->nextSibling()) {
-        if (n->hasTagName(SVGNames::feDistantLightTag) || 
+        if (n->hasTagName(SVGNames::feDistantLightTag) ||
             n->hasTagName(SVGNames::fePointLightTag) ||
             n->hasTagName(SVGNames::feSpotLightTag)) {
@@ -121 +96 @@
     }
 
-    m_filterEffect->setLightSource(light);
+    return light;
+}
+
+bool SVGFESpecularLightingElement::build(FilterBuilder* builder)
+{
+    FilterEffect* input1 = builder->getEffectById(in1());
+    
+    if(!input1)
+        return false;
+        
+    RenderStyle* parentStyle = this->styleForRenderer(parent()->renderer());    
+    RenderStyle* filterStyle = this->resolveStyle(parentStyle);
+    
+    Color color = filterStyle->svgStyle()->lightingColor();
+    
+    parentStyle->deref(document()->renderArena());
+    filterStyle->deref(document()->renderArena());
+    
+    RefPtr<FilterEffect> addedEffect = FESpecularLighting::create(input1, color, surfaceScale(), specularConstant(), 
+                                        specularExponent(), kernelUnitLengthX(), kernelUnitLengthY(), findLights());
+    builder->add(result(), addedEffect.release());
+
+    return true;
 }
 

trunk/WebCore/svg/SVGFESpecularLightingElement.h

@@ -38 +38 @@
         
         virtual void parseMappedAttribute(MappedAttribute*);
-        virtual SVGFESpecularLighting* filterEffect(SVGResourceFilter*) const;
+        virtual SVGFilterEffect* filterEffect(SVGResourceFilter*) const;
+        bool build(FilterBuilder*);
 
     protected:
@@ -51 +52 @@
         ANIMATED_PROPERTY_DECLARATIONS(SVGFESpecularLightingElement, float, KernelUnitLengthY, kernelUnitLengthY)
 
-        mutable RefPtr<SVGFESpecularLighting> m_filterEffect;
+        mutable RefPtr<FESpecularLighting> m_filterEffect;
         
-        void updateLights() const;
+        LightSource* findLights() const;
     };
 

trunk/WebCore/svg/SVGFETileElement.cpp

@@ -53 +53 @@
 }
 
-SVGFETile* SVGFETileElement::filterEffect(SVGResourceFilter* filter) const
+SVGFilterEffect* SVGFETileElement::filterEffect(SVGResourceFilter* filter) const
 {
-    if (!m_filterEffect)
-        m_filterEffect = SVGFETile::create(filter);
+   ASSERT_NOT_REACHED();
+   return 0;
+}
 
-    m_filterEffect->setIn(in1());
+bool SVGFETileElement::build(FilterBuilder* builder)
+{
+    FilterEffect* input1 = builder->getEffectById(in1());
 
-    setStandardAttributes(m_filterEffect.get());
-    return m_filterEffect.get();
+    if(!input1)
+        return false;
+
+    builder->add(result(), FETile::create(input1));
+    
+    return true;
 }
 

trunk/WebCore/svg/SVGFETileElement.h

@@ -37 +37 @@
 
         virtual void parseMappedAttribute(MappedAttribute*);
-        virtual SVGFETile* filterEffect(SVGResourceFilter*) const;
+        virtual SVGFilterEffect* filterEffect(SVGResourceFilter*) const;
+        bool build(FilterBuilder*);
 
     protected:
@@ -45 +46 @@
         ANIMATED_PROPERTY_DECLARATIONS(SVGFETileElement, String, In1, in1)
 
-        mutable RefPtr<SVGFETile> m_filterEffect;
+        mutable RefPtr<FETile> m_filterEffect;
     };
 

trunk/WebCore/svg/SVGFETurbulenceElement.cpp

@@ -38 +38 @@
     , m_seed(0.0f)
     , m_stitchTiles(SVG_STITCHTYPE_NOSTITCH)
-    , m_type(SVG_TURBULENCE_TYPE_TURBULENCE)
+    , m_type(FETURBULENCE_TYPE_TURBULENCE)
     , m_filterEffect(0)
 {
@@ -59 +59 @@
     if (attr->name() == SVGNames::typeAttr) {
         if (value == "fractalNoise")
-            setTypeBaseValue(SVG_TURBULENCE_TYPE_FRACTALNOISE);
+            setTypeBaseValue(FETURBULENCE_TYPE_FRACTALNOISE);
         else if (value == "turbulence")
-            setTypeBaseValue(SVG_TURBULENCE_TYPE_TURBULENCE);
+            setTypeBaseValue(FETURBULENCE_TYPE_TURBULENCE);
     } else if (attr->name() == SVGNames::stitchTilesAttr) {
         if (value == "stitch")
@@ -81 +81 @@
 }
 
-SVGFETurbulence* SVGFETurbulenceElement::filterEffect(SVGResourceFilter* filter) const
+SVGFilterEffect* SVGFETurbulenceElement::filterEffect(SVGResourceFilter* filter) const
 {
-    
-    if (!m_filterEffect)
-        m_filterEffect = SVGFETurbulence::create(filter);
-    
-    m_filterEffect->setType((SVGTurbulanceType) type());
-    m_filterEffect->setBaseFrequencyX(baseFrequencyX());
-    m_filterEffect->setBaseFrequencyY(baseFrequencyY());
-    m_filterEffect->setNumOctaves(numOctaves());
-    m_filterEffect->setSeed(seed());
-    m_filterEffect->setStitchTiles(stitchTiles() == SVG_STITCHTYPE_STITCH);
+    ASSERT_NOT_REACHED();
+    return 0;
+}
 
-    setStandardAttributes(m_filterEffect.get()); 
-    return m_filterEffect.get();
+bool SVGFETurbulenceElement::build(FilterBuilder* builder)
+{
+    RefPtr<FilterEffect> addedEffect = FETurbulence::create(static_cast<TurbulanceType> (type()), baseFrequencyX(), 
+                                        baseFrequencyY(), numOctaves(), seed(), stitchTiles() == SVG_STITCHTYPE_STITCH);
+    builder->add(result(), addedEffect.release());
+
+    return true;
 }
 

trunk/WebCore/svg/SVGFETurbulenceElement.h

@@ -43 +43 @@
 
         virtual void parseMappedAttribute(MappedAttribute*);
-        virtual SVGFETurbulence* filterEffect(SVGResourceFilter*) const;
+        virtual SVGFilterEffect* filterEffect(SVGResourceFilter*) const;
+        bool build(FilterBuilder*);
 
     protected:
@@ -56 +57 @@
         ANIMATED_PROPERTY_DECLARATIONS(SVGFETurbulenceElement, int, Type, type)
 
-        mutable RefPtr<SVGFETurbulence> m_filterEffect;
+        mutable RefPtr<FETurbulence> m_filterEffect;
     };
 

trunk/WebCore/svg/SVGFilterPrimitiveStandardAttributes.h

@@ -25 +25 @@
 
 #if ENABLE(SVG)
+#include "FilterBuilder.h"
 #include "SVGStyledElement.h"
 

trunk/WebCore/svg/graphics/filters/SVGFEConvolveMatrix.cpp

@@ -23 +23 @@
 
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
+#include "SVGFEConvolveMatrix.h"
 #include "SVGRenderTreeAsText.h"
-#include "SVGFEConvolveMatrix.h"
 
 namespace WebCore {
 
-SVGFEConvolveMatrix::SVGFEConvolveMatrix(SVGResourceFilter* filter)
-    : SVGFilterEffect(filter)
-    , m_kernelSize()
-    , m_divisor(0.0f)
-    , m_bias(0.0f)
-    , m_targetOffset()
-    , m_edgeMode(SVG_EDGEMODE_UNKNOWN)
-    , m_kernelUnitLength()
-    , m_preserveAlpha(false)
+FEConvolveMatrix::FEConvolveMatrix(FilterEffect* in, FilterEffect* in2, const FloatSize& kernelSize, 
+    const float& divisor, const float& bias, const FloatSize& targetOffset, EdgeModeType edgeMode,
+    const FloatPoint& kernelUnitLength, bool preserveAlpha, const Vector<float>& kernelMatrix)
+    : FilterEffect()
+    , m_in(in)
+    , m_in2(in2)
+    , m_kernelSize(kernelSize)
+    , m_divisor(divisor)
+    , m_bias(bias)
+    , m_targetOffset(targetOffset)
+    , m_edgeMode(edgeMode)
+    , m_kernelUnitLength(kernelUnitLength)
+    , m_preserveAlpha(preserveAlpha)
+    , m_kernelMatrix(kernelMatrix)
 {
 }
 
-PassRefPtr<SVGFEConvolveMatrix> SVGFEConvolveMatrix::create(SVGResourceFilter* filter)
+PassRefPtr<FEConvolveMatrix> FEConvolveMatrix::create(FilterEffect* in, FilterEffect* in2, const FloatSize& kernelSize, 
+    const float& divisor, const float& bias, const FloatSize& targetOffset, EdgeModeType edgeMode, 
+    const FloatPoint& kernelUnitLength, bool preserveAlpha, const Vector<float>& kernelMatrix)
 {
-    return adoptRef(new SVGFEConvolveMatrix(filter));
+    return adoptRef(new FEConvolveMatrix(in, in2, kernelSize, divisor, bias, targetOffset, edgeMode, kernelUnitLength,
+        preserveAlpha, kernelMatrix));
 }
 
-FloatSize SVGFEConvolveMatrix::kernelSize() const
+
+FloatSize FEConvolveMatrix::kernelSize() const
 {
     return m_kernelSize;
 }
 
-void SVGFEConvolveMatrix::setKernelSize(FloatSize kernelSize)
+void FEConvolveMatrix::setKernelSize(FloatSize kernelSize)
 {
     m_kernelSize = kernelSize; 
 }
 
-const Vector<float>& SVGFEConvolveMatrix::kernel() const
+const Vector<float>& FEConvolveMatrix::kernel() const
 {
     return m_kernelMatrix; 
 }
 
-void SVGFEConvolveMatrix::setKernel(const Vector<float>& kernel)
+void FEConvolveMatrix::setKernel(const Vector<float>& kernel)
 {
     m_kernelMatrix = kernel; 
 }
 
-float SVGFEConvolveMatrix::divisor() const
+float FEConvolveMatrix::divisor() const
 {
     return m_divisor; 
 }
 
-void SVGFEConvolveMatrix::setDivisor(float divisor)
+void FEConvolveMatrix::setDivisor(float divisor)
 {
     m_divisor = divisor; 
 }
 
-float SVGFEConvolveMatrix::bias() const
+float FEConvolveMatrix::bias() const
 {
     return m_bias; 
 }
 
-void SVGFEConvolveMatrix::setBias(float bias)
+void FEConvolveMatrix::setBias(float bias)
 {
     m_bias = bias; 
 }
 
-FloatSize SVGFEConvolveMatrix::targetOffset() const
+FloatSize FEConvolveMatrix::targetOffset() const
 {
     return m_targetOffset; 
 }
 
-void SVGFEConvolveMatrix::setTargetOffset(FloatSize targetOffset)
+void FEConvolveMatrix::setTargetOffset(FloatSize targetOffset)
 {
     m_targetOffset = targetOffset; 
 }
 
-SVGEdgeModeType SVGFEConvolveMatrix::edgeMode() const
+EdgeModeType FEConvolveMatrix::edgeMode() const
 {
     return m_edgeMode; 
 }
 
-void SVGFEConvolveMatrix::setEdgeMode(SVGEdgeModeType edgeMode)
+void FEConvolveMatrix::setEdgeMode(EdgeModeType edgeMode)
 {
     m_edgeMode = edgeMode; 
 }
 
-FloatPoint SVGFEConvolveMatrix::kernelUnitLength() const
+FloatPoint FEConvolveMatrix::kernelUnitLength() const
 {
     return m_kernelUnitLength; 
 }
 
-void SVGFEConvolveMatrix::setKernelUnitLength(FloatPoint kernelUnitLength)
+void FEConvolveMatrix::setKernelUnitLength(FloatPoint kernelUnitLength)
 {
     m_kernelUnitLength = kernelUnitLength; 
 }
 
-bool SVGFEConvolveMatrix::preserveAlpha() const
+bool FEConvolveMatrix::preserveAlpha() const
 {
     return m_preserveAlpha; 
 }
 
-void SVGFEConvolveMatrix::setPreserveAlpha(bool preserveAlpha)
+void FEConvolveMatrix::setPreserveAlpha(bool preserveAlpha)
 {
     m_preserveAlpha = preserveAlpha; 
 }
 
-static TextStream& operator<<(TextStream& ts, SVGEdgeModeType t)
+void FEConvolveMatrix::apply()
+{
+}
+
+void FEConvolveMatrix::dump()
+{
+}
+
+static TextStream& operator<<(TextStream& ts, EdgeModeType t)
 {
     switch (t)
     {
-        case SVG_EDGEMODE_UNKNOWN:
+        case EDGEMODE_UNKNOWN:
             ts << "UNKNOWN";break;
-        case SVG_EDGEMODE_DUPLICATE:
+        case EDGEMODE_DUPLICATE:
             ts << "DUPLICATE";break;
-        case SVG_EDGEMODE_WRAP:
+        case EDGEMODE_WRAP:
             ts << "WRAP"; break;
-        case SVG_EDGEMODE_NONE:
+        case EDGEMODE_NONE:
             ts << "NONE"; break;
     }
@@ -141 +158 @@
 }
 
-TextStream& SVGFEConvolveMatrix::externalRepresentation(TextStream& ts) const
+TextStream& FEConvolveMatrix::externalRepresentation(TextStream& ts) const
 {
     ts << "[type=CONVOLVE-MATRIX] ";
-    SVGFilterEffect::externalRepresentation(ts);
+    FilterEffect::externalRepresentation(ts);
     ts << " [order " << m_kernelSize << "]"
-        << " [kernel matrix=" << m_kernelMatrix  << "]"
-        << " [divisor=" << m_divisor << "]"
-        << " [bias=" << m_bias << "]"
-        << " [target " << m_targetOffset << "]"
-        << " [edge mode=" << m_edgeMode << "]"
-        << " [kernel unit length " << m_kernelUnitLength << "]"
-        << " [preserve alpha=" << m_preserveAlpha << "]";
+       << " [kernel matrix=" << m_kernelMatrix  << "]"
+       << " [divisor=" << m_divisor << "]"
+       << " [bias=" << m_bias << "]"
+       << " [target " << m_targetOffset << "]"
+       << " [edge mode=" << m_edgeMode << "]"
+       << " [kernel unit length " << m_kernelUnitLength << "]"
+       << " [preserve alpha=" << m_preserveAlpha << "]";
     return ts;
 }

trunk/WebCore/svg/graphics/filters/SVGFEConvolveMatrix.h

@@ -24 +24 @@
 
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
-#include "SVGFilterEffect.h"
+#include "FilterEffect.h"
+#include "FloatPoint.h"
+#include "FloatSize.h"
+
+#include <wtf/Vector.h>
 
 namespace WebCore {
 
-enum SVGEdgeModeType {
-    SVG_EDGEMODE_UNKNOWN   = 0,
-    SVG_EDGEMODE_DUPLICATE = 1,
-    SVG_EDGEMODE_WRAP      = 2,
-    SVG_EDGEMODE_NONE      = 3
-};
+    enum EdgeModeType {
+        EDGEMODE_UNKNOWN   = 0,
+        EDGEMODE_DUPLICATE = 1,
+        EDGEMODE_WRAP      = 2,
+        EDGEMODE_NONE      = 3
+    };
 
-class SVGFEConvolveMatrix : public SVGFilterEffect {
-public:
-    static PassRefPtr<SVGFEConvolveMatrix> create(SVGResourceFilter*);
+    class FEConvolveMatrix : public FilterEffect {
+    public:
+        static PassRefPtr<FEConvolveMatrix> create(FilterEffect*, FilterEffect*, const FloatSize&, 
+                const float&, const float&, const FloatSize&, EdgeModeType, const FloatPoint&,
+                bool, const Vector<float>&);
 
-    FloatSize kernelSize() const;
-    void setKernelSize(FloatSize);
+        FloatSize kernelSize() const;
+        void setKernelSize(FloatSize);
 
-    const Vector<float>& kernel() const;
-    void setKernel(const Vector<float>&);
+        const Vector<float>& kernel() const;
+        void setKernel(const Vector<float>&);
 
-    float divisor() const;
-    void setDivisor(float);
+        float divisor() const;
+        void setDivisor(float);
 
-    float bias() const;
-    void setBias(float);
+        float bias() const;
+        void setBias(float);
 
-    FloatSize targetOffset() const;
-    void setTargetOffset(FloatSize);
+        FloatSize targetOffset() const;
+        void setTargetOffset(FloatSize);
 
-    SVGEdgeModeType edgeMode() const;
-    void setEdgeMode(SVGEdgeModeType);
+        EdgeModeType edgeMode() const;
+        void setEdgeMode(EdgeModeType);
 
-    FloatPoint kernelUnitLength() const;
-    void setKernelUnitLength(FloatPoint);
+        FloatPoint kernelUnitLength() const;
+        void setKernelUnitLength(FloatPoint);
 
-    bool preserveAlpha() const;
-    void setPreserveAlpha(bool);
+        bool preserveAlpha() const;
+        void setPreserveAlpha(bool);
 
-    virtual TextStream& externalRepresentation(TextStream&) const;
+        virtual void apply();
+        virtual void dump();
+        TextStream& externalRepresentation(TextStream& ts) const;
 
-private:
-    SVGFEConvolveMatrix(SVGResourceFilter*);
+    private:
+        FEConvolveMatrix(FilterEffect*, FilterEffect*, const FloatSize&, const float&, const float&,
+                const FloatSize&, EdgeModeType, const FloatPoint&, bool, const Vector<float>&);
 
-    FloatSize m_kernelSize;
-    float m_divisor;
-    float m_bias;
-    FloatSize m_targetOffset;
-    SVGEdgeModeType m_edgeMode;
-    FloatPoint m_kernelUnitLength;
-    bool m_preserveAlpha;
-    Vector<float> m_kernelMatrix; // maybe should be a real matrix?
-};
+        RefPtr<FilterEffect> m_in;
+        RefPtr<FilterEffect> m_in2;
+        FloatSize m_kernelSize;
+        float m_divisor;
+        float m_bias;
+        FloatSize m_targetOffset;
+        EdgeModeType m_edgeMode;
+        FloatPoint m_kernelUnitLength;
+        bool m_preserveAlpha;
+        Vector<float> m_kernelMatrix;
+    };
 
 } // namespace WebCore

trunk/WebCore/svg/graphics/filters/SVGFEDiffuseLighting.cpp

@@ -25 +25 @@
 #include "SVGLightSource.h"
 #include "SVGFEDiffuseLighting.h"
-#include "TextStream.h"
+#include "SVGRenderTreeAsText.h"
 
 namespace WebCore {
 
-SVGFEDiffuseLighting::SVGFEDiffuseLighting(SVGResourceFilter* filter)
-    : SVGFilterEffect(filter)
-    , m_lightingColor()
-    , m_surfaceScale(0.0f)
-    , m_diffuseConstant(0.0f)
-    , m_kernelUnitLengthX(0.0f)
-    , m_kernelUnitLengthY(0.0f)
-    , m_lightSource(0)
+FEDiffuseLighting::FEDiffuseLighting(FilterEffect* in , const Color& lightingColor, const float& surfaceScale,
+    const float& diffuseConstant, const float& kernelUnitLengthX, const float& kernelUnitLengthY, LightSource* lightSource)
+    : FilterEffect()
+    , m_in(in)
+    , m_lightingColor(lightingColor)
+    , m_surfaceScale(surfaceScale)
+    , m_diffuseConstant(diffuseConstant)
+    , m_kernelUnitLengthX(kernelUnitLengthX)
+    , m_kernelUnitLengthY(kernelUnitLengthY)
+    , m_lightSource(lightSource)
 {
 }
 
-PassRefPtr<SVGFEDiffuseLighting> SVGFEDiffuseLighting::create(SVGResourceFilter* filter)
+PassRefPtr<FEDiffuseLighting> FEDiffuseLighting::create(FilterEffect* in , const Color& lightingColor,
+    const float& surfaceScale, const float& diffuseConstant, const float& kernelUnitLengthX,
+    const float& kernelUnitLengthY, LightSource* lightSource)
 {
-    return adoptRef(new SVGFEDiffuseLighting(filter));
+    return adoptRef(new FEDiffuseLighting(in, lightingColor, surfaceScale, diffuseConstant, kernelUnitLengthX, kernelUnitLengthY, lightSource));
 }
 
-SVGFEDiffuseLighting::~SVGFEDiffuseLighting()
+FEDiffuseLighting::~FEDiffuseLighting()
 {
 }
 
-Color SVGFEDiffuseLighting::lightingColor() const
+Color FEDiffuseLighting::lightingColor() const
 {
     return m_lightingColor;
 }
 
-void SVGFEDiffuseLighting::setLightingColor(const Color& lightingColor)
+void FEDiffuseLighting::setLightingColor(const Color& lightingColor)
 {
     m_lightingColor = lightingColor;
 }
 
-float SVGFEDiffuseLighting::surfaceScale() const 
+float FEDiffuseLighting::surfaceScale() const 
 {
     return m_surfaceScale;
 }
 
-void SVGFEDiffuseLighting::setSurfaceScale(float surfaceScale)
+void FEDiffuseLighting::setSurfaceScale(float surfaceScale)
 {
     m_surfaceScale = surfaceScale;
 }
 
-float SVGFEDiffuseLighting::diffuseConstant() const
+float FEDiffuseLighting::diffuseConstant() const
 {
     return m_diffuseConstant;
 }
 
-void SVGFEDiffuseLighting::setDiffuseConstant(float diffuseConstant)
+void FEDiffuseLighting::setDiffuseConstant(float diffuseConstant)
 {
     m_diffuseConstant = diffuseConstant;
 }
 
-float SVGFEDiffuseLighting::kernelUnitLengthX() const
+float FEDiffuseLighting::kernelUnitLengthX() const
 {
     return m_kernelUnitLengthX;
 }
 
-void SVGFEDiffuseLighting::setKernelUnitLengthX(float kernelUnitLengthX)
+void FEDiffuseLighting::setKernelUnitLengthX(float kernelUnitLengthX)
 {
     m_kernelUnitLengthX = kernelUnitLengthX;
 }
 
-float SVGFEDiffuseLighting::kernelUnitLengthY() const
+float FEDiffuseLighting::kernelUnitLengthY() const
 {
     return m_kernelUnitLengthY;
 }
 
-void SVGFEDiffuseLighting::setKernelUnitLengthY(float kernelUnitLengthY)
+void FEDiffuseLighting::setKernelUnitLengthY(float kernelUnitLengthY)
 {
     m_kernelUnitLengthY = kernelUnitLengthY;
 }
 
-const LightSource* SVGFEDiffuseLighting::lightSource() const
+const LightSource* FEDiffuseLighting::lightSource() const
 {
     return m_lightSource.get();
 }
 
-void SVGFEDiffuseLighting::setLightSource(LightSource* lightSource)
+void FEDiffuseLighting::setLightSource(LightSource* lightSource)
 {    
     m_lightSource = lightSource;
 }
 
-TextStream& SVGFEDiffuseLighting::externalRepresentation(TextStream& ts) const
+void FEDiffuseLighting::apply()
+{
+}
+
+void FEDiffuseLighting::dump()
+{
+}
+
+TextStream& FEDiffuseLighting::externalRepresentation(TextStream& ts) const
 {
     ts << "[type=DIFFUSE-LIGHTING] ";
-    SVGFilterEffect::externalRepresentation(ts);
+    FilterEffect::externalRepresentation(ts);
     ts << " [surface scale=" << m_surfaceScale << "]"
         << " [diffuse constant=" << m_diffuseConstant << "]"

trunk/WebCore/svg/graphics/filters/SVGFEDiffuseLighting.h

@@ -25 +25 @@
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
 #include "Color.h"
-#include "SVGFilterEffect.h"
+#include "FilterEffect.h"
 
 namespace WebCore {
 
-class LightSource;
+    class LightSource;
 
-class SVGFEDiffuseLighting : public SVGFilterEffect {
-public:
-    static PassRefPtr<SVGFEDiffuseLighting> create(SVGResourceFilter*);
-    virtual ~SVGFEDiffuseLighting();
+    class FEDiffuseLighting : public FilterEffect {
+    public:
+        static PassRefPtr<FEDiffuseLighting> create(FilterEffect*, const Color&, const float&, const float&,
+                const float&, const float&, LightSource*);
+        virtual ~FEDiffuseLighting();
 
-    Color lightingColor() const;
-    void setLightingColor(const Color&);
+        Color lightingColor() const;
+        void setLightingColor(const Color&);
 
-    float surfaceScale() const;
-    void setSurfaceScale(float);
+        float surfaceScale() const;
+        void setSurfaceScale(float);
 
-    float diffuseConstant() const;
-    void setDiffuseConstant(float);
+        float diffuseConstant() const;
+        void setDiffuseConstant(float);
 
-    float kernelUnitLengthX() const;
-    void setKernelUnitLengthX(float);
+        float kernelUnitLengthX() const;
+        void setKernelUnitLengthX(float);
 
-    float kernelUnitLengthY() const;
-    void setKernelUnitLengthY(float);
+        float kernelUnitLengthY() const;
+        void setKernelUnitLengthY(float);
 
-    const LightSource* lightSource() const;
-    void setLightSource(LightSource*);
+        const LightSource* lightSource() const;
+        void setLightSource(LightSource*);
 
-    virtual TextStream& externalRepresentation(TextStream&) const;
+        virtual void apply();
+        virtual void dump();
+        TextStream& externalRepresentation(TextStream& ts) const;
+        
+    private:
+        FEDiffuseLighting(FilterEffect*, const Color&, const float&, const float&,
+                const float&, const float&, LightSource*);
 
-#if PLATFORM(CI)
-    virtual CIFilter* getCIFilter(const FloatRect& bbox) const;
-#endif
-
-private:
-    SVGFEDiffuseLighting(SVGResourceFilter*);
-    
-    Color m_lightingColor;
-    float m_surfaceScale;
-    float m_diffuseConstant;
-    float m_kernelUnitLengthX;
-    float m_kernelUnitLengthY;
-    RefPtr<LightSource> m_lightSource;
-};
+        RefPtr<FilterEffect> m_in;
+        Color m_lightingColor;
+        float m_surfaceScale;
+        float m_diffuseConstant;
+        float m_kernelUnitLengthX;
+        float m_kernelUnitLengthY;
+        RefPtr<LightSource> m_lightSource;
+    };
 
 } // namespace WebCore

trunk/WebCore/svg/graphics/filters/SVGFEDisplacementMap.cpp

@@ -23 +23 @@
 
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
+#include "SVGFEDisplacementMap.h"
 #include "SVGRenderTreeAsText.h"
-#include "SVGFEDisplacementMap.h"
 
 namespace WebCore {
 
-SVGFEDisplacementMap::SVGFEDisplacementMap(SVGResourceFilter* filter)
-    : SVGFilterEffect(filter)
-    , m_xChannelSelector(SVG_CHANNEL_UNKNOWN)
-    , m_yChannelSelector(SVG_CHANNEL_UNKNOWN)
-    , m_scale(0)
+FEDisplacementMap::FEDisplacementMap(FilterEffect* in, FilterEffect* in2, ChannelSelectorType xChannelSelector,
+    ChannelSelectorType yChannelSelector, const float& scale)
+    : FilterEffect()
+    , m_in(in)
+    , m_in2(in2)
+    , m_xChannelSelector(xChannelSelector)
+    , m_yChannelSelector(yChannelSelector)
+    , m_scale(scale)
 {
 }
 
-PassRefPtr<SVGFEDisplacementMap> SVGFEDisplacementMap::create(SVGResourceFilter* filter)
+PassRefPtr<FEDisplacementMap> FEDisplacementMap::create(FilterEffect* in, FilterEffect* in2,
+    ChannelSelectorType xChannelSelector, ChannelSelectorType yChannelSelector, const float& scale)
 {
-    return adoptRef(new SVGFEDisplacementMap(filter));
+    return adoptRef(new FEDisplacementMap(in, in2, xChannelSelector, yChannelSelector, scale));
 }
 
-String SVGFEDisplacementMap::in2() const
-{
-    return m_in2;
-}
-
-void SVGFEDisplacementMap::setIn2(const String &in2)
-{
-    m_in2 = in2;
-}
-
-SVGChannelSelectorType SVGFEDisplacementMap::xChannelSelector() const
+ChannelSelectorType FEDisplacementMap::xChannelSelector() const
 {
     return m_xChannelSelector;
 }
 
-void SVGFEDisplacementMap::setXChannelSelector(const SVGChannelSelectorType xChannelSelector)
+void FEDisplacementMap::setXChannelSelector(const ChannelSelectorType xChannelSelector)
 {
     m_xChannelSelector = xChannelSelector;
 }
 
-SVGChannelSelectorType SVGFEDisplacementMap::yChannelSelector() const
+ChannelSelectorType FEDisplacementMap::yChannelSelector() const
 {
     return m_yChannelSelector;
 }
 
-void SVGFEDisplacementMap::setYChannelSelector(const SVGChannelSelectorType yChannelSelector)
+void FEDisplacementMap::setYChannelSelector(const ChannelSelectorType yChannelSelector)
 {
     m_yChannelSelector = yChannelSelector;
 }
 
-float SVGFEDisplacementMap::scale() const
+float FEDisplacementMap::scale() const
 {
     return m_scale;
 }
 
-void SVGFEDisplacementMap::setScale(float scale)
+void FEDisplacementMap::setScale(float scale)
 {
     m_scale = scale;
 }
 
-static TextStream& operator<<(TextStream& ts, SVGChannelSelectorType t)
+void FEDisplacementMap::apply()
+{
+}
+
+void FEDisplacementMap::dump()
+{
+}
+
+static TextStream& operator<<(TextStream& ts, ChannelSelectorType t)
 {
     switch (t)
     {
-        case SVG_CHANNEL_UNKNOWN:
+        case CHANNEL_UNKNOWN:
             ts << "UNKNOWN"; break;
-        case SVG_CHANNEL_R:
+        case CHANNEL_R:
             ts << "RED"; break;
-        case SVG_CHANNEL_G:
+        case CHANNEL_G:
             ts << "GREEN"; break;
-        case SVG_CHANNEL_B:
+        case CHANNEL_B:
             ts << "BLUE"; break;
-        case SVG_CHANNEL_A:
+        case CHANNEL_A:
             ts << "ALPHA"; break;
     }
@@ -99 +101 @@
 }
 
-TextStream& SVGFEDisplacementMap::externalRepresentation(TextStream& ts) const
+TextStream& FEDisplacementMap::externalRepresentation(TextStream& ts) const
 {
     ts << "[type=DISPLACEMENT-MAP] ";
-    SVGFilterEffect::externalRepresentation(ts);
-    if (!in2().isEmpty())
-        ts << " [in2=" << in2() << "]";
-    ts << " [scale=" << m_scale << "]"
+    FilterEffect::externalRepresentation(ts);
+    ts << " [in2=" << m_in2.get() << "]"
+        << " [scale=" << m_scale << "]"
         << " [x channel selector=" << m_xChannelSelector << "]"
         << " [y channel selector=" << m_yChannelSelector << "]";

trunk/WebCore/svg/graphics/filters/SVGFEDisplacementMap.h

@@ -24 +24 @@
 
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
-#include "SVGFilterEffect.h"
+#include "PlatformString.h"
+#include "FilterEffect.h"
 
 namespace WebCore {
 
-enum SVGChannelSelectorType {
-    SVG_CHANNEL_UNKNOWN = 0,
-    SVG_CHANNEL_R       = 1,
-    SVG_CHANNEL_G       = 2,
-    SVG_CHANNEL_B       = 3,
-    SVG_CHANNEL_A       = 4
-};
+    enum ChannelSelectorType {
+        CHANNEL_UNKNOWN = 0,
+        CHANNEL_R       = 1,
+        CHANNEL_G       = 2,
+        CHANNEL_B       = 3,
+        CHANNEL_A       = 4
+    };
+    
+    class FEDisplacementMap : public FilterEffect {
+    public:
+        static PassRefPtr<FEDisplacementMap> create(FilterEffect*, FilterEffect*, ChannelSelectorType,
+                ChannelSelectorType, const float&);
 
-class SVGFEDisplacementMap : public SVGFilterEffect {
-public:
-    static PassRefPtr<SVGFEDisplacementMap> create(SVGResourceFilter*);
+        ChannelSelectorType xChannelSelector() const;
+        void setXChannelSelector(const ChannelSelectorType);
 
-    String in2() const;
-    void setIn2(const String&);
+        ChannelSelectorType yChannelSelector() const;
+        void setYChannelSelector(const ChannelSelectorType);
 
-    SVGChannelSelectorType xChannelSelector() const;
-    void setXChannelSelector(const SVGChannelSelectorType);
+        float scale() const;
+        void setScale(float scale);
 
-    SVGChannelSelectorType yChannelSelector() const;
-    void setYChannelSelector(const SVGChannelSelectorType);
+        virtual void apply();
+        virtual void dump();
+        TextStream& externalRepresentation(TextStream& ts) const;
 
-    float scale() const;
-    void setScale(float scale);
+    private:
+        FEDisplacementMap(FilterEffect*, FilterEffect*, ChannelSelectorType,
+            ChannelSelectorType, const float&);
 
-    virtual TextStream& externalRepresentation(TextStream&) const;
-
-#if PLATFORM(CI)
-    virtual CIFilter* getCIFilter(const FloatRect& bbox) const;
-#endif
-
-private:
-    SVGFEDisplacementMap(SVGResourceFilter*);
-
-    SVGChannelSelectorType m_xChannelSelector;
-    SVGChannelSelectorType m_yChannelSelector;
-    float m_scale;
-    String m_in2;
-};
+        RefPtr<FilterEffect> m_in;
+        RefPtr<FilterEffect> m_in2;
+        ChannelSelectorType m_xChannelSelector;
+        ChannelSelectorType m_yChannelSelector;
+        float m_scale;
+    };
 
 } // namespace WebCore

trunk/WebCore/svg/graphics/filters/SVGFEFlood.cpp

@@ -23 +23 @@
 
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
+#include "SVGFEFlood.h"
 #include "SVGRenderTreeAsText.h"
-#include "SVGFEFlood.h"
 
 namespace WebCore {
 
-SVGFEFlood::SVGFEFlood(SVGResourceFilter* filter)
-    : SVGFilterEffect(filter)
-    , m_floodColor()
-    , m_floodOpacity(0.0f)
+FEFlood::FEFlood(const Color& floodColor, const float& floodOpacity)
+    : FilterEffect()
+    , m_floodColor(floodColor)
+    , m_floodOpacity(floodOpacity)
 {
 }
 
-PassRefPtr<SVGFEFlood> SVGFEFlood::create(SVGResourceFilter* filter)
+PassRefPtr<FEFlood> FEFlood::create(const Color& floodColor, const float& floodOpacity)
 {
-    return adoptRef(new SVGFEFlood(filter));
+    return adoptRef(new FEFlood(floodColor, floodOpacity));
 }
 
-Color SVGFEFlood::floodColor() const
+Color FEFlood::floodColor() const
 {
     return m_floodColor;
 }
 
-void SVGFEFlood::setFloodColor(const Color& color)
+void FEFlood::setFloodColor(const Color& color)
 {
     m_floodColor = color;
 }
 
-float SVGFEFlood::floodOpacity() const
+float FEFlood::floodOpacity() const
 {
     return m_floodOpacity;
 }
 
-void SVGFEFlood::setFloodOpacity(float floodOpacity)
+void FEFlood::setFloodOpacity(float floodOpacity)
 {
     m_floodOpacity = floodOpacity;
 }
 
-TextStream& SVGFEFlood::externalRepresentation(TextStream& ts) const
+void FEFlood::apply()
+{
+}
+
+void FEFlood::dump()
+{
+}
+
+TextStream& FEFlood::externalRepresentation(TextStream& ts) const
 {
     ts << "[type=FLOOD] ";
-    SVGFilterEffect::externalRepresentation(ts);
+    FilterEffect::externalRepresentation(ts);
     ts << " [color=" << floodColor() << "]"
         << " [opacity=" << floodOpacity() << "]";

trunk/WebCore/svg/graphics/filters/SVGFEFlood.h

@@ -25 +25 @@
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
 #include "Color.h"
-#include "SVGFilterEffect.h"
+#include "FilterEffect.h"
 
 namespace WebCore {
 
-class SVGFEFlood : public SVGFilterEffect {
-public:
-    static PassRefPtr<SVGFEFlood> create(SVGResourceFilter*);
+    class FEFlood : public FilterEffect {
+    public:
+        static PassRefPtr<FEFlood> create(const Color&, const float&);
 
-    Color floodColor() const;
-    void setFloodColor(const Color &);
+        Color floodColor() const;
+        void setFloodColor(const Color &);
 
-    float floodOpacity() const;
-    void setFloodOpacity(float);
+        float floodOpacity() const;
+        void setFloodOpacity(float);
 
-    virtual TextStream& externalRepresentation(TextStream&) const;
+        virtual void apply();
+        virtual void dump();
+        TextStream& externalRepresentation(TextStream& ts) const;
 
-#if PLATFORM(CI)
-    virtual CIFilter* getCIFilter(const FloatRect& bbox) const;
-#endif
+    private:
+        FEFlood(const Color&, const float&);
 
-private:
-    SVGFEFlood(SVGResourceFilter*);
-
-    Color m_floodColor;
-    float m_floodOpacity;
-};
+        Color m_floodColor;
+        float m_floodOpacity;
+    };
 
 } // namespace WebCore

trunk/WebCore/svg/graphics/filters/SVGFEGaussianBlur.cpp

@@ -24 +24 @@
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
 #include "SVGFEGaussianBlur.h"
-#include "TextStream.h"
+#include "SVGRenderTreeAsText.h"
 
 namespace WebCore {
 
-SVGFEGaussianBlur::SVGFEGaussianBlur(SVGResourceFilter* filter)
-    : SVGFilterEffect(filter)
-    , m_x(0.0f)
-    , m_y(0.0f)
+FEGaussianBlur::FEGaussianBlur(FilterEffect* in, const float& x, const float& y)
+    : FilterEffect()
+    , m_in(in)
+    , m_x(x)
+    , m_y(y)
 {
 }
 
-PassRefPtr<SVGFEGaussianBlur> SVGFEGaussianBlur::create(SVGResourceFilter* filter)
+PassRefPtr<FEGaussianBlur> FEGaussianBlur::create(FilterEffect* in, const float& x, const float& y)
 {
-    return adoptRef(new SVGFEGaussianBlur(filter));
+    return adoptRef(new FEGaussianBlur(in, x, y));
 }
 
-float SVGFEGaussianBlur::stdDeviationX() const
+float FEGaussianBlur::stdDeviationX() const
 {
     return m_x;
 }
 
-void SVGFEGaussianBlur::setStdDeviationX(float x)
+void FEGaussianBlur::setStdDeviationX(float x)
 {
     m_x = x;
 }
 
-float SVGFEGaussianBlur::stdDeviationY() const
+float FEGaussianBlur::stdDeviationY() const
 {
     return m_y;
 }
 
-void SVGFEGaussianBlur::setStdDeviationY(float y)
+void FEGaussianBlur::setStdDeviationY(float y)
 {
     m_y = y;
 }
 
-TextStream& SVGFEGaussianBlur::externalRepresentation(TextStream& ts) const
+void FEGaussianBlur::apply()
+{
+}
+
+void FEGaussianBlur::dump()
+{
+}
+
+TextStream& FEGaussianBlur::externalRepresentation(TextStream& ts) const
 {
     ts << "[type=GAUSSIAN-BLUR] ";
-    SVGFilterEffect::externalRepresentation(ts);
+    FilterEffect::externalRepresentation(ts);
     ts << " [std dev. x=" << stdDeviationX() << " y=" << stdDeviationY() << "]";
     return ts;

trunk/WebCore/svg/graphics/filters/SVGFEGaussianBlur.h

@@ -24 +24 @@
 
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
-#include "SVGFilterEffect.h"
+#include "FilterEffect.h"
 
 namespace WebCore {
 
-class SVGFEGaussianBlur : public SVGFilterEffect {
-public:
-    static PassRefPtr<SVGFEGaussianBlur> create(SVGResourceFilter*);
+    class FEGaussianBlur : public FilterEffect {
+    public:
+        static PassRefPtr<FEGaussianBlur> create(FilterEffect*, const float&, const float&);
 
-    float stdDeviationX() const;
-    void setStdDeviationX(float);
+        float stdDeviationX() const;
+        void setStdDeviationX(float);
 
-    float stdDeviationY() const;
-    void setStdDeviationY(float);
+        float stdDeviationY() const;
+        void setStdDeviationY(float);
 
-    virtual TextStream& externalRepresentation(TextStream&) const;
+        virtual void apply();
+        virtual void dump();
+        TextStream& externalRepresentation(TextStream& ts) const;
 
-#if PLATFORM(CI)
-    virtual CIFilter* getCIFilter(const FloatRect& bbox) const;
-#endif
+    private:
+        FEGaussianBlur(FilterEffect*, const float&, const float&);
 
-private:
-    SVGFEGaussianBlur(SVGResourceFilter*);
-
-    float m_x;
-    float m_y;
-};
+        RefPtr<FilterEffect> m_in;
+        float m_x;
+        float m_y;
+    };
 
 } // namespace WebCore

trunk/WebCore/svg/graphics/filters/SVGFEImage.cpp

@@ -24 +24 @@
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
 #include "SVGFEImage.h"
-
-#include "SVGResourceFilter.h"
-#include "TextStream.h"
+#include "SVGRenderTreeAsText.h"
 
 namespace WebCore {
 
-SVGFEImage::SVGFEImage(SVGResourceFilter* filter)
-    : SVGFilterEffect(filter)
-    , m_cachedImage(0)
+FEImage::FEImage(CachedImage* cachedImage)
+    : FilterEffect()
+    , m_cachedImage(cachedImage)
 {
 }
 
-PassRefPtr<SVGFEImage> SVGFEImage::create(SVGResourceFilter* filter)
+PassRefPtr<FEImage> FEImage::create(CachedImage* cachedImage)
 {
-    return adoptRef(new SVGFEImage(filter));
+    return adoptRef(new FEImage(cachedImage));
 }
 
-SVGFEImage::~SVGFEImage()
+FEImage::~FEImage()
 {
     if (m_cachedImage)
@@ -47 +45 @@
 }
 
-CachedImage* SVGFEImage::cachedImage() const
+CachedImage* FEImage::cachedImage() const
 {
     return m_cachedImage;
 }
 
-void SVGFEImage::setCachedImage(CachedImage* image)
+void FEImage::setCachedImage(CachedImage* image)
 {
     if (m_cachedImage == image)
@@ -66 +64 @@
 }
 
-TextStream& SVGFEImage::externalRepresentation(TextStream& ts) const
+void FEImage::apply()
+{
+}
+
+void FEImage::dump()
+{
+}
+
+TextStream& FEImage::externalRepresentation(TextStream& ts) const
 {
     ts << "[type=IMAGE] ";
-    SVGFilterEffect::externalRepresentation(ts);
+    FilterEffect::externalRepresentation(ts);
     // FIXME: should this dump also object returned by SVGFEImage::image() ?
     return ts;
-
-}
-
-void SVGFEImage::imageChanged(CachedImage*)
-{
-    if (SVGResourceFilter* filterResource = filter())
-        filterResource->invalidate();
 }
 

trunk/WebCore/svg/graphics/filters/SVGFEImage.h

@@ -26 +26 @@
 #include "CachedImage.h"
 #include "CachedResourceClient.h"
-#include "SVGFilterEffect.h"
+#include "FilterEffect.h"
 
 namespace WebCore {
 
-class SVGFEImage : public SVGFilterEffect
-                 , public CachedResourceClient {
-public:
-    static PassRefPtr<SVGFEImage> create(SVGResourceFilter*);
-    virtual ~SVGFEImage();
+    class FEImage : public FilterEffect
+                     , public CachedResourceClient {
+    public:
+        static PassRefPtr<FEImage> create(CachedImage*);
+        virtual ~FEImage();
 
-    // FIXME: We need to support <svg> (RenderObject*) as well as image data.
+        // FIXME: We need to support <svg> (RenderObject*) as well as image data.
 
-    CachedImage* cachedImage() const;
-    void setCachedImage(CachedImage*);
+        CachedImage* cachedImage() const;
+        void setCachedImage(CachedImage*);
+        
+        virtual void apply();
+        virtual void dump();
+        TextStream& externalRepresentation(TextStream& ts) const;
+        
+    private:
+        FEImage(CachedImage*);
 
-    virtual TextStream& externalRepresentation(TextStream&) const;
-
-#if PLATFORM(CI)
-    virtual CIFilter* getCIFilter(const FloatRect& bbox) const;
-#endif
-
-    virtual void imageChanged(CachedImage*);
-    
-private:
-    SVGFEImage(SVGResourceFilter*);
-
-    CachedImage* m_cachedImage;
-};
+        CachedImage* m_cachedImage;
+    };
 
 } // namespace WebCore

trunk/WebCore/svg/graphics/filters/SVGFEMerge.cpp

@@ -24 +24 @@
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
 #include "SVGFEMerge.h"
-#include "TextStream.h"
+#include "SVGRenderTreeAsText.h"
 
 namespace WebCore {
 
-SVGFEMerge::SVGFEMerge(SVGResourceFilter* filter) 
-    : SVGFilterEffect(filter) 
+FEMerge::FEMerge(const Vector<FilterEffect*>& mergeInputs) 
+    : FilterEffect()
+    , m_mergeInputs(mergeInputs)
 {
 }
 
-PassRefPtr<SVGFEMerge> SVGFEMerge::create(SVGResourceFilter* filter)
+PassRefPtr<FEMerge> FEMerge::create(const Vector<FilterEffect*>& mergeInputs)
 {
-    return adoptRef(new SVGFEMerge(filter));
+    return adoptRef(new FEMerge(mergeInputs));
 }
 
-const Vector<String>& SVGFEMerge::mergeInputs() const
+const Vector<FilterEffect*>& FEMerge::mergeInputs() const
 {
     return m_mergeInputs;
 }
 
-void SVGFEMerge::setMergeInputs(const Vector<String>& mergeInputs)
+void FEMerge::setMergeInputs(const Vector<FilterEffect*>& mergeInputs)
 {
     m_mergeInputs = mergeInputs;
 }
 
-TextStream& SVGFEMerge::externalRepresentation(TextStream& ts) const
+void FEMerge::apply()
+{
+}
+
+void FEMerge::dump()
+{
+}
+
+TextStream& FEMerge::externalRepresentation(TextStream& ts) const
 {
     ts << "[type=MERGE] ";
-    SVGFilterEffect::externalRepresentation(ts);
+    FilterEffect::externalRepresentation(ts);
     ts << "[merge inputs=[";
     unsigned x = 0;

trunk/WebCore/svg/graphics/filters/SVGFEMerge.h

@@ -24 +24 @@
 
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
-#include "SVGFilterEffect.h"
+#include "FilterEffect.h"
+
+#include <wtf/Vector.h>
 
 namespace WebCore {
 
-class SVGFEMerge : public SVGFilterEffect {
-public:
-    static PassRefPtr<SVGFEMerge> create(SVGResourceFilter*);
+    class FEMerge : public FilterEffect {
+    public:
+        static PassRefPtr<FEMerge> create(const Vector<FilterEffect*>&);
 
-    const Vector<String>& mergeInputs() const;
-    void setMergeInputs(const Vector<String>& mergeInputs);
+        const Vector<FilterEffect*>& mergeInputs() const;
+        void setMergeInputs(const Vector<FilterEffect*>& mergeInputs);
+        
+        virtual void apply();
+        virtual void dump();
+        TextStream& externalRepresentation(TextStream& ts) const;
 
-    virtual TextStream& externalRepresentation(TextStream&) const;
+    private:
+        FEMerge(const Vector<FilterEffect*>&);
 
-#if PLATFORM(CI)
-    virtual CIFilter* getCIFilter(const FloatRect& bbox) const;
-#endif
-
-private:
-    SVGFEMerge(SVGResourceFilter*);
-
-    Vector<String> m_mergeInputs;
-};
+        Vector<FilterEffect*> m_mergeInputs;
+    };
 
 } // namespace WebCore

trunk/WebCore/svg/graphics/filters/SVGFEMorphology.cpp

@@ -24 +24 @@
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
 #include "SVGFEMorphology.h"
-#include "TextStream.h"
+#include "SVGRenderTreeAsText.h"
 
 namespace WebCore {
 
-SVGFEMorphology::SVGFEMorphology(SVGResourceFilter* filter)
-    : SVGFilterEffect(filter)
-    , m_operator(SVG_MORPHOLOGY_OPERATOR_UNKNOWN)
-    , m_radiusX(0.0f)
-    , m_radiusY(0.0f)
+FEMorphology::FEMorphology(FilterEffect* in, MorphologyOperatorType type, const float& radiusX, const float& radiusY)
+    : FilterEffect()
+    , m_in(in)
+    , m_type(type)
+    , m_radiusX(radiusX)
+    , m_radiusY(radiusY)
 {
 }
 
-SVGMorphologyOperatorType SVGFEMorphology::morphologyOperator() const
+PassRefPtr<FEMorphology> FEMorphology::create(FilterEffect* in, MorphologyOperatorType type, const float& radiusX, const float& radiusY)
 {
-    return m_operator;
+    return adoptRef(new FEMorphology(in, type, radiusX, radiusY));
 }
 
-void SVGFEMorphology::setMorphologyOperator(SVGMorphologyOperatorType _operator)
+MorphologyOperatorType FEMorphology::morphologyOperator() const
 {
-    m_operator = _operator;
+    return m_type;
 }
 
-float SVGFEMorphology::radiusX() const
+void FEMorphology::setMorphologyOperator(MorphologyOperatorType type)
+{
+    m_type = type;
+}
+
+float FEMorphology::radiusX() const
 {
     return m_radiusX;
 }
 
-void SVGFEMorphology::setRadiusX(float radiusX)
+void FEMorphology::setRadiusX(float radiusX)
 {
     m_radiusX = radiusX;
 }
 
-float SVGFEMorphology::radiusY() const
+float FEMorphology::radiusY() const
 {
     return m_radiusY;
 }
 
-void SVGFEMorphology::setRadiusY(float radiusY)
+void FEMorphology::setRadiusY(float radiusY)
 {
     m_radiusY = radiusY;
 }
 
-static TextStream& operator<<(TextStream& ts, SVGMorphologyOperatorType t)
+void FEMorphology::apply()
+{
+}
+
+void FEMorphology::dump()
+{
+}
+
+static TextStream& operator<<(TextStream& ts, MorphologyOperatorType t)
 {
     switch (t)
     {
-        case SVG_MORPHOLOGY_OPERATOR_UNKNOWN:
+        case FEMORPHOLOGY_OPERATOR_UNKNOWN:
             ts << "UNKNOWN"; break;
-        case SVG_MORPHOLOGY_OPERATOR_ERODE:
+        case FEMORPHOLOGY_OPERATOR_ERODE:
             ts << "ERODE"; break;
-        case SVG_MORPHOLOGY_OPERATOR_DIALATE:
+        case FEMORPHOLOGY_OPERATOR_DIALATE:
             ts << "DIALATE"; break;
     }
@@ -80 +94 @@
 }
 
-TextStream& SVGFEMorphology::externalRepresentation(TextStream& ts) const
+TextStream& FEMorphology::externalRepresentation(TextStream& ts) const
 {
-    ts << "[type=MORPHOLOGY-OPERATOR] ";
-    SVGFilterEffect::externalRepresentation(ts);
+    ts << "[type=MORPHOLOGY] ";
+    FilterEffect::externalRepresentation(ts);
     ts << " [operator type=" << morphologyOperator() << "]"
-        << " [radius x=" << radiusX() << " y=" << radiusY() << "]";
+        << " [radius x=" << radiusX() << " y=" << radiusY() << "]";        
     return ts;
 }

trunk/WebCore/svg/graphics/filters/SVGFEMorphology.h

@@ -24 +24 @@
 
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
-#include "SVGFilterEffect.h"
+#include "FilterEffect.h"
 
 namespace WebCore {
 
-enum SVGMorphologyOperatorType {
-    SVG_MORPHOLOGY_OPERATOR_UNKNOWN = 0,
-    SVG_MORPHOLOGY_OPERATOR_ERODE   = 1,
-    SVG_MORPHOLOGY_OPERATOR_DIALATE = 2
-};
+    enum MorphologyOperatorType {
+        FEMORPHOLOGY_OPERATOR_UNKNOWN = 0,
+        FEMORPHOLOGY_OPERATOR_ERODE   = 1,
+        FEMORPHOLOGY_OPERATOR_DIALATE = 2
+    };
 
-class SVGFEMorphology : public SVGFilterEffect {
-public:
-    SVGFEMorphology(SVGResourceFilter*);
+    class FEMorphology : public FilterEffect {
+    public:
+        PassRefPtr<FEMorphology> create(FilterEffect*, MorphologyOperatorType, const float&, const float&);  
+        MorphologyOperatorType morphologyOperator() const;
+        void setMorphologyOperator(MorphologyOperatorType);
 
-    SVGMorphologyOperatorType morphologyOperator() const;
-    void setMorphologyOperator(SVGMorphologyOperatorType);
+        float radiusX() const;
+        void setRadiusX(float);
 
-    float radiusX() const;
-    void setRadiusX(float);
+        float radiusY() const;
+        void setRadiusY(float);
 
-    float radiusY() const;
-    void setRadiusY(float);
+        virtual void apply();
+        virtual void dump();
+        TextStream& externalRepresentation(TextStream& ts) const;
 
-    virtual TextStream& externalRepresentation(TextStream&) const;
-
-private:
-    SVGMorphologyOperatorType m_operator;
-    float m_radiusX;
-    float m_radiusY;
-};
+    private:
+        FEMorphology(FilterEffect*, MorphologyOperatorType, const float&, const float&);
+        
+        RefPtr<FilterEffect> m_in;
+        MorphologyOperatorType m_type;
+        float m_radiusX;
+        float m_radiusY;
+    };
 
 } // namespace WebCore

trunk/WebCore/svg/graphics/filters/SVGFEOffset.cpp

@@ -24 +24 @@
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
 #include "SVGFEOffset.h"
-#include "TextStream.h"
+#include "SVGRenderTreeAsText.h"
 
 namespace WebCore {
 
-SVGFEOffset::SVGFEOffset(SVGResourceFilter* filter)
-    : SVGFilterEffect(filter)
-    , m_dx(0.0f)
-    , m_dy(0.0f)
+FEOffset::FEOffset(FilterEffect* in, const float& dx, const float& dy)
+    : FilterEffect()
+    , m_in(in)
+    , m_dx(dx)
+    , m_dy(dy)
 {
 }
 
-PassRefPtr<SVGFEOffset> SVGFEOffset::create(SVGResourceFilter* filter)
+PassRefPtr<FEOffset> FEOffset::create(FilterEffect* in, const float& dx, const float& dy)
 {
-    return adoptRef(new SVGFEOffset(filter));
+    return adoptRef(new FEOffset(in, dx, dy));
 }
 
-float SVGFEOffset::dx() const
+float FEOffset::dx() const
 {
     return m_dx;
 }
 
-void SVGFEOffset::setDx(float dx)
+void FEOffset::setDx(float dx)
 {
     m_dx = dx;
 }
 
-float SVGFEOffset::dy() const
+float FEOffset::dy() const
 {
     return m_dy;
 }
 
-void SVGFEOffset::setDy(float dy)
+void FEOffset::setDy(float dy)
 {
     m_dy = dy;
 }
 
-TextStream& SVGFEOffset::externalRepresentation(TextStream& ts) const
+void FEOffset::apply()
 {
-    ts << "[type=OFFSET] "; SVGFilterEffect::externalRepresentation(ts)
-        << " [dx=" << dx() << " dy=" << dy() << "]";
+}
+
+void FEOffset::dump()
+{
+}
+
+TextStream& FEOffset::externalRepresentation(TextStream& ts) const
+{
+    ts << "[type=OFFSET] "; 
+    FilterEffect::externalRepresentation(ts);
+    ts << " [dx=" << dx() << " dy=" << dy() << "]";
     return ts;
 }

trunk/WebCore/svg/graphics/filters/SVGFEOffset.h

@@ -24 +24 @@
 
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
-#include "SVGFilterEffect.h"
+#include "FilterEffect.h"
 
 namespace WebCore {
 
-class SVGFEOffset : public SVGFilterEffect {
-public:
-    static PassRefPtr<SVGFEOffset> create(SVGResourceFilter*);
+    class FEOffset : public FilterEffect {
+    public:
+        static PassRefPtr<FEOffset> create(FilterEffect*, const float&, const float&);
 
-    float dx() const;
-    void setDx(float);
+        float dx() const;
+        void setDx(float);
 
-    float dy() const;
-    void setDy(float);
+        float dy() const;
+        void setDy(float);
 
-    virtual TextStream& externalRepresentation(TextStream&) const;
+        virtual void apply();
+        virtual void dump();
+        TextStream& externalRepresentation(TextStream& ts) const;
 
-#if PLATFORM(CI)
-    virtual CIFilter* getCIFilter(const FloatRect& bbox) const;
-#endif
+    private:
+        FEOffset(FilterEffect*, const float&, const float&);
 
-private:
-    SVGFEOffset(SVGResourceFilter*);
-
-    float m_dx;
-    float m_dy;
-};
+        RefPtr<FilterEffect> m_in;
+        float m_dx;
+        float m_dy;
+    };
 
 } // namespace WebCore

trunk/WebCore/svg/graphics/filters/SVGFESpecularLighting.cpp

@@ -24 +24 @@
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
 #include "SVGFESpecularLighting.h"
-#include "TextStream.h"
+#include "SVGRenderTreeAsText.h"
 
 namespace WebCore {
 
-SVGFESpecularLighting::SVGFESpecularLighting(SVGResourceFilter* filter)
-    : SVGFilterEffect(filter)
-    , m_lightingColor()
-    , m_surfaceScale(0.0f)
-    , m_specularConstant(0.0f)
-    , m_specularExponent(0.0f)
-    , m_kernelUnitLengthX(0.0f)
-    , m_kernelUnitLengthY(0.0f)
-    , m_lightSource(0)
+FESpecularLighting::FESpecularLighting(FilterEffect* in, const Color& lightingColor, const float& surfaceScale,
+    const float& specularConstant, const float& specularExponent, const float& kernelUnitLengthX,
+    const float& kernelUnitLengthY, LightSource* lightSource)
+    : FilterEffect()
+    , m_in(in)
+    , m_lightingColor(lightingColor)
+    , m_surfaceScale(surfaceScale)
+    , m_specularConstant(specularConstant)
+    , m_specularExponent(specularExponent)
+    , m_kernelUnitLengthX(kernelUnitLengthX)
+    , m_kernelUnitLengthY(kernelUnitLengthY)
+    , m_lightSource(lightSource)
 {
 }
 
-PassRefPtr<SVGFESpecularLighting> SVGFESpecularLighting::create(SVGResourceFilter* filter)
+PassRefPtr<FESpecularLighting> FESpecularLighting::create(FilterEffect* in, const Color& lightingColor,
+    const float& surfaceScale, const float& specularConstant, const float& specularExponent,
+    const float& kernelUnitLengthX, const float& kernelUnitLengthY, LightSource* lightSource)
 {
-    return adoptRef(new SVGFESpecularLighting(filter));
+    return adoptRef(new FESpecularLighting(in, lightingColor, surfaceScale, specularConstant, specularExponent,
+        kernelUnitLengthX, kernelUnitLengthY, lightSource));
 }
 
-SVGFESpecularLighting::~SVGFESpecularLighting()
+FESpecularLighting::~FESpecularLighting()
 {
 }
 
-Color SVGFESpecularLighting::lightingColor() const
+Color FESpecularLighting::lightingColor() const
 {
     return m_lightingColor;
 }
 
-void SVGFESpecularLighting::setLightingColor(const Color& lightingColor)
+void FESpecularLighting::setLightingColor(const Color& lightingColor)
 {
     m_lightingColor = lightingColor;
 }
 
-float SVGFESpecularLighting::surfaceScale() const
+float FESpecularLighting::surfaceScale() const
 {
     return m_surfaceScale;
 }
 
-void SVGFESpecularLighting::setSurfaceScale(float surfaceScale)
+void FESpecularLighting::setSurfaceScale(float surfaceScale)
 {
     m_surfaceScale = surfaceScale;
 }
 
-float SVGFESpecularLighting::specularConstant() const
+float FESpecularLighting::specularConstant() const
 {
     return m_specularConstant;
 }
 
-void SVGFESpecularLighting::setSpecularConstant(float specularConstant)
+void FESpecularLighting::setSpecularConstant(float specularConstant)
 {
     m_specularConstant = specularConstant;
 }
 
-float SVGFESpecularLighting::specularExponent() const
+float FESpecularLighting::specularExponent() const
 {
     return m_specularExponent;
 }
 
-void SVGFESpecularLighting::setSpecularExponent(float specularExponent)
+void FESpecularLighting::setSpecularExponent(float specularExponent)
 {
     m_specularExponent = specularExponent;
 }
 
-float SVGFESpecularLighting::kernelUnitLengthX() const
+float FESpecularLighting::kernelUnitLengthX() const
 {
     return m_kernelUnitLengthX;
 }
 
-void SVGFESpecularLighting::setKernelUnitLengthX(float kernelUnitLengthX)
+void FESpecularLighting::setKernelUnitLengthX(float kernelUnitLengthX)
 {
     m_kernelUnitLengthX = kernelUnitLengthX;
 }
 
-float SVGFESpecularLighting::kernelUnitLengthY() const
+float FESpecularLighting::kernelUnitLengthY() const
 {
     return m_kernelUnitLengthY;
 }
 
-void SVGFESpecularLighting::setKernelUnitLengthY(float kernelUnitLengthY)
+void FESpecularLighting::setKernelUnitLengthY(float kernelUnitLengthY)
 {
     m_kernelUnitLengthY = kernelUnitLengthY;
 }
 
-const LightSource* SVGFESpecularLighting::lightSource() const
+const LightSource* FESpecularLighting::lightSource() const
 {
     return m_lightSource.get();
 }
 
-void SVGFESpecularLighting::setLightSource(LightSource* lightSource)
+void FESpecularLighting::setLightSource(LightSource* lightSource)
 {
     m_lightSource = lightSource;
 }
 
-TextStream& SVGFESpecularLighting::externalRepresentation(TextStream& ts) const
+void FESpecularLighting::apply()
+{
+}
+
+void FESpecularLighting::dump()
+{
+}
+
+TextStream& FESpecularLighting::externalRepresentation(TextStream& ts) const
 {
     ts << "[type=SPECULAR-LIGHTING] ";
-    SVGFilterEffect::externalRepresentation(ts);
+    FilterEffect::externalRepresentation(ts);
     ts << " [surface scale=" << m_surfaceScale << "]"
         << " [specual constant=" << m_specularConstant << "]"

trunk/WebCore/svg/graphics/filters/SVGFESpecularLighting.h

@@ -26 +26 @@
 #include "Color.h"
 #include "SVGLightSource.h"
-#include "SVGFilterEffect.h"
+#include "FilterEffect.h"
 
 namespace WebCore {
 
-class SVGFESpecularLighting : public SVGFilterEffect {
-public:
-    static PassRefPtr<SVGFESpecularLighting> create(SVGResourceFilter*);
-    virtual ~SVGFESpecularLighting();
+    class FESpecularLighting : public FilterEffect {
+    public:
+        static PassRefPtr<FESpecularLighting> create(FilterEffect*, const Color&, const float&, const float&,
+            const float&, const float&, const float&, LightSource*);
+        virtual ~FESpecularLighting();
 
-    Color lightingColor() const;
-    void setLightingColor(const Color&);
+        Color lightingColor() const;
+        void setLightingColor(const Color&);
 
-    float surfaceScale() const;
-    void setSurfaceScale(float);
+        float surfaceScale() const;
+        void setSurfaceScale(float);
 
-    float specularConstant() const;
-    void setSpecularConstant(float);
+        float specularConstant() const;
+        void setSpecularConstant(float);
 
-    float specularExponent() const;
-    void setSpecularExponent(float);
+        float specularExponent() const;
+        void setSpecularExponent(float);
 
-    float kernelUnitLengthX() const;
-    void setKernelUnitLengthX(float);
+        float kernelUnitLengthX() const;
+        void setKernelUnitLengthX(float);
 
-    float kernelUnitLengthY() const;
-    void setKernelUnitLengthY(float);
+        float kernelUnitLengthY() const;
+        void setKernelUnitLengthY(float);
 
-    const LightSource* lightSource() const;
-    void setLightSource(LightSource*);
+        const LightSource* lightSource() const;
+        void setLightSource(LightSource*);
 
-    virtual TextStream& externalRepresentation(TextStream&) const;
+        virtual void apply();
+        virtual void dump();
+        TextStream& externalRepresentation(TextStream& ts) const;
 
-#if PLATFORM(CI)
-    virtual CIFilter* getCIFilter(const FloatRect& bbox) const;
-#endif
+    private:
+        FESpecularLighting(FilterEffect*, const Color&, const float&, const float&, const float&,
+            const float&, const float&, LightSource*);
 
-private:
-    SVGFESpecularLighting(SVGResourceFilter*);
-
-    Color m_lightingColor;
-    float m_surfaceScale;
-    float m_specularConstant;
-    float m_specularExponent;
-    float m_kernelUnitLengthX;
-    float m_kernelUnitLengthY;
-    RefPtr<LightSource> m_lightSource;
-};
+        RefPtr<FilterEffect> m_in;
+        Color m_lightingColor;
+        float m_surfaceScale;
+        float m_specularConstant;
+        float m_specularExponent;
+        float m_kernelUnitLengthX;
+        float m_kernelUnitLengthY;
+        RefPtr<LightSource> m_lightSource;
+    };
 
 } // namespace WebCore

trunk/WebCore/svg/graphics/filters/SVGFETile.cpp

@@ -22 +22 @@
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
 #include "SVGFETile.h"
+#include "SVGRenderTreeAsText.h"
 
 namespace WebCore {
 
-SVGFETile::SVGFETile(SVGResourceFilter* filter)
-    : SVGFilterEffect(filter)
+FETile::FETile(FilterEffect* in)
+    : FilterEffect()
+    , m_in(in)
 {
 }
 
-PassRefPtr<SVGFETile> SVGFETile::create(SVGResourceFilter* filter)
+PassRefPtr<FETile> FETile::create(FilterEffect* in)
 {
-    return adoptRef(new SVGFETile(filter));
+    return adoptRef(new FETile(in));
+}
+
+void FETile::apply()
+{
+}
+
+void FETile::dump()
+{
+}
+
+TextStream& FETile::externalRepresentation(TextStream& ts) const
+{
+    ts << "[type=TILE]";
+    FilterEffect::externalRepresentation(ts);
+    return ts;
 }
 

trunk/WebCore/svg/graphics/filters/SVGFETile.h

@@ -24 +24 @@
 
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
-#include "SVGFilterEffect.h"
+#include "FilterEffect.h"
 
 namespace WebCore {
     
-    class SVGFETile : public SVGFilterEffect {
+    class FETile : public FilterEffect {
     public:
-        static PassRefPtr<SVGFETile> create(SVGResourceFilter*);
+        static PassRefPtr<FETile> create(FilterEffect*);
 
-    #if PLATFORM(CI)
-        virtual CIFilter* getCIFilter(const FloatRect& bbox) const;
-    #endif
+        virtual void apply();
+        virtual void dump();
+        TextStream& externalRepresentation(TextStream& ts) const;
+        
     private:
-        SVGFETile(SVGResourceFilter*);
-
+        FETile(FilterEffect*);
+        
+        RefPtr<FilterEffect> m_in;
     };
 

trunk/WebCore/svg/graphics/filters/SVGFETurbulence.cpp

@@ -24 +24 @@
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
 #include "SVGFETurbulence.h"
-#include "TextStream.h"
+#include "SVGRenderTreeAsText.h"
 
 namespace WebCore {
 
-SVGFETurbulence::SVGFETurbulence(SVGResourceFilter* filter)
-    : SVGFilterEffect(filter)
-    , m_baseFrequencyX(0.0f)
-    , m_baseFrequencyY(0.0f)
-    , m_numOctaves(0)
-    , m_seed(0)
-    , m_stitchTiles(false)
-    , m_type(SVG_TURBULENCE_TYPE_UNKNOWN)
+FETurbulence::FETurbulence(TurbulanceType type, const float& baseFrequencyX, const float& baseFrequencyY,
+    const int& numOctaves, const float& seed, bool stitchTiles)
+    : FilterEffect()
+    , m_type(type)
+    , m_baseFrequencyX(baseFrequencyX)
+    , m_baseFrequencyY(baseFrequencyY)
+    , m_numOctaves(numOctaves)
+    , m_seed(seed)
+    , m_stitchTiles(stitchTiles)
 {
 }
 
-PassRefPtr<SVGFETurbulence> SVGFETurbulence::create(SVGResourceFilter* filter)
+PassRefPtr<FETurbulence> FETurbulence::create(TurbulanceType type, const float& baseFrequencyX, const float& baseFrequencyY,
+    const int& numOctaves, const float& seed, bool stitchTiles)
 {
-    return adoptRef(new SVGFETurbulence(filter));
+    return adoptRef(new FETurbulence(type, baseFrequencyX, baseFrequencyY, numOctaves, seed, stitchTiles));
 }
 
-SVGTurbulanceType SVGFETurbulence::type() const
+TurbulanceType FETurbulence::type() const
 {
     return m_type;
 }
 
-void SVGFETurbulence::setType(SVGTurbulanceType type)
+void FETurbulence::setType(TurbulanceType type)
 {
     m_type = type;
 }
 
-float SVGFETurbulence::baseFrequencyY() const
+float FETurbulence::baseFrequencyY() const
 {
     return m_baseFrequencyY;
 }
 
-void SVGFETurbulence::setBaseFrequencyY(float baseFrequencyY)
+void FETurbulence::setBaseFrequencyY(float baseFrequencyY)
 {
     m_baseFrequencyY = baseFrequencyY;
 }
 
-float SVGFETurbulence::baseFrequencyX() const
+float FETurbulence::baseFrequencyX() const
 {
     return m_baseFrequencyX;
 }
 
-void SVGFETurbulence::setBaseFrequencyX(float baseFrequencyX)
+void FETurbulence::setBaseFrequencyX(float baseFrequencyX)
 {
        m_baseFrequencyX = baseFrequencyX;
 }
 
-float SVGFETurbulence::seed() const
+float FETurbulence::seed() const
 {
     return m_seed; 
 }
 
-void SVGFETurbulence::setSeed(float seed)
+void FETurbulence::setSeed(float seed)
 {
     m_seed = seed;
 }
 
-int SVGFETurbulence::numOctaves() const
+int FETurbulence::numOctaves() const
 {
     return m_numOctaves;
 }
 
-void SVGFETurbulence::setNumOctaves(bool numOctaves)
+void FETurbulence::setNumOctaves(bool numOctaves)
 {
     m_numOctaves = numOctaves;
 }
 
-bool SVGFETurbulence::stitchTiles() const
+bool FETurbulence::stitchTiles() const
 {
     return m_stitchTiles;
 }
 
-void SVGFETurbulence::setStitchTiles(bool stitch)
+void FETurbulence::setStitchTiles(bool stitch)
 {
     m_stitchTiles = stitch;
 }
 
-static TextStream& operator<<(TextStream& ts, SVGTurbulanceType t)
+void FETurbulence::apply()
+{
+}
+
+void FETurbulence::dump()
+{
+}
+
+static TextStream& operator<<(TextStream& ts, TurbulanceType t)
 {
     switch (t)
     {
-        case SVG_TURBULENCE_TYPE_UNKNOWN:
+        case FETURBULENCE_TYPE_UNKNOWN:
             ts << "UNKNOWN"; break;
-        case SVG_TURBULENCE_TYPE_TURBULENCE:
+        case FETURBULENCE_TYPE_TURBULENCE:
             ts << "TURBULANCE"; break;
-        case SVG_TURBULENCE_TYPE_FRACTALNOISE:
+        case FETURBULENCE_TYPE_FRACTALNOISE:
             ts << "NOISE"; break;
     }
@@ -118 +128 @@
 }
 
-TextStream& SVGFETurbulence::externalRepresentation(TextStream& ts) const
+TextStream& FETurbulence::externalRepresentation(TextStream& ts) const
 {
     ts << "[type=TURBULENCE] ";
-    SVGFilterEffect::externalRepresentation(ts);
+    FilterEffect::externalRepresentation(ts);
     ts << " [turbulence type=" << type() << "]"
         << " [base frequency x=" << baseFrequencyX() << " y=" << baseFrequencyY() << "]"
@@ -127 +137 @@
         << " [num octaves=" << numOctaves() << "]"
         << " [stitch tiles=" << stitchTiles() << "]";
+
     return ts;
-
 }
 

trunk/WebCore/svg/graphics/filters/SVGFETurbulence.h

@@ -24 +24 @@
 
 #if ENABLE(SVG) && ENABLE(SVG_FILTERS)
-#include "SVGFilterEffect.h"
+#include "FilterEffect.h"
 
 namespace WebCore {
 
-enum SVGTurbulanceType {
-    SVG_TURBULENCE_TYPE_UNKNOWN      = 0,
-    SVG_TURBULENCE_TYPE_FRACTALNOISE = 1,
-    SVG_TURBULENCE_TYPE_TURBULENCE   = 2
-};
+    enum TurbulanceType {
+        FETURBULENCE_TYPE_UNKNOWN      = 0,
+        FETURBULENCE_TYPE_FRACTALNOISE = 1,
+        FETURBULENCE_TYPE_TURBULENCE   = 2
+    };
 
-class SVGFETurbulence : public SVGFilterEffect {
-public:
-    static PassRefPtr<SVGFETurbulence> create(SVGResourceFilter*);
+    class FETurbulence : public FilterEffect {
+    public:
+        static PassRefPtr<FETurbulence> create(TurbulanceType, const float&, const float&, const int&, const float&,
+                bool);
 
-    SVGTurbulanceType type() const;
-    void setType(SVGTurbulanceType);
+        TurbulanceType type() const;
+        void setType(TurbulanceType);
 
-    float baseFrequencyY() const;
-    void setBaseFrequencyY(float);
+        float baseFrequencyY() const;
+        void setBaseFrequencyY(float);
 
-    float baseFrequencyX() const;
-    void setBaseFrequencyX(float);
+        float baseFrequencyX() const;
+        void setBaseFrequencyX(float);
 
-    float seed() const;
-    void setSeed(float);
+        float seed() const;
+        void setSeed(float);
 
-    int numOctaves() const;
-    void setNumOctaves(bool);
+        int numOctaves() const;
+        void setNumOctaves(bool);
 
-    bool stitchTiles() const;
-    void setStitchTiles(bool);
+        bool stitchTiles() const;
+        void setStitchTiles(bool);
 
-    virtual TextStream& externalRepresentation(TextStream&) const;
+        virtual void apply();
+        virtual void dump();
+        TextStream& externalRepresentation(TextStream& ts) const;
 
-private:
-    SVGFETurbulence(SVGResourceFilter*);
+    private:
+        FETurbulence(TurbulanceType, const float&, const float&, const int&, const float&,
+                bool);
 
-    float m_baseFrequencyX;
-    float m_baseFrequencyY;
-    int m_numOctaves;
-    float m_seed;
-    bool m_stitchTiles;
-    SVGTurbulanceType m_type;
-};
+        TurbulanceType m_type;
+        float m_baseFrequencyX;
+        float m_baseFrequencyY;
+        int m_numOctaves;
+        float m_seed;
+        bool m_stitchTiles;
+    };
 
 } // namespace WebCore

trunk/WebCore/svg/graphics/filters/cg/SVGFEHelpersCg.h

@@ -34 +34 @@
 namespace WebCore {
 
-CIVector* getVectorForChannel(SVGChannelSelectorType channel);
+CIVector* getVectorForChannel(ChannelSelectorType channel);
 CIColor* ciColor(const Color& c);
 

trunk/WebCore/svg/graphics/filters/cg/SVGFEHelpersCg.mm

@@ -40 +40 @@
 namespace WebCore {
 
-CIVector* getVectorForChannel(SVGChannelSelectorType channel)
+CIVector* getVectorForChannel(ChannelSelectorType channel)
 {
     switch (channel) {
-    case SVG_CHANNEL_UNKNOWN:
+    case CHANNEL_UNKNOWN:
         return nil;    
-    case SVG_CHANNEL_R:
+    case CHANNEL_R:
         return [CIVector vectorWithX:1.0f Y:0.0f Z:0.0f W:0.0f];
-    case SVG_CHANNEL_G:
+    case CHANNEL_G:
         return [CIVector vectorWithX:0.0f Y:1.0f Z:0.0f W:0.0f];
-    case SVG_CHANNEL_B:
+    case CHANNEL_B:
         return [CIVector vectorWithX:0.0f Y:0.0f Z:1.0f W:0.0f];
-    case SVG_CHANNEL_A:
+    case CHANNEL_A:
         return [CIVector vectorWithX:0.0f Y:0.0f Z:0.0f W:1.0f];
     default: