Use #pragma once in WebCore
[WebKit-https.git] / Source / WebCore / svg / SVGAnimatedEnumeration.cpp
1 /*
2  * Copyright (C) Research In Motion Limited 2012. All rights reserved.
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 "SVGAnimatedEnumeration.h"
22
23 #include "SVGAnimationElement.h"
24 #include "SVGComponentTransferFunctionElement.h"
25 #include "SVGFEBlendElement.h"
26 #include "SVGFEColorMatrixElement.h"
27 #include "SVGFECompositeElement.h"
28 #include "SVGFEConvolveMatrixElement.h"
29 #include "SVGFEDisplacementMapElement.h"
30 #include "SVGFEMorphologyElement.h"
31 #include "SVGFETurbulenceElement.h"
32 #include "SVGGradientElement.h"
33 #include "SVGMarkerElement.h"
34 #include "SVGNames.h"
35 #include "SVGTextContentElement.h"
36 #include "SVGTextPathElement.h"
37 #include "SVGUnitTypes.h"
38
39 namespace WebCore {
40
41 static inline unsigned enumerationValueForTargetAttribute(SVGElement* targetElement, const QualifiedName& attrName, const String& value)
42 {
43     ASSERT(targetElement);
44     if (attrName == SVGNames::clipPathUnitsAttr
45         || attrName == SVGNames::filterUnitsAttr
46         || attrName == SVGNames::gradientUnitsAttr
47         || attrName == SVGNames::maskContentUnitsAttr
48         || attrName == SVGNames::maskUnitsAttr
49         || attrName == SVGNames::patternContentUnitsAttr
50         || attrName == SVGNames::patternUnitsAttr
51         || attrName == SVGNames::primitiveUnitsAttr)
52         return SVGPropertyTraits<SVGUnitTypes::SVGUnitType>::fromString(value);
53
54     if (attrName == SVGNames::lengthAdjustAttr)
55         return SVGPropertyTraits<SVGLengthAdjustType>::fromString(value);
56     if (attrName == SVGNames::markerUnitsAttr)
57         return SVGPropertyTraits<SVGMarkerUnitsType>::fromString(value);
58     if (attrName == SVGNames::methodAttr)
59         return SVGPropertyTraits<SVGTextPathMethodType>::fromString(value);
60     if (attrName == SVGNames::spacingAttr)
61         return SVGPropertyTraits<SVGTextPathSpacingType>::fromString(value);
62     if (attrName == SVGNames::spreadMethodAttr)
63         return SVGPropertyTraits<SVGSpreadMethodType>::fromString(value);
64
65     if (attrName == SVGNames::edgeModeAttr)
66         return SVGPropertyTraits<EdgeModeType>::fromString(value);
67
68     if (attrName == SVGNames::operatorAttr) {
69         if (targetElement->hasTagName(SVGNames::feCompositeTag))
70             return SVGPropertyTraits<CompositeOperationType>::fromString(value);
71         ASSERT(targetElement->hasTagName(SVGNames::feMorphologyTag));
72         return SVGPropertyTraits<MorphologyOperatorType>::fromString(value);
73     }
74
75     if (attrName == SVGNames::typeAttr) {
76         if (targetElement->hasTagName(SVGNames::feColorMatrixTag))
77             return SVGPropertyTraits<ColorMatrixType>::fromString(value);
78         if (targetElement->hasTagName(SVGNames::feTurbulenceTag))
79             return SVGPropertyTraits<TurbulenceType>::fromString(value);
80
81         ASSERT(targetElement->hasTagName(SVGNames::feFuncATag)
82                || targetElement->hasTagName(SVGNames::feFuncBTag)
83                || targetElement->hasTagName(SVGNames::feFuncGTag)
84                || targetElement->hasTagName(SVGNames::feFuncRTag));
85         return SVGPropertyTraits<ComponentTransferType>::fromString(value);
86     }
87
88     if (attrName == SVGNames::modeAttr) {
89         BlendMode mode = BlendModeNormal;
90         parseBlendMode(value, mode);
91         return mode;
92     }
93     if (attrName == SVGNames::stitchTilesAttr)
94         return SVGPropertyTraits<SVGStitchOptions>::fromString(value);
95     if (attrName == SVGNames::xChannelSelectorAttr)
96         return SVGPropertyTraits<ChannelSelectorType>::fromString(value);
97     if (attrName == SVGNames::yChannelSelectorAttr)
98         return SVGPropertyTraits<ChannelSelectorType>::fromString(value);
99
100     ASSERT_NOT_REACHED();
101     return 0;
102 }
103
104 SVGAnimatedEnumerationAnimator::SVGAnimatedEnumerationAnimator(SVGAnimationElement* animationElement, SVGElement* contextElement)
105     : SVGAnimatedTypeAnimator(AnimatedEnumeration, animationElement, contextElement)
106 {
107 }
108
109 std::unique_ptr<SVGAnimatedType> SVGAnimatedEnumerationAnimator::constructFromString(const String& string)
110 {
111     ASSERT(m_animationElement);
112     auto animatedType = SVGAnimatedType::createEnumeration(std::make_unique<unsigned>());
113     animatedType->enumeration() = enumerationValueForTargetAttribute(m_animationElement->targetElement(), m_animationElement->attributeName(), string);
114     return animatedType;
115 }
116
117 std::unique_ptr<SVGAnimatedType> SVGAnimatedEnumerationAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
118 {
119     return SVGAnimatedType::createEnumeration(constructFromBaseValue<SVGAnimatedEnumeration>(animatedTypes));
120 }
121
122 void SVGAnimatedEnumerationAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
123 {
124     stopAnimValAnimationForType<SVGAnimatedEnumeration>(animatedTypes);
125 }
126
127 void SVGAnimatedEnumerationAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType& type)
128 {
129     resetFromBaseValue<SVGAnimatedEnumeration>(animatedTypes, type, &SVGAnimatedType::enumeration);
130 }
131
132 void SVGAnimatedEnumerationAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)
133 {
134     animValWillChangeForType<SVGAnimatedEnumeration>(animatedTypes);
135 }
136
137 void SVGAnimatedEnumerationAnimator::animValDidChange(const SVGElementAnimatedPropertyList& animatedTypes)
138 {
139     animValDidChangeForType<SVGAnimatedEnumeration>(animatedTypes);
140 }
141
142 void SVGAnimatedEnumerationAnimator::addAnimatedTypes(SVGAnimatedType*, SVGAnimatedType*)
143 {
144     ASSERT_NOT_REACHED();
145 }
146
147 void SVGAnimatedEnumerationAnimator::calculateAnimatedValue(float percentage, unsigned, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType*, SVGAnimatedType* animated)
148 {
149     ASSERT(m_animationElement);
150     ASSERT(m_contextElement);
151
152     unsigned fromEnumeration = m_animationElement->animationMode() == ToAnimation ? animated->enumeration() : from->enumeration();
153     unsigned toEnumeration = to->enumeration();
154     unsigned& animatedEnumeration = animated->enumeration();
155
156     m_animationElement->animateDiscreteType<unsigned>(percentage, fromEnumeration, toEnumeration, animatedEnumeration);
157 }
158
159 float SVGAnimatedEnumerationAnimator::calculateDistance(const String&, const String&)
160 {
161     // No paced animations for enumerations.
162     return -1;
163 }
164
165 }