Generate more SVG type checks and conversions.
[WebKit-https.git] / Source / WebCore / svg / SVGAnimatedTransformList.cpp
1 /*
2  * Copyright (C) 2004, 2005 Nikolas Zimmermann <zimmermann@kde.org>
3  * Copyright (C) 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
4  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
5  * Copyright (C) 2008 Apple Inc. All rights reserved.
6  * Copyright (C) Research In Motion Limited 2012. All rights reserved.
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  */
23
24 #include "config.h"
25
26 #if ENABLE(SVG)
27 #include "SVGAnimatedTransformList.h"
28
29 #include "SVGAnimateTransformElement.h"
30 #include "SVGAnimatedNumber.h"
31 #include "SVGNames.h"
32 #include "SVGTransformDistance.h"
33
34 namespace WebCore {
35
36 SVGAnimatedTransformListAnimator::SVGAnimatedTransformListAnimator(SVGAnimationElement* animationElement, SVGElement* contextElement)
37     : SVGAnimatedTypeAnimator(AnimatedTransformList, animationElement, contextElement)
38     , m_transformTypeString(SVGTransform::transformTypePrefixForParsing(toSVGAnimateTransformElement(animationElement)->transformType()))
39 {
40     // Only <animateTransform> uses this animator, as <animate> doesn't allow to animate transform lists directly.
41     ASSERT(animationElement->hasTagName(SVGNames::animateTransformTag));
42 }
43
44 PassOwnPtr<SVGAnimatedType> SVGAnimatedTransformListAnimator::constructFromString(const String& string)
45 {
46     OwnPtr<SVGAnimatedType> animatedType = SVGAnimatedType::createTransformList(new SVGTransformList);
47     animatedType->transformList().parse(m_transformTypeString + string + ')');
48     ASSERT(animatedType->transformList().size() <= 1);
49     return animatedType.release();
50 }
51
52 PassOwnPtr<SVGAnimatedType> SVGAnimatedTransformListAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
53 {
54     return SVGAnimatedType::createTransformList(constructFromBaseValue<SVGAnimatedTransformList>(animatedTypes));
55 }
56
57 void SVGAnimatedTransformListAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& animatedTypes)
58 {
59     stopAnimValAnimationForType<SVGAnimatedTransformList>(animatedTypes);
60 }
61
62 void SVGAnimatedTransformListAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& animatedTypes, SVGAnimatedType* type)
63 {
64     resetFromBaseValue<SVGAnimatedTransformList>(animatedTypes, type, &SVGAnimatedType::transformList);
65 }
66
67 void SVGAnimatedTransformListAnimator::animValWillChange(const SVGElementAnimatedPropertyList& animatedTypes)
68 {
69     animValWillChangeForType<SVGAnimatedTransformList>(animatedTypes);
70 }
71
72 void SVGAnimatedTransformListAnimator::animValDidChange(const SVGElementAnimatedPropertyList& animatedTypes)
73 {
74     animValDidChangeForType<SVGAnimatedTransformList>(animatedTypes);
75 }
76
77 void SVGAnimatedTransformListAnimator::addAnimatedTypes(SVGAnimatedType* from, SVGAnimatedType* to)
78 {
79     ASSERT(from->type() == AnimatedTransformList);
80     ASSERT(from->type() == to->type());
81
82     const SVGTransformList& fromTransformList = from->transformList();
83     SVGTransformList& toTransformList = to->transformList();
84     unsigned fromTransformListSize = fromTransformList.size();
85     if (!fromTransformListSize || fromTransformListSize != toTransformList.size())
86         return;
87
88     ASSERT(fromTransformListSize == 1);
89     const SVGTransform& fromTransform = fromTransformList[0];
90     SVGTransform& toTransform = toTransformList[0];
91
92     ASSERT(fromTransform.type() == toTransform.type());
93     toTransform = SVGTransformDistance::addSVGTransforms(fromTransform, toTransform);
94 }
95
96 void SVGAnimatedTransformListAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated)
97 {
98     ASSERT(m_animationElement);
99
100     // Spec: To animations provide specific functionality to get a smooth change from the underlying value to the
101     // ‘to’ attribute value, which conflicts mathematically with the requirement for additive transform animations
102     // to be post-multiplied. As a consequence, in SVG 1.1 the behavior of to animations for ‘animateTransform’ is undefined.
103     const SVGTransformList& fromTransformList = from->transformList();
104     const SVGTransformList& toTransformList = to->transformList();
105     const SVGTransformList& toAtEndOfDurationTransformList = toAtEndOfDuration->transformList();
106     SVGTransformList& animatedTransformList = animated->transformList();
107
108     // Pass false to 'resizeAnimatedListIfNeeded' here, as the special post-multiplication behavior of <animateTransform> needs to be respected below.
109     if (!m_animationElement->adjustFromToListValues<SVGTransformList>(fromTransformList, toTransformList, animatedTransformList, percentage, false))
110         return;
111
112     // Never resize the animatedTransformList to the toTransformList size, instead either clear the list or append to it.
113     if (!animatedTransformList.isEmpty() && (!m_animationElement->isAdditive() || m_animationElement->animationMode() == ToAnimation))
114         animatedTransformList.clear();
115
116     unsigned fromTransformListSize = fromTransformList.size();
117     const SVGTransform& toTransform = toTransformList[0];
118     const SVGTransform effectiveFrom = fromTransformListSize ? fromTransformList[0] : SVGTransform(toTransform.type(), SVGTransform::ConstructZeroTransform);
119     SVGTransform currentTransform = SVGTransformDistance(effectiveFrom, toTransform).scaledDistance(percentage).addToSVGTransform(effectiveFrom);
120     if (m_animationElement->isAccumulated() && repeatCount) {
121         const SVGTransform effectiveToAtEnd = toAtEndOfDurationTransformList.size() ? toAtEndOfDurationTransformList[0] : SVGTransform(toTransform.type(), SVGTransform::ConstructZeroTransform);
122         animatedTransformList.append(SVGTransformDistance::addSVGTransforms(currentTransform, effectiveToAtEnd, repeatCount));
123     } else
124         animatedTransformList.append(currentTransform);
125 }
126
127 float SVGAnimatedTransformListAnimator::calculateDistance(const String& fromString, const String& toString)
128 {
129     ASSERT(m_animationElement);
130
131     // FIXME: This is not correct in all cases. The spec demands that each component (translate x and y for example)
132     // is paced separately. To implement this we need to treat each component as individual animation everywhere.
133     OwnPtr<SVGAnimatedType> from = constructFromString(fromString);
134     OwnPtr<SVGAnimatedType> to = constructFromString(toString);
135
136     SVGTransformList& fromTransformList = from->transformList();
137     SVGTransformList& toTransformList = to->transformList();
138     unsigned itemsCount = fromTransformList.size();
139     if (!itemsCount || itemsCount != toTransformList.size())
140         return -1;
141
142     ASSERT(itemsCount == 1);
143     if (fromTransformList[0].type() != toTransformList[0].type())
144         return -1;
145
146     // Spec: http://www.w3.org/TR/SVG/animate.html#complexDistances
147     // Paced animations assume a notion of distance between the various animation values defined by the ‘to’, ‘from’, ‘by’ and ‘values’ attributes.
148     // Distance is defined only for scalar types (such as <length>), colors and the subset of transformation types that are supported by ‘animateTransform’.
149     return SVGTransformDistance(fromTransformList[0], toTransformList[0]).distance();
150 }
151
152 }
153
154 #endif // ENABLE(SVG)