Source/WebCore/svg/SVGFEGaussianBlurElement.cpp

   1 /*
   2  * Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>
   3  * Copyright (C) 2004, 2005, 2006 Rob Buis <buis@kde.org>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public License
  16  * along with this library; see the file COPYING.LIB.  If not, write to
  17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 #include "config.h"
  22 #include "SVGFEGaussianBlurElement.h"
  23
  24 #include "Attribute.h"
  25 #include "FilterEffect.h"
  26 #include "SVGElementInstance.h"
  27 #include "SVGFilterBuilder.h"
  28 #include "SVGNames.h"
  29 #include "SVGParserUtilities.h"
  30 #include <wtf/NeverDestroyed.h>
  31
  32 namespace WebCore {
  33
  34 // Animated property definitions
  35 DEFINE_ANIMATED_STRING(SVGFEGaussianBlurElement, SVGNames::inAttr, In1, in1)
  36 DEFINE_ANIMATED_NUMBER_MULTIPLE_WRAPPERS(SVGFEGaussianBlurElement, SVGNames::stdDeviationAttr, stdDeviationXIdentifier(), StdDeviationX, stdDeviationX)
  37 DEFINE_ANIMATED_NUMBER_MULTIPLE_WRAPPERS(SVGFEGaussianBlurElement, SVGNames::stdDeviationAttr, stdDeviationYIdentifier(), StdDeviationY, stdDeviationY)
  38 DEFINE_ANIMATED_ENUMERATION(SVGFEGaussianBlurElement, SVGNames::edgeModeAttr, EdgeMode, edgeMode, EdgeModeType)
  39
  40 BEGIN_REGISTER_ANIMATED_PROPERTIES(SVGFEGaussianBlurElement)
  41     REGISTER_LOCAL_ANIMATED_PROPERTY(in1)
  42     REGISTER_LOCAL_ANIMATED_PROPERTY(stdDeviationX)
  43     REGISTER_LOCAL_ANIMATED_PROPERTY(stdDeviationY)
  44     REGISTER_LOCAL_ANIMATED_PROPERTY(edgeMode)
  45     REGISTER_PARENT_ANIMATED_PROPERTIES(SVGFilterPrimitiveStandardAttributes)
  46 END_REGISTER_ANIMATED_PROPERTIES
  47
  48 inline SVGFEGaussianBlurElement::SVGFEGaussianBlurElement(const QualifiedName& tagName, Document& document)
  49     : SVGFilterPrimitiveStandardAttributes(tagName, document)
  50     , m_edgeMode(EDGEMODE_NONE)
  51 {
  52     ASSERT(hasTagName(SVGNames::feGaussianBlurTag));
  53     registerAnimatedPropertiesForSVGFEGaussianBlurElement();
  54 }
  55
  56 PassRefPtr<SVGFEGaussianBlurElement> SVGFEGaussianBlurElement::create(const QualifiedName& tagName, Document& document)
  57 {
  58     return adoptRef(new SVGFEGaussianBlurElement(tagName, document));
  59 }
  60
  61 const AtomicString& SVGFEGaussianBlurElement::stdDeviationXIdentifier()
  62 {
  63     DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, s_identifier, ("SVGStdDeviationX", AtomicString::ConstructFromLiteral));
  64     return s_identifier;
  65 }
  66
  67 const AtomicString& SVGFEGaussianBlurElement::stdDeviationYIdentifier()
  68 {
  69     DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, s_identifier, ("SVGStdDeviationY", AtomicString::ConstructFromLiteral));
  70     return s_identifier;
  71 }
  72
  73 void SVGFEGaussianBlurElement::setStdDeviation(float x, float y)
  74 {
  75     setStdDeviationXBaseValue(x);
  76     setStdDeviationYBaseValue(y);
  77     invalidate();
  78 }
  79
  80 bool SVGFEGaussianBlurElement::isSupportedAttribute(const QualifiedName& attrName)
  81 {
  82     static NeverDestroyed<HashSet<QualifiedName>> supportedAttributes;
  83     if (supportedAttributes.get().isEmpty()) {
  84         supportedAttributes.get().add(SVGNames::inAttr);
  85         supportedAttributes.get().add(SVGNames::stdDeviationAttr);
  86         supportedAttributes.get().add(SVGNames::edgeModeAttr);
  87     }
  88     return supportedAttributes.get().contains<SVGAttributeHashTranslator>(attrName);
  89 }
  90
  91 void SVGFEGaussianBlurElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
  92 {
  93     if (!isSupportedAttribute(name)) {
  94         SVGFilterPrimitiveStandardAttributes::parseAttribute(name, value);
  95         return;
  96     }
  97
  98     if (name == SVGNames::stdDeviationAttr) {
  99         float x, y;
 100         if (parseNumberOptionalNumber(value, x, y)) {
 101             setStdDeviationXBaseValue(x);
 102             setStdDeviationYBaseValue(y);
 103         }
 104         return;
 105     }
 106
 107     if (name == SVGNames::inAttr) {
 108         setIn1BaseValue(value);
 109         return;
 110     }
 111
 112     if (name == SVGNames::edgeModeAttr) {
 113         EdgeModeType propertyValue = SVGPropertyTraits<EdgeModeType>::fromString(value);
 114         if (propertyValue > 0)
 115             setEdgeModeBaseValue(propertyValue);
 116         else
 117             document().accessSVGExtensions().reportWarning(
 118                 "feGaussianBlur: problem parsing edgeMode=\"" + value
 119                 + "\". Filtered element will not be displayed.");
 120         return;
 121     }
 122
 123     ASSERT_NOT_REACHED();
 124 }
 125
 126 void SVGFEGaussianBlurElement::svgAttributeChanged(const QualifiedName& attrName)
 127 {
 128     if (!isSupportedAttribute(attrName)) {
 129         SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);
 130         return;
 131     }
 132
 133     SVGElementInstance::InvalidationGuard invalidationGuard(this);
 134
 135     if (attrName == SVGNames::inAttr
 136         || attrName == SVGNames::stdDeviationAttr
 137         || attrName == SVGNames::edgeModeAttr) {
 138         invalidate();
 139         return;
 140     }
 141
 142     ASSERT_NOT_REACHED();
 143 }
 144
 145 PassRefPtr<FilterEffect> SVGFEGaussianBlurElement::build(SVGFilterBuilder* filterBuilder, Filter* filter)
 146 {
 147     FilterEffect* input1 = filterBuilder->getEffectById(in1());
 148
 149     if (!input1)
 150         return 0;
 151
 152     if (stdDeviationX() < 0 || stdDeviationY() < 0)
 153         return 0;
 154
 155     RefPtr<FilterEffect> effect = FEGaussianBlur::create(filter, stdDeviationX(), stdDeviationY(), edgeMode());
 156     effect->inputEffects().append(input1);
 157     return effect.release();
 158 }
 159
 160 }