d021597124b207bdf2785b93f7b7578d8b21430f
[WebKit-https.git] / Source / WebCore / page / animation / ImplicitAnimation.cpp
1 /*
2  * Copyright (C) 2007 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer. 
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution. 
13  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission. 
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "config.h"
30
31 #include "AnimationControllerPrivate.h"
32 #include "CSSPropertyAnimation.h"
33 #include "CompositeAnimation.h"
34 #include "EventNames.h"
35 #include "GeometryUtilities.h"
36 #include "ImplicitAnimation.h"
37 #include "KeyframeAnimation.h"
38 #include "RenderBox.h"
39
40 namespace WebCore {
41
42 ImplicitAnimation::ImplicitAnimation(Animation& transition, CSSPropertyID animatingProperty, RenderElement* renderer, CompositeAnimation* compAnim, RenderStyle* fromStyle)
43     : AnimationBase(transition, renderer, compAnim)
44     , m_fromStyle(fromStyle)
45     , m_transitionProperty(transition.property())
46     , m_animatingProperty(animatingProperty)
47 {
48     ASSERT(animatingProperty != CSSPropertyInvalid);
49 }
50
51 ImplicitAnimation::~ImplicitAnimation()
52 {
53     // // Make sure to tell the renderer that we are ending. This will make sure any accelerated animations are removed.
54     if (!postActive())
55         endAnimation();
56 }
57
58 bool ImplicitAnimation::shouldSendEventForListener(Document::ListenerType inListenerType) const
59 {
60     return m_object->document().hasListenerType(inListenerType);
61 }
62
63 void ImplicitAnimation::animate(CompositeAnimation*, RenderElement*, const RenderStyle*, RenderStyle* targetStyle, RefPtr<RenderStyle>& animatedStyle)
64 {
65     // If we get this far and the animation is done, it means we are cleaning up a just finished animation.
66     // So just return. Everything is already all cleaned up.
67     if (postActive())
68         return;
69
70     // Reset to start the transition if we are new
71     if (isNew())
72         reset(targetStyle);
73
74     // Run a cycle of animation.
75     // We know we will need a new render style, so make one if needed
76     if (!animatedStyle)
77         animatedStyle = RenderStyle::clone(targetStyle);
78
79     bool needsAnim = CSSPropertyAnimation::blendProperties(this, m_animatingProperty, animatedStyle.get(), m_fromStyle.get(), m_toStyle.get(), progress(1, 0, 0));
80     // FIXME: we also need to detect cases where we have to software animate for other reasons,
81     // such as a child using inheriting the transform. https://bugs.webkit.org/show_bug.cgi?id=23902
82     if (!needsAnim)
83         // If we are running an accelerated animation, set a flag in the style which causes the style
84         // to compare as different to any other style. This ensures that changes to the property
85         // that is animating are correctly detected during the animation (e.g. when a transition
86         // gets interrupted).
87         animatedStyle->setIsRunningAcceleratedAnimation();
88
89     // Fire the start timeout if needed
90     fireAnimationEventsIfNeeded();
91 }
92
93 void ImplicitAnimation::getAnimatedStyle(RefPtr<RenderStyle>& animatedStyle)
94 {
95     if (!animatedStyle)
96         animatedStyle = RenderStyle::clone(m_toStyle.get());
97
98     CSSPropertyAnimation::blendProperties(this, m_animatingProperty, animatedStyle.get(), m_fromStyle.get(), m_toStyle.get(), progress(1, 0, 0));
99 }
100
101 bool ImplicitAnimation::computeExtentOfTransformAnimation(LayoutRect& bounds) const
102 {
103     ASSERT(hasStyle());
104
105     if (!is<RenderBox>(m_object))
106         return true; // Non-boxes don't get transformed;
107
108     ASSERT(m_animatingProperty == CSSPropertyTransform);
109
110     RenderBox& box = downcast<RenderBox>(*m_object);
111     FloatRect rendererBox = snapRectToDevicePixels(box.borderBoxRect(), box.document().deviceScaleFactor());
112
113     LayoutRect startBounds = bounds;
114     LayoutRect endBounds = bounds;
115
116     if (isTransformFunctionListValid()) {
117         if (!computeTransformedExtentViaTransformList(rendererBox, *m_fromStyle, startBounds))
118             return false;
119
120         if (!computeTransformedExtentViaTransformList(rendererBox, *m_toStyle, endBounds))
121             return false;
122     } else {
123         if (!computeTransformedExtentViaMatrix(rendererBox, *m_fromStyle, startBounds))
124             return false;
125
126         if (!computeTransformedExtentViaMatrix(rendererBox, *m_toStyle, endBounds))
127             return false;
128     }
129
130     bounds = unionRect(startBounds, endBounds);
131     return true;
132 }
133
134 bool ImplicitAnimation::startAnimation(double timeOffset)
135 {
136     if (m_object && m_object->isComposited())
137         return downcast<RenderBoxModelObject>(*m_object).startTransition(timeOffset, m_animatingProperty, m_fromStyle.get(), m_toStyle.get());
138     return false;
139 }
140
141 void ImplicitAnimation::pauseAnimation(double timeOffset)
142 {
143     if (!m_object)
144         return;
145
146     if (m_object->isComposited())
147         downcast<RenderBoxModelObject>(*m_object).transitionPaused(timeOffset, m_animatingProperty);
148     // Restore the original (unanimated) style
149     if (!paused())
150         setNeedsStyleRecalc(m_object->element());
151 }
152
153 void ImplicitAnimation::endAnimation()
154 {
155     if (m_object && m_object->isComposited())
156         downcast<RenderBoxModelObject>(*m_object).transitionFinished(m_animatingProperty);
157 }
158
159 void ImplicitAnimation::onAnimationEnd(double elapsedTime)
160 {
161     // If we have a keyframe animation on this property, this transition is being overridden. The keyframe
162     // animation keeps an unanimated style in case a transition starts while the keyframe animation is
163     // running. But now that the transition has completed, we need to update this style with its new
164     // destination. If we didn't, the next time through we would think a transition had started
165     // (comparing the old unanimated style with the new final style of the transition).
166     RefPtr<KeyframeAnimation> keyframeAnim = m_compositeAnimation->getAnimationForProperty(m_animatingProperty);
167     if (keyframeAnim)
168         keyframeAnim->setUnanimatedStyle(m_toStyle);
169     
170     sendTransitionEvent(eventNames().transitionendEvent, elapsedTime);
171     endAnimation();
172 }
173
174 bool ImplicitAnimation::sendTransitionEvent(const AtomicString& eventType, double elapsedTime)
175 {
176     if (eventType == eventNames().transitionendEvent) {
177         Document::ListenerType listenerType = Document::TRANSITIONEND_LISTENER;
178
179         if (shouldSendEventForListener(listenerType)) {
180             String propertyName = getPropertyNameString(m_animatingProperty);
181                 
182             // Dispatch the event
183             RefPtr<Element> element = m_object->element();
184
185             ASSERT(!element || !element->document().inPageCache());
186             if (!element)
187                 return false;
188
189             // Schedule event handling
190             m_compositeAnimation->animationController().addEventToDispatch(element, eventType, propertyName, elapsedTime);
191
192             // Restore the original (unanimated) style
193             if (eventType == eventNames().transitionendEvent && element->renderer())
194                 setNeedsStyleRecalc(element.get());
195
196             return true; // Did dispatch an event
197         }
198     }
199
200     return false; // Didn't dispatch an event
201 }
202
203 void ImplicitAnimation::reset(RenderStyle* to)
204 {
205     ASSERT(to);
206     ASSERT(m_fromStyle);
207
208     m_toStyle = to;
209
210     // Restart the transition
211     if (m_fromStyle && m_toStyle)
212         updateStateMachine(AnimationStateInput::RestartAnimation, -1);
213         
214     // set the transform animation list
215     validateTransformFunctionList();
216     checkForMatchingFilterFunctionLists();
217 }
218
219 void ImplicitAnimation::setOverridden(bool b)
220 {
221     if (b == m_overridden)
222         return;
223
224     m_overridden = b;
225     updateStateMachine(m_overridden ? AnimationStateInput::PauseOverride : AnimationStateInput::ResumeOverride, -1);
226 }
227
228 bool ImplicitAnimation::affectsProperty(CSSPropertyID property) const
229 {
230     return (m_animatingProperty == property);
231 }
232
233 bool ImplicitAnimation::isTargetPropertyEqual(CSSPropertyID prop, const RenderStyle* targetStyle)
234 {
235     // We can get here for a transition that has not started yet. This would make m_toStyle unset and null. 
236     // So we check that here (see <https://bugs.webkit.org/show_bug.cgi?id=26706>)
237     if (!m_toStyle)
238         return false;
239     return CSSPropertyAnimation::propertiesEqual(prop, m_toStyle.get(), targetStyle);
240 }
241
242 void ImplicitAnimation::blendPropertyValueInStyle(CSSPropertyID prop, RenderStyle* currentStyle)
243 {
244     // We should never add a transition with a 0 duration and delay. But if we ever did
245     // it would have a null toStyle. So just in case, let's check that here. (See
246     // <https://bugs.webkit.org/show_bug.cgi?id=24787>
247     if (!m_toStyle)
248         return;
249         
250     CSSPropertyAnimation::blendProperties(this, prop, currentStyle, m_fromStyle.get(), m_toStyle.get(), progress(1, 0, 0));
251 }
252
253 void ImplicitAnimation::validateTransformFunctionList()
254 {
255     m_transformFunctionListValid = false;
256     
257     if (!m_fromStyle || !m_toStyle)
258         return;
259         
260     const TransformOperations* val = &m_fromStyle->transform();
261     const TransformOperations* toVal = &m_toStyle->transform();
262
263     if (val->operations().isEmpty())
264         val = toVal;
265
266     if (val->operations().isEmpty())
267         return;
268         
269     // An emtpy transform list matches anything.
270     if (val != toVal && !toVal->operations().isEmpty() && !val->operationsMatch(*toVal))
271         return;
272
273     // Transform lists match.
274     m_transformFunctionListValid = true;
275 }
276
277 void ImplicitAnimation::checkForMatchingFilterFunctionLists()
278 {
279     m_filterFunctionListsMatch = false;
280     
281     if (!m_fromStyle || !m_toStyle)
282         return;
283         
284     const FilterOperations* val = &m_fromStyle->filter();
285     const FilterOperations* toVal = &m_toStyle->filter();
286
287     if (val->operations().isEmpty())
288         val = toVal;
289
290     if (val->operations().isEmpty())
291         return;
292         
293     // An emtpy filter list matches anything.
294     if (val != toVal && !toVal->operations().isEmpty() && !val->operationsMatch(*toVal))
295         return;
296
297     // Filter lists match.
298     m_filterFunctionListsMatch = true;
299 }
300
301 double ImplicitAnimation::timeToNextService()
302 {
303     double t = AnimationBase::timeToNextService();
304     if (t != 0 || preActive())
305         return t;
306         
307     // A return value of 0 means we need service. But if this is an accelerated animation we 
308     // only need service at the end of the transition.
309     if (CSSPropertyAnimation::animationOfPropertyIsAccelerated(m_animatingProperty) && isAccelerated()) {
310         bool isLooping;
311         getTimeToNextEvent(t, isLooping);
312     }
313     return t;
314 }
315
316 } // namespace WebCore