SVG <animateMotion> does not reset the element to its first animation frame if its...
[WebKit-https.git] / Source / WebCore / svg / SVGAnimateMotionElement.cpp
1 /*
2  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
3  * Copyright (C) 2007 Rob Buis <buis@kde.org>
4  * Copyright (C) 2008 Apple Inc. All rights reserved.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public License
17  * along with this library; see the file COPYING.LIB.  If not, write to
18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  * Boston, MA 02110-1301, USA.
20  */
21
22 #include "config.h"
23 #include "SVGAnimateMotionElement.h"
24
25 #include "AffineTransform.h"
26 #include "ElementIterator.h"
27 #include "PathTraversalState.h"
28 #include "RenderSVGResource.h"
29 #include "SVGImageElement.h"
30 #include "SVGMPathElement.h"
31 #include "SVGNames.h"
32 #include "SVGParserUtilities.h"
33 #include "SVGPathData.h"
34 #include "SVGPathElement.h"
35 #include "SVGPathUtilities.h"
36 #include <wtf/IsoMallocInlines.h>
37 #include <wtf/MathExtras.h>
38 #include <wtf/StdLibExtras.h>
39 #include <wtf/text/StringView.h>
40
41 namespace WebCore {
42
43 WTF_MAKE_ISO_ALLOCATED_IMPL(SVGAnimateMotionElement);
44     
45 using namespace SVGNames;
46
47 inline SVGAnimateMotionElement::SVGAnimateMotionElement(const QualifiedName& tagName, Document& document)
48     : SVGAnimationElement(tagName, document)
49     , m_hasToPointAtEndOfDuration(false)
50 {
51     setCalcMode(CalcMode::Paced);
52     ASSERT(hasTagName(animateMotionTag));
53 }
54
55 Ref<SVGAnimateMotionElement> SVGAnimateMotionElement::create(const QualifiedName& tagName, Document& document)
56 {
57     return adoptRef(*new SVGAnimateMotionElement(tagName, document));
58 }
59
60 bool SVGAnimateMotionElement::hasValidAttributeType() const
61 {
62     auto targetElement = makeRefPtr(this->targetElement());
63     if (!targetElement)
64         return false;
65
66     // We don't have a special attribute name to verify the animation type. Check the element name instead.
67     if (!targetElement->isSVGGraphicsElement())
68         return false;
69     // Spec: SVG 1.1 section 19.2.15
70     // FIXME: svgTag is missing. Needs to be checked, if transforming <svg> could cause problems.
71     if (targetElement->hasTagName(gTag)
72         || targetElement->hasTagName(defsTag)
73         || targetElement->hasTagName(useTag)
74         || is<SVGImageElement>(*targetElement)
75         || targetElement->hasTagName(switchTag)
76         || targetElement->hasTagName(pathTag)
77         || targetElement->hasTagName(rectTag)
78         || targetElement->hasTagName(circleTag)
79         || targetElement->hasTagName(ellipseTag)
80         || targetElement->hasTagName(lineTag)
81         || targetElement->hasTagName(polylineTag)
82         || targetElement->hasTagName(polygonTag)
83         || targetElement->hasTagName(textTag)
84         || targetElement->hasTagName(clipPathTag)
85         || targetElement->hasTagName(maskTag)
86         || targetElement->hasTagName(SVGNames::aTag)
87         || targetElement->hasTagName(foreignObjectTag)
88         )
89         return true;
90     return false;
91 }
92
93 bool SVGAnimateMotionElement::hasValidAttributeName() const
94 {
95     // AnimateMotion does not use attributeName so it is always valid.
96     return true;
97 }
98
99 void SVGAnimateMotionElement::parseAttribute(const QualifiedName& name, const AtomString& value)
100 {
101     if (name == SVGNames::pathAttr) {
102         m_path = buildPathFromString(value);
103         updateAnimationPath();
104         return;
105     }
106
107     SVGAnimationElement::parseAttribute(name, value);
108 }
109     
110 SVGAnimateMotionElement::RotateMode SVGAnimateMotionElement::rotateMode() const
111 {
112     static NeverDestroyed<const AtomString> autoVal("auto", AtomString::ConstructFromLiteral);
113     static NeverDestroyed<const AtomString> autoReverse("auto-reverse", AtomString::ConstructFromLiteral);
114     const AtomString& rotate = getAttribute(SVGNames::rotateAttr);
115     if (rotate == autoVal)
116         return RotateAuto;
117     if (rotate == autoReverse)
118         return RotateAutoReverse;
119     return RotateAngle;
120 }
121
122 void SVGAnimateMotionElement::updateAnimationPath()
123 {
124     m_animationPath = Path();
125     bool foundMPath = false;
126
127     for (auto& mPath : childrenOfType<SVGMPathElement>(*this)) {
128         auto pathElement = mPath.pathElement();
129         if (pathElement) {
130             m_animationPath = pathFromGraphicsElement(pathElement.get());
131             foundMPath = true;
132             break;
133         }
134     }
135
136     if (!foundMPath && hasAttributeWithoutSynchronization(SVGNames::pathAttr))
137         m_animationPath = m_path;
138
139     updateAnimationMode();
140 }
141
142 void SVGAnimateMotionElement::resetAnimatedType()
143 {
144     if (!hasValidAttributeType())
145         return;
146     auto targetElement = makeRefPtr(this->targetElement());
147     if (!targetElement)
148         return;
149     if (AffineTransform* transform = targetElement->supplementalTransform())
150         transform->makeIdentity();
151 }
152
153 void SVGAnimateMotionElement::clearAnimatedType(SVGElement* targetElement)
154 {
155     if (!targetElement)
156         return;
157     if (AffineTransform* transform = targetElement->supplementalTransform())
158         transform->makeIdentity();
159     applyResultsToTarget();
160 }
161
162 bool SVGAnimateMotionElement::calculateToAtEndOfDurationValue(const String& toAtEndOfDurationString)
163 {
164     parsePoint(toAtEndOfDurationString, m_toPointAtEndOfDuration);
165     m_hasToPointAtEndOfDuration = true;
166     return true;
167 }
168
169 bool SVGAnimateMotionElement::calculateFromAndToValues(const String& fromString, const String& toString)
170 {
171     m_hasToPointAtEndOfDuration = false;
172     parsePoint(fromString, m_fromPoint);
173     parsePoint(toString, m_toPoint);
174     return true;
175 }
176     
177 bool SVGAnimateMotionElement::calculateFromAndByValues(const String& fromString, const String& byString)
178 {
179     m_hasToPointAtEndOfDuration = false;
180     if (animationMode() == AnimationMode::By && !isAdditive())
181         return false;
182     parsePoint(fromString, m_fromPoint);
183     FloatPoint byPoint;
184     parsePoint(byString, byPoint);
185     m_toPoint = FloatPoint(m_fromPoint.x() + byPoint.x(), m_fromPoint.y() + byPoint.y());
186     return true;
187 }
188
189 void SVGAnimateMotionElement::buildTransformForProgress(AffineTransform* transform, float percentage)
190 {
191     ASSERT(!m_animationPath.isEmpty());
192
193     bool success = false;
194     float positionOnPath = m_animationPath.length() * percentage;
195     auto traversalState(m_animationPath.traversalStateAtLength(positionOnPath, success));
196     if (!success)
197         return;
198
199     FloatPoint position = traversalState.current();
200     float angle = traversalState.normalAngle();
201
202     transform->translate(position);
203     RotateMode rotateMode = this->rotateMode();
204     if (rotateMode != RotateAuto && rotateMode != RotateAutoReverse)
205         return;
206     if (rotateMode == RotateAutoReverse)
207         angle += 180;
208     transform->rotate(angle);
209 }
210
211 void SVGAnimateMotionElement::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGSMILElement*)
212 {
213     auto targetElement = makeRefPtr(this->targetElement());
214     if (!targetElement)
215         return;
216
217     AffineTransform* transform = targetElement->supplementalTransform();
218     if (!transform)
219         return;
220
221     if (!isAdditive())
222         transform->makeIdentity();
223
224     if (animationMode() != AnimationMode::Path) {
225         FloatPoint toPointAtEndOfDuration = m_toPoint;
226         if (isAccumulated() && repeatCount && m_hasToPointAtEndOfDuration)
227             toPointAtEndOfDuration = m_toPointAtEndOfDuration;
228
229         float animatedX = 0;
230         animateAdditiveNumber(percentage, repeatCount, m_fromPoint.x(), m_toPoint.x(), toPointAtEndOfDuration.x(), animatedX);
231
232         float animatedY = 0;
233         animateAdditiveNumber(percentage, repeatCount, m_fromPoint.y(), m_toPoint.y(), toPointAtEndOfDuration.y(), animatedY);
234
235         transform->translate(animatedX, animatedY);
236         return;
237     }
238
239     buildTransformForProgress(transform, percentage);
240
241     // Handle accumulate="sum".
242     if (isAccumulated() && repeatCount) {
243         for (unsigned i = 0; i < repeatCount; ++i)
244             buildTransformForProgress(transform, 1);
245     }
246 }
247
248 void SVGAnimateMotionElement::applyResultsToTarget()
249 {
250     // We accumulate to the target element transform list so there is not much to do here.
251     auto targetElement = makeRefPtr(this->targetElement());
252     if (!targetElement)
253         return;
254
255     if (RenderElement* renderer = targetElement->renderer()) {
256         renderer->setNeedsTransformUpdate();
257         RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
258     }
259
260     AffineTransform* targetSupplementalTransform = targetElement->supplementalTransform();
261     if (!targetSupplementalTransform)
262         return;
263
264     // ...except in case where we have additional instances in <use> trees.
265     for (auto* instance : targetElement->instances()) {
266         AffineTransform* transform = instance->supplementalTransform();
267         if (!transform || *transform == *targetSupplementalTransform)
268             continue;
269         *transform = *targetSupplementalTransform;
270         if (RenderElement* renderer = instance->renderer()) {
271             renderer->setNeedsTransformUpdate();
272             RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
273         }
274     }
275 }
276
277 Optional<float> SVGAnimateMotionElement::calculateDistance(const String& fromString, const String& toString)
278 {
279     FloatPoint from;
280     FloatPoint to;
281     if (!parsePoint(fromString, from))
282         return { };
283     if (!parsePoint(toString, to))
284         return { };
285     FloatSize diff = to - from;
286     return sqrtf(diff.width() * diff.width() + diff.height() * diff.height());
287 }
288
289 void SVGAnimateMotionElement::updateAnimationMode()
290 {
291     if (!m_animationPath.isEmpty())
292         setAnimationMode(AnimationMode::Path);
293     else
294         SVGAnimationElement::updateAnimationMode();
295 }
296
297 }