Use NeverDestroyed instead of DEPRECATED_DEFINE_STATIC_LOCAL
[WebKit-https.git] / Source / WebCore / svg / SVGFEDiffuseLightingElement.cpp
1 /*
2  * Copyright (C) 2005 Oliver Hunt <ojh16@student.canterbury.ac.nz>
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public License
15  * along with this library; see the file COPYING.LIB.  If not, write to
16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  * Boston, MA 02110-1301, USA.
18  */
19
20 #include "config.h"
21 #include "SVGFEDiffuseLightingElement.h"
22
23 #include "FEDiffuseLighting.h"
24 #include "FilterEffect.h"
25 #include "RenderStyle.h"
26 #include "SVGColor.h"
27 #include "SVGFELightElement.h"
28 #include "SVGFilterBuilder.h"
29 #include "SVGNames.h"
30 #include "SVGParserUtilities.h"
31
32 namespace WebCore {
33
34 // Animated property definitions
35 DEFINE_ANIMATED_STRING(SVGFEDiffuseLightingElement, SVGNames::inAttr, In1, in1)
36 DEFINE_ANIMATED_NUMBER(SVGFEDiffuseLightingElement, SVGNames::diffuseConstantAttr, DiffuseConstant, diffuseConstant)
37 DEFINE_ANIMATED_NUMBER(SVGFEDiffuseLightingElement, SVGNames::surfaceScaleAttr, SurfaceScale, surfaceScale)
38 DEFINE_ANIMATED_NUMBER_MULTIPLE_WRAPPERS(SVGFEDiffuseLightingElement, SVGNames::kernelUnitLengthAttr, kernelUnitLengthXIdentifier(), KernelUnitLengthX, kernelUnitLengthX)
39 DEFINE_ANIMATED_NUMBER_MULTIPLE_WRAPPERS(SVGFEDiffuseLightingElement, SVGNames::kernelUnitLengthAttr, kernelUnitLengthYIdentifier(), KernelUnitLengthY, kernelUnitLengthY)
40
41 BEGIN_REGISTER_ANIMATED_PROPERTIES(SVGFEDiffuseLightingElement)
42     REGISTER_LOCAL_ANIMATED_PROPERTY(in1)
43     REGISTER_LOCAL_ANIMATED_PROPERTY(diffuseConstant)
44     REGISTER_LOCAL_ANIMATED_PROPERTY(surfaceScale)
45     REGISTER_LOCAL_ANIMATED_PROPERTY(kernelUnitLengthX)
46     REGISTER_LOCAL_ANIMATED_PROPERTY(kernelUnitLengthY)
47     REGISTER_PARENT_ANIMATED_PROPERTIES(SVGFilterPrimitiveStandardAttributes)
48 END_REGISTER_ANIMATED_PROPERTIES
49
50 inline SVGFEDiffuseLightingElement::SVGFEDiffuseLightingElement(const QualifiedName& tagName, Document& document)
51     : SVGFilterPrimitiveStandardAttributes(tagName, document)
52     , m_diffuseConstant(1)
53     , m_surfaceScale(1)
54 {
55     ASSERT(hasTagName(SVGNames::feDiffuseLightingTag));
56     registerAnimatedPropertiesForSVGFEDiffuseLightingElement();
57 }
58
59 Ref<SVGFEDiffuseLightingElement> SVGFEDiffuseLightingElement::create(const QualifiedName& tagName, Document& document)
60 {
61     return adoptRef(*new SVGFEDiffuseLightingElement(tagName, document));
62 }
63
64 const AtomicString& SVGFEDiffuseLightingElement::kernelUnitLengthXIdentifier()
65 {
66     static NeverDestroyed<AtomicString> s_identifier("SVGKernelUnitLengthX", AtomicString::ConstructFromLiteral);
67     return s_identifier;
68 }
69
70 const AtomicString& SVGFEDiffuseLightingElement::kernelUnitLengthYIdentifier()
71 {
72     static NeverDestroyed<AtomicString> s_identifier("SVGKernelUnitLengthY", AtomicString::ConstructFromLiteral);
73     return s_identifier;
74 }
75
76 void SVGFEDiffuseLightingElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
77 {
78     if (name == SVGNames::inAttr) {
79         setIn1BaseValue(value);
80         return;
81     }
82
83     if (name == SVGNames::surfaceScaleAttr) {
84         setSurfaceScaleBaseValue(value.toFloat());
85         return;
86     }
87
88     if (name == SVGNames::diffuseConstantAttr) {
89         setDiffuseConstantBaseValue(value.toFloat());
90         return;
91     }
92
93     if (name == SVGNames::kernelUnitLengthAttr) {
94         float x, y;
95         if (parseNumberOptionalNumber(value, x, y)) {
96             setKernelUnitLengthXBaseValue(x);
97             setKernelUnitLengthYBaseValue(y);
98         }
99         return;
100     }
101
102     SVGFilterPrimitiveStandardAttributes::parseAttribute(name, value);
103 }
104
105 bool SVGFEDiffuseLightingElement::setFilterEffectAttribute(FilterEffect* effect, const QualifiedName& attrName)
106 {
107     FEDiffuseLighting* diffuseLighting = static_cast<FEDiffuseLighting*>(effect);
108
109     if (attrName == SVGNames::lighting_colorAttr) {
110         RenderObject* renderer = this->renderer();
111         ASSERT(renderer);
112         return diffuseLighting->setLightingColor(renderer->style().svgStyle().lightingColor());
113     }
114     if (attrName == SVGNames::surfaceScaleAttr)
115         return diffuseLighting->setSurfaceScale(surfaceScale());
116     if (attrName == SVGNames::diffuseConstantAttr)
117         return diffuseLighting->setDiffuseConstant(diffuseConstant());
118
119     LightSource* lightSource = const_cast<LightSource*>(diffuseLighting->lightSource());
120     const SVGFELightElement* lightElement = SVGFELightElement::findLightElement(this);
121     ASSERT(lightSource);
122     ASSERT(lightElement);
123
124     if (attrName == SVGNames::azimuthAttr)
125         return lightSource->setAzimuth(lightElement->azimuth());
126     if (attrName == SVGNames::elevationAttr)
127         return lightSource->setElevation(lightElement->elevation());
128     if (attrName == SVGNames::xAttr)
129         return lightSource->setX(lightElement->x());
130     if (attrName == SVGNames::yAttr)
131         return lightSource->setY(lightElement->y());
132     if (attrName == SVGNames::zAttr)
133         return lightSource->setZ(lightElement->z());
134     if (attrName == SVGNames::pointsAtXAttr)
135         return lightSource->setPointsAtX(lightElement->pointsAtX());
136     if (attrName == SVGNames::pointsAtYAttr)
137         return lightSource->setPointsAtY(lightElement->pointsAtY());
138     if (attrName == SVGNames::pointsAtZAttr)
139         return lightSource->setPointsAtZ(lightElement->pointsAtZ());
140     if (attrName == SVGNames::specularExponentAttr)
141         return lightSource->setSpecularExponent(lightElement->specularExponent());
142     if (attrName == SVGNames::limitingConeAngleAttr)
143         return lightSource->setLimitingConeAngle(lightElement->limitingConeAngle());
144
145     ASSERT_NOT_REACHED();
146     return false;
147 }
148
149 void SVGFEDiffuseLightingElement::svgAttributeChanged(const QualifiedName& attrName)
150 {
151     if (attrName == SVGNames::surfaceScaleAttr || attrName == SVGNames::diffuseConstantAttr || attrName == SVGNames::kernelUnitLengthAttr || attrName == SVGNames::lighting_colorAttr) {
152         InstanceInvalidationGuard guard(*this);
153         primitiveAttributeChanged(attrName);
154         return;
155     }
156
157     if (attrName == SVGNames::inAttr) {
158         InstanceInvalidationGuard guard(*this);
159         invalidate();
160         return;
161     }
162
163     SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);
164 }
165
166 void SVGFEDiffuseLightingElement::lightElementAttributeChanged(const SVGFELightElement* lightElement, const QualifiedName& attrName)
167 {
168     if (SVGFELightElement::findLightElement(this) != lightElement)
169         return;
170
171     // The light element has different attribute names.
172     primitiveAttributeChanged(attrName);
173 }
174
175 RefPtr<FilterEffect> SVGFEDiffuseLightingElement::build(SVGFilterBuilder* filterBuilder, Filter& filter)
176 {
177     FilterEffect* input1 = filterBuilder->getEffectById(in1());
178
179     if (!input1)
180         return nullptr;
181
182     RefPtr<LightSource> lightSource = SVGFELightElement::findLightSource(this);
183     if (!lightSource)
184         return nullptr;
185
186     RenderObject* renderer = this->renderer();
187     if (!renderer)
188         return nullptr;
189     
190     Color color = renderer->style().svgStyle().lightingColor();
191
192     RefPtr<FilterEffect> effect = FEDiffuseLighting::create(filter, color, surfaceScale(), diffuseConstant(),
193                                                                 kernelUnitLengthX(), kernelUnitLengthY(), lightSource.release());
194     effect->inputEffects().append(input1);
195     return effect;
196 }
197
198 }