SVGFEGaussianBlurElement.cpp [plain text]
#include "config.h"
#if ENABLE(SVG) && ENABLE(FILTERS)
#include "SVGFEGaussianBlurElement.h"
#include "Attribute.h"
#include "FilterEffect.h"
#include "SVGElementInstance.h"
#include "SVGFilterBuilder.h"
#include "SVGNames.h"
#include "SVGParserUtilities.h"
namespace WebCore {
DEFINE_ANIMATED_STRING(SVGFEGaussianBlurElement, SVGNames::inAttr, In1, in1)
DEFINE_ANIMATED_NUMBER_MULTIPLE_WRAPPERS(SVGFEGaussianBlurElement, SVGNames::stdDeviationAttr, stdDeviationXIdentifier(), StdDeviationX, stdDeviationX)
DEFINE_ANIMATED_NUMBER_MULTIPLE_WRAPPERS(SVGFEGaussianBlurElement, SVGNames::stdDeviationAttr, stdDeviationYIdentifier(), StdDeviationY, stdDeviationY)
BEGIN_REGISTER_ANIMATED_PROPERTIES(SVGFEGaussianBlurElement)
REGISTER_LOCAL_ANIMATED_PROPERTY(in1)
REGISTER_LOCAL_ANIMATED_PROPERTY(stdDeviationX)
REGISTER_LOCAL_ANIMATED_PROPERTY(stdDeviationY)
REGISTER_PARENT_ANIMATED_PROPERTIES(SVGFilterPrimitiveStandardAttributes)
END_REGISTER_ANIMATED_PROPERTIES
inline SVGFEGaussianBlurElement::SVGFEGaussianBlurElement(const QualifiedName& tagName, Document* document)
: SVGFilterPrimitiveStandardAttributes(tagName, document)
{
ASSERT(hasTagName(SVGNames::feGaussianBlurTag));
registerAnimatedPropertiesForSVGFEGaussianBlurElement();
}
PassRefPtr<SVGFEGaussianBlurElement> SVGFEGaussianBlurElement::create(const QualifiedName& tagName, Document* document)
{
return adoptRef(new SVGFEGaussianBlurElement(tagName, document));
}
const AtomicString& SVGFEGaussianBlurElement::stdDeviationXIdentifier()
{
DEFINE_STATIC_LOCAL(AtomicString, s_identifier, ("SVGStdDeviationX"));
return s_identifier;
}
const AtomicString& SVGFEGaussianBlurElement::stdDeviationYIdentifier()
{
DEFINE_STATIC_LOCAL(AtomicString, s_identifier, ("SVGStdDeviationY"));
return s_identifier;
}
void SVGFEGaussianBlurElement::setStdDeviation(float x, float y)
{
setStdDeviationXBaseValue(x);
setStdDeviationYBaseValue(y);
invalidate();
}
bool SVGFEGaussianBlurElement::isSupportedAttribute(const QualifiedName& attrName)
{
DEFINE_STATIC_LOCAL(HashSet<QualifiedName>, supportedAttributes, ());
if (supportedAttributes.isEmpty()) {
supportedAttributes.add(SVGNames::inAttr);
supportedAttributes.add(SVGNames::stdDeviationAttr);
}
return supportedAttributes.contains<QualifiedName, SVGAttributeHashTranslator>(attrName);
}
void SVGFEGaussianBlurElement::parseAttribute(Attribute* attr)
{
if (!isSupportedAttribute(attr->name())) {
SVGFilterPrimitiveStandardAttributes::parseAttribute(attr);
return;
}
const AtomicString& value = attr->value();
if (attr->name() == SVGNames::stdDeviationAttr) {
float x, y;
if (parseNumberOptionalNumber(value, x, y)) {
setStdDeviationXBaseValue(x);
setStdDeviationYBaseValue(y);
}
return;
}
if (attr->name() == SVGNames::inAttr) {
setIn1BaseValue(value);
return;
}
ASSERT_NOT_REACHED();
}
void SVGFEGaussianBlurElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);
return;
}
SVGElementInstance::InvalidationGuard invalidationGuard(this);
if (attrName == SVGNames::inAttr || attrName == SVGNames::stdDeviationAttr) {
invalidate();
return;
}
ASSERT_NOT_REACHED();
}
PassRefPtr<FilterEffect> SVGFEGaussianBlurElement::build(SVGFilterBuilder* filterBuilder, Filter* filter)
{
FilterEffect* input1 = filterBuilder->getEffectById(in1());
if (!input1)
return 0;
RefPtr<FilterEffect> effect = FEGaussianBlur::create(filter, stdDeviationX(), stdDeviationY());
effect->inputEffects().append(input1);
return effect.release();
}
}
#endif // ENABLE(SVG)