blob: deca6c1c857a624345d8d9df330fdacb87341784 [file] [log] [blame]
/*
* Copyright (C) 2007, 2008, 2009 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of Apple Inc. ("Apple") nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "AnimationBase.h"
#include "CSSAnimationControllerPrivate.h"
#include "CSSPrimitiveValue.h"
#include "CSSPropertyAnimation.h"
#include "CompositeAnimation.h"
#include "Document.h"
#include "FloatConversion.h"
#include "GeometryUtilities.h"
#include "Logging.h"
#include "RenderBox.h"
#include "RenderStyle.h"
#include "RenderView.h"
#include <algorithm>
#include <wtf/Ref.h>
namespace WebCore {
AnimationBase::AnimationBase(const Animation& animation, Element& element, CompositeAnimation& compositeAnimation)
: m_element(&element)
, m_compositeAnimation(&compositeAnimation)
, m_animation(const_cast<Animation&>(animation))
{
// Compute the total duration
if (m_animation->iterationCount() > 0)
m_totalDuration = m_animation->duration() * m_animation->iterationCount();
}
AnimationBase::~AnimationBase() = default;
const RenderStyle& AnimationBase::currentStyle() const
{
if (auto* renderer = this->renderer())
return renderer->style();
return unanimatedStyle();
}
RenderElement* AnimationBase::renderer() const
{
return m_element ? m_element->renderer() : nullptr;
}
void AnimationBase::clear()
{
endAnimation();
m_element = nullptr;
m_compositeAnimation = nullptr;
}
void AnimationBase::setNeedsStyleRecalc(Element* element)
{
if (!element || element->document().renderTreeBeingDestroyed())
return;
ASSERT(element->document().pageCacheState() == Document::NotInPageCache);
element->invalidateStyle();
}
double AnimationBase::duration() const
{
return m_animation->duration();
}
bool AnimationBase::playStatePlaying() const
{
return m_animation->playState() == AnimationPlayState::Playing;
}
bool AnimationBase::animationsMatch(const Animation& animation) const
{
return m_animation->animationsMatch(animation);
}
#if !LOG_DISABLED
static const char* nameForState(AnimationBase::AnimationState state)
{
switch (state) {
case AnimationBase::AnimationState::New: return "New";
case AnimationBase::AnimationState::StartWaitTimer: return "StartWaitTimer";
case AnimationBase::AnimationState::StartWaitStyleAvailable: return "StartWaitStyleAvailable";
case AnimationBase::AnimationState::StartWaitResponse: return "StartWaitResponse";
case AnimationBase::AnimationState::Looping: return "Looping";
case AnimationBase::AnimationState::Ending: return "Ending";
case AnimationBase::AnimationState::PausedNew: return "PausedNew";
case AnimationBase::AnimationState::PausedWaitTimer: return "PausedWaitTimer";
case AnimationBase::AnimationState::PausedWaitStyleAvailable: return "PausedWaitStyleAvailable";
case AnimationBase::AnimationState::PausedWaitResponse: return "PausedWaitResponse";
case AnimationBase::AnimationState::PausedRun: return "PausedRun";
case AnimationBase::AnimationState::Done: return "Done";
case AnimationBase::AnimationState::FillingForwards: return "FillingForwards";
}
return "";
}
static const char* nameForStateInput(AnimationBase::AnimationStateInput input)
{
switch (input) {
case AnimationBase::AnimationStateInput::MakeNew: return "MakeNew";
case AnimationBase::AnimationStateInput::StartAnimation: return "StartAnimation";
case AnimationBase::AnimationStateInput::RestartAnimation: return "RestartAnimation";
case AnimationBase::AnimationStateInput::StartTimerFired: return "StartTimerFired";
case AnimationBase::AnimationStateInput::StyleAvailable: return "StyleAvailable";
case AnimationBase::AnimationStateInput::StartTimeSet: return "StartTimeSet";
case AnimationBase::AnimationStateInput::LoopTimerFired: return "LoopTimerFired";
case AnimationBase::AnimationStateInput::EndTimerFired: return "EndTimerFired";
case AnimationBase::AnimationStateInput::PauseOverride: return "PauseOverride";
case AnimationBase::AnimationStateInput::ResumeOverride: return "ResumeOverride";
case AnimationBase::AnimationStateInput::PlayStateRunning: return "PlayStateRunning";
case AnimationBase::AnimationStateInput::PlayStatePaused: return "PlayStatePaused";
case AnimationBase::AnimationStateInput::EndAnimation: return "EndAnimation";
}
return "";
}
#endif
void AnimationBase::updateStateMachine(AnimationStateInput input, double param)
{
if (!m_compositeAnimation)
return;
// If we get AnimationStateInput::RestartAnimation then we force a new animation, regardless of state.
if (input == AnimationStateInput::MakeNew) {
if (m_animationState == AnimationState::StartWaitStyleAvailable)
m_compositeAnimation->animationController().removeFromAnimationsWaitingForStyle(*this);
LOG(Animations, "%p AnimationState %s -> New", this, nameForState(m_animationState));
m_animationState = AnimationState::New;
m_startTime = WTF::nullopt;
m_pauseTime = WTF::nullopt;
m_requestedStartTime = 0;
m_nextIterationDuration = WTF::nullopt;
endAnimation();
return;
}
if (input == AnimationStateInput::RestartAnimation) {
if (m_animationState == AnimationState::StartWaitStyleAvailable)
m_compositeAnimation->animationController().removeFromAnimationsWaitingForStyle(*this);
LOG(Animations, "%p AnimationState %s -> New", this, nameForState(m_animationState));
m_animationState = AnimationState::New;
m_startTime = WTF::nullopt;
m_pauseTime = WTF::nullopt;
m_requestedStartTime = 0;
m_nextIterationDuration = WTF::nullopt;
endAnimation();
if (!paused())
updateStateMachine(AnimationStateInput::StartAnimation, -1);
return;
}
if (input == AnimationStateInput::EndAnimation) {
if (m_animationState == AnimationState::StartWaitStyleAvailable)
m_compositeAnimation->animationController().removeFromAnimationsWaitingForStyle(*this);
LOG(Animations, "%p AnimationState %s -> Done", this, nameForState(m_animationState));
m_animationState = AnimationState::Done;
endAnimation();
return;
}
if (input == AnimationStateInput::PauseOverride) {
if (m_animationState == AnimationState::StartWaitResponse) {
// If we are in AnimationState::StartWaitResponse, the animation will get canceled before
// we get a response, so move to the next state.
endAnimation();
updateStateMachine(AnimationStateInput::StartTimeSet, beginAnimationUpdateTime());
}
return;
}
if (input == AnimationStateInput::ResumeOverride) {
if (m_animationState == AnimationState::Looping || m_animationState == AnimationState::Ending) {
// Start the animation
startAnimation(beginAnimationUpdateTime() - m_startTime.valueOr(0));
}
return;
}
// Execute state machine
switch (m_animationState) {
case AnimationState::New:
ASSERT(input == AnimationStateInput::StartAnimation || input == AnimationStateInput::PlayStateRunning || input == AnimationStateInput::PlayStatePaused);
if (input == AnimationStateInput::StartAnimation || input == AnimationStateInput::PlayStateRunning) {
m_requestedStartTime = beginAnimationUpdateTime();
LOG(Animations, "%p AnimationState %s -> StartWaitTimer", this, nameForState(m_animationState));
m_animationState = AnimationState::StartWaitTimer;
} else {
// We are pausing before we even started.
LOG(Animations, "%p AnimationState %s -> AnimationState::PausedNew", this, nameForState(m_animationState));
m_animationState = AnimationState::PausedNew;
m_pauseTime = WTF::nullopt;
}
break;
case AnimationState::StartWaitTimer:
ASSERT(input == AnimationStateInput::StartTimerFired || input == AnimationStateInput::PlayStatePaused);
if (input == AnimationStateInput::StartTimerFired) {
ASSERT(param >= 0);
// Start timer has fired, tell the animation to start and wait for it to respond with start time
LOG(Animations, "%p AnimationState %s -> StartWaitStyleAvailable (time is %f)", this, nameForState(m_animationState), param);
m_animationState = AnimationState::StartWaitStyleAvailable;
m_compositeAnimation->animationController().addToAnimationsWaitingForStyle(*this);
// Trigger a render so we can start the animation
if (m_element)
m_compositeAnimation->animationController().addElementChangeToDispatch(*m_element);
} else {
ASSERT(!paused());
// We're waiting for the start timer to fire and we got a pause. Cancel the timer, pause and wait
m_pauseTime = beginAnimationUpdateTime();
LOG(Animations, "%p AnimationState %s -> PausedWaitTimer", this, nameForState(m_animationState));
m_animationState = AnimationState::PausedWaitTimer;
}
break;
case AnimationState::StartWaitStyleAvailable:
ASSERT(input == AnimationStateInput::StyleAvailable || input == AnimationStateInput::PlayStatePaused);
if (input == AnimationStateInput::StyleAvailable) {
// Start timer has fired, tell the animation to start and wait for it to respond with start time
LOG(Animations, "%p AnimationState %s -> StartWaitResponse (time is %f)", this, nameForState(m_animationState), param);
m_animationState = AnimationState::StartWaitResponse;
overrideAnimations();
// Start the animation
if (overridden()) {
// We won't try to start accelerated animations if we are overridden and
// just move on to the next state.
LOG(Animations, "%p AnimationState %s -> StartWaitResponse", this, nameForState(m_animationState));
m_animationState = AnimationState::StartWaitResponse;
m_isAccelerated = false;
updateStateMachine(AnimationStateInput::StartTimeSet, beginAnimationUpdateTime());
} else {
double timeOffset = 0;
// If the value for 'animation-delay' is negative then the animation appears to have started in the past.
if (m_animation->delay() < 0)
timeOffset = -m_animation->delay();
bool started = startAnimation(timeOffset);
m_compositeAnimation->animationController().addToAnimationsWaitingForStartTimeResponse(*this, started);
m_isAccelerated = started;
}
} else {
// We're waiting for the style to be available and we got a pause. Pause and wait
m_pauseTime = beginAnimationUpdateTime();
LOG(Animations, "%p AnimationState %s -> PausedWaitStyleAvailable", this, nameForState(m_animationState));
m_animationState = AnimationState::PausedWaitStyleAvailable;
}
break;
case AnimationState::StartWaitResponse:
ASSERT(input == AnimationStateInput::StartTimeSet || input == AnimationStateInput::PlayStatePaused);
if (input == AnimationStateInput::StartTimeSet) {
ASSERT(param > -0.001); // Sometimes Core Animation gives us a beginTime slightly into the future.
LOG(Animations, "%p AnimationState %s -> StartTimeSet (time is %f)", this, nameForState(m_animationState), param);
// We have a start time, set it, unless the startTime is already set
if (!m_startTime) {
m_startTime = param;
// If the value for 'animation-delay' is negative then the animation appears to have started in the past.
if (m_animation->delay() < 0)
m_startTime = m_startTime.value() + m_animation->delay();
}
// Now that we know the start time, fire the start event.
onAnimationStart(0); // The elapsedTime is 0.
// Decide whether to go into looping or ending state
goIntoEndingOrLoopingState();
// Dispatch updateStyleIfNeeded so we can start the animation
if (m_element)
m_compositeAnimation->animationController().addElementChangeToDispatch(*m_element);
} else {
// We are pausing while waiting for a start response. Cancel the animation and wait. When
// we unpause, we will act as though the start timer just fired
m_pauseTime = beginAnimationUpdateTime();
pauseAnimation(beginAnimationUpdateTime() - m_startTime.valueOr(0));
LOG(Animations, "%p AnimationState %s -> PausedWaitResponse", this, nameForState(m_animationState));
m_animationState = AnimationState::PausedWaitResponse;
}
break;
case AnimationState::Looping:
ASSERT(input == AnimationStateInput::LoopTimerFired || input == AnimationStateInput::PlayStatePaused);
if (input == AnimationStateInput::LoopTimerFired) {
ASSERT(param >= 0);
LOG(Animations, "%p AnimationState %s -> LoopTimerFired (time is %f)", this, nameForState(m_animationState), param);
// Loop timer fired, loop again or end.
onAnimationIteration(param);
// Decide whether to go into looping or ending state
goIntoEndingOrLoopingState();
} else {
// We are pausing while running. Cancel the animation and wait
m_pauseTime = beginAnimationUpdateTime();
pauseAnimation(beginAnimationUpdateTime() - m_startTime.valueOr(0));
LOG(Animations, "%p AnimationState %s -> PausedRun", this, nameForState(m_animationState));
m_animationState = AnimationState::PausedRun;
}
break;
case AnimationState::Ending:
#if !LOG_DISABLED
if (input != AnimationStateInput::EndTimerFired && input != AnimationStateInput::PlayStatePaused)
LOG_ERROR("State is AnimationState::Ending, but input is not AnimationStateInput::EndTimerFired or AnimationStateInput::PlayStatePaused. It is %s.", nameForStateInput(input));
#endif
if (input == AnimationStateInput::EndTimerFired) {
ASSERT(param >= 0);
// End timer fired, finish up
onAnimationEnd(param);
LOG(Animations, "%p AnimationState %s -> Done (time is %f)", this, nameForState(m_animationState), param);
m_animationState = AnimationState::Done;
if (m_element) {
if (m_animation->fillsForwards()) {
LOG(Animations, "%p AnimationState %s -> FillingForwards", this, nameForState(m_animationState));
m_animationState = AnimationState::FillingForwards;
} else
resumeOverriddenAnimations();
// Fire off another style change so we can set the final value
if (m_element)
m_compositeAnimation->animationController().addElementChangeToDispatch(*m_element);
}
} else {
// We are pausing while running. Cancel the animation and wait
m_pauseTime = beginAnimationUpdateTime();
pauseAnimation(beginAnimationUpdateTime() - m_startTime.valueOr(0));
LOG(Animations, "%p AnimationState %s -> PausedRun", this, nameForState(m_animationState));
m_animationState = AnimationState::PausedRun;
}
// |this| may be deleted here
break;
case AnimationState::PausedWaitTimer:
ASSERT(input == AnimationStateInput::PlayStateRunning);
ASSERT(paused());
// Update the times
m_startTime = m_startTime.valueOr(0) + beginAnimationUpdateTime() - m_pauseTime.valueOr(0);
m_pauseTime = WTF::nullopt;
// we were waiting for the start timer to fire, go back and wait again
LOG(Animations, "%p AnimationState %s -> New", this, nameForState(m_animationState));
m_animationState = AnimationState::New;
updateStateMachine(AnimationStateInput::StartAnimation, 0);
break;
case AnimationState::PausedNew:
case AnimationState::PausedWaitResponse:
case AnimationState::PausedWaitStyleAvailable:
case AnimationState::PausedRun:
// We treat these two cases the same. The only difference is that, when we are in
// AnimationState::PausedWaitResponse, we don't yet have a valid startTime, so we send 0 to startAnimation.
// When the AnimationStateInput::StartTimeSet comes in and we were in AnimationState::PausedRun, we will notice
// that we have already set the startTime and will ignore it.
ASSERT(input == AnimationStateInput::PlayStatePaused || input == AnimationStateInput::PlayStateRunning || input == AnimationStateInput::StartTimeSet || input == AnimationStateInput::StyleAvailable);
ASSERT(paused());
if (input == AnimationStateInput::PlayStateRunning) {
if (m_animationState == AnimationState::PausedNew) {
// We were paused before we even started, and now we're supposed
// to start, so jump back to the New state and reset.
LOG(Animations, "%p AnimationState %s -> AnimationState::New", this, nameForState(m_animationState));
m_animationState = AnimationState::New;
m_pauseTime = WTF::nullopt;
updateStateMachine(input, param);
break;
}
// Update the times
if (m_animationState == AnimationState::PausedRun)
m_startTime = m_startTime.valueOr(0) + beginAnimationUpdateTime() - m_pauseTime.valueOr(0);
else
m_startTime = 0;
m_pauseTime = WTF::nullopt;
if (m_animationState == AnimationState::PausedWaitStyleAvailable) {
LOG(Animations, "%p AnimationState %s -> StartWaitStyleAvailable", this, nameForState(m_animationState));
m_animationState = AnimationState::StartWaitStyleAvailable;
} else {
// We were either running or waiting for a begin time response from the animation.
// Either way we need to restart the animation (possibly with an offset if we
// had already been running) and wait for it to start.
LOG(Animations, "%p AnimationState %s -> StartWaitResponse", this, nameForState(m_animationState));
m_animationState = AnimationState::StartWaitResponse;
// Start the animation
if (overridden()) {
// We won't try to start accelerated animations if we are overridden and
// just move on to the next state.
updateStateMachine(AnimationStateInput::StartTimeSet, beginAnimationUpdateTime());
m_isAccelerated = true;
} else {
bool started = startAnimation(beginAnimationUpdateTime() - m_startTime.valueOr(0));
m_compositeAnimation->animationController().addToAnimationsWaitingForStartTimeResponse(*this, started);
m_isAccelerated = started;
}
}
break;
}
if (input == AnimationStateInput::StartTimeSet) {
ASSERT(m_animationState == AnimationState::PausedWaitResponse);
// We are paused but we got the callback that notifies us that an accelerated animation started.
// We ignore the start time and just move into the paused-run state.
LOG(Animations, "%p AnimationState %s -> PausedRun (time is %f)", this, nameForState(m_animationState), param);
m_animationState = AnimationState::PausedRun;
ASSERT(!m_startTime);
m_startTime = param;
m_pauseTime = m_pauseTime.valueOr(0) + param;
break;
}
ASSERT(m_animationState == AnimationState::PausedNew || m_animationState == AnimationState::PausedWaitStyleAvailable);
if (input == AnimationStateInput::PlayStatePaused)
break;
ASSERT(input == AnimationStateInput::StyleAvailable);
// We are paused but we got the callback that notifies us that style has been updated.
// We move to the AnimationState::PausedWaitResponse state
LOG(Animations, "%p AnimationState %s -> PausedWaitResponse", this, nameForState(m_animationState));
m_animationState = AnimationState::PausedWaitResponse;
overrideAnimations();
break;
case AnimationState::FillingForwards:
case AnimationState::Done:
// We're done. Stay in this state until we are deleted
break;
}
}
void AnimationBase::fireAnimationEventsIfNeeded()
{
if (!m_compositeAnimation)
return;
// If we are waiting for the delay time to expire and it has, go to the next state
if (m_animationState != AnimationState::StartWaitTimer && m_animationState != AnimationState::Looping && m_animationState != AnimationState::Ending)
return;
// We have to make sure to keep a ref to the this pointer, because it could get destroyed
// during an animation callback that might get called. Since the owner is a CompositeAnimation
// and it ref counts this object, we will keep a ref to that instead. That way the AnimationBase
// can still access the resources of its CompositeAnimation as needed.
Ref<AnimationBase> protectedThis(*this);
Ref<CompositeAnimation> protectCompositeAnimation(*m_compositeAnimation);
// Check for start timeout
if (m_animationState == AnimationState::StartWaitTimer) {
if (beginAnimationUpdateTime() - m_requestedStartTime >= m_animation->delay())
updateStateMachine(AnimationStateInput::StartTimerFired, 0);
return;
}
double elapsedDuration = beginAnimationUpdateTime() - m_startTime.valueOr(0);
// FIXME: we need to ensure that elapsedDuration is never < 0. If it is, this suggests that
// we had a recalcStyle() outside of beginAnimationUpdate()/endAnimationUpdate().
// Also check in getTimeToNextEvent().
elapsedDuration = std::max(elapsedDuration, 0.0);
// Check for end timeout
if (m_totalDuration && elapsedDuration >= m_totalDuration.value()) {
// We may still be in AnimationState::Looping if we've managed to skip a
// whole iteration, in which case we should jump to the end state.
LOG(Animations, "%p AnimationState %s -> Ending", this, nameForState(m_animationState));
m_animationState = AnimationState::Ending;
// Fire an end event
updateStateMachine(AnimationStateInput::EndTimerFired, m_totalDuration.value());
} else {
// Check for iteration timeout
if (!m_nextIterationDuration) {
// Hasn't been set yet, set it
double durationLeft = m_animation->duration() - fmod(elapsedDuration, m_animation->duration());
m_nextIterationDuration = elapsedDuration + durationLeft;
}
if (elapsedDuration >= m_nextIterationDuration) {
// Set to the next iteration
double previous = m_nextIterationDuration.value();
double durationLeft = m_animation->duration() - fmod(elapsedDuration, m_animation->duration());
m_nextIterationDuration = elapsedDuration + durationLeft;
// Send the event
updateStateMachine(AnimationStateInput::LoopTimerFired, previous);
}
}
}
void AnimationBase::updatePlayState(AnimationPlayState playState)
{
if (!m_compositeAnimation)
return;
// When we get here, we can have one of 4 desired states: running, paused, suspended, paused & suspended.
// The state machine can be in one of two states: running, paused.
// Set the state machine to the desired state.
bool pause = playState == AnimationPlayState::Paused || m_compositeAnimation->isSuspended();
if (pause == paused() && !isNew())
return;
updateStateMachine(pause ? AnimationStateInput::PlayStatePaused : AnimationStateInput::PlayStateRunning, -1);
}
Optional<Seconds> AnimationBase::timeToNextService()
{
// Returns the time at which next service is required. WTF::nullopt means no service is required. 0 means
// service is required now, and > 0 means service is required that many seconds in the future.
if (paused() || isNew() || postActive() || fillingForwards())
return WTF::nullopt;
if (m_animationState == AnimationState::StartWaitTimer) {
double timeFromNow = m_animation->delay() - (beginAnimationUpdateTime() - m_requestedStartTime);
return std::max(Seconds { timeFromNow }, 0_s);
}
fireAnimationEventsIfNeeded();
// In all other cases, we need service right away.
return 0_s;
}
// Compute the fractional time, taking into account direction.
// There is no need to worry about iterations, we assume that we would have
// short circuited above if we were done.
double AnimationBase::fractionalTime(double scale, double elapsedTime, double offset) const
{
double fractionalTime = m_animation->duration() ? (elapsedTime / m_animation->duration()) : 1;
// FIXME: startTime can be before the current animation "frame" time. This is to sync with the frame time
// concept in AnimationTimeController. So we need to somehow sync the two. Until then, the possible
// error is small and will probably not be noticeable. Until we fix this, remove the assert.
// https://bugs.webkit.org/show_bug.cgi?id=52037
// ASSERT(fractionalTime >= 0);
if (fractionalTime < 0)
fractionalTime = 0;
int integralTime = static_cast<int>(fractionalTime);
const int integralIterationCount = static_cast<int>(m_animation->iterationCount());
const bool iterationCountHasFractional = m_animation->iterationCount() - integralIterationCount;
if (m_animation->iterationCount() != Animation::IterationCountInfinite && !iterationCountHasFractional)
integralTime = std::min(integralTime, integralIterationCount - 1);
fractionalTime -= integralTime;
if (((m_animation->direction() == Animation::AnimationDirectionAlternate) && (integralTime & 1))
|| ((m_animation->direction() == Animation::AnimationDirectionAlternateReverse) && !(integralTime & 1))
|| m_animation->direction() == Animation::AnimationDirectionReverse)
fractionalTime = 1 - fractionalTime;
if (scale != 1 || offset)
fractionalTime = (fractionalTime - offset) * scale;
return fractionalTime;
}
double AnimationBase::progress(double scale, double offset, const TimingFunction* timingFunction) const
{
if (preActive())
return 0;
if (postActive())
return 1;
double elapsedTime = getElapsedTime();
double duration = m_animation->duration();
if (m_animation->iterationCount() > 0)
duration *= m_animation->iterationCount();
if (fillingForwards())
elapsedTime = duration;
double fractionalTime = this->fractionalTime(scale, elapsedTime, offset);
if (m_animation->iterationCount() > 0 && elapsedTime >= duration) {
if (WTF::isIntegral(fractionalTime))
return fractionalTime;
}
if (!timingFunction)
timingFunction = m_animation->timingFunction();
return timingFunction->transformTime(fractionalTime, m_animation->duration());
}
void AnimationBase::getTimeToNextEvent(Seconds& time, bool& isLooping) const
{
// Decide when the end or loop event needs to fire
const double elapsedDuration = std::max(beginAnimationUpdateTime() - m_startTime.valueOr(0), 0.0);
double durationLeft = 0;
double nextIterationTime = m_totalDuration.valueOr(0);
if (!m_totalDuration || elapsedDuration < m_totalDuration.value()) {
durationLeft = m_animation->duration() > 0 ? (m_animation->duration() - fmod(elapsedDuration, m_animation->duration())) : 0;
nextIterationTime = elapsedDuration + durationLeft;
}
if (!m_totalDuration || nextIterationTime < m_totalDuration.value()) {
// We are not at the end yet
ASSERT(nextIterationTime > 0);
isLooping = true;
} else {
// We are at the end
isLooping = false;
}
time = Seconds { durationLeft };
}
void AnimationBase::goIntoEndingOrLoopingState()
{
Seconds t;
bool isLooping;
getTimeToNextEvent(t, isLooping);
LOG(Animations, "%p AnimationState %s -> %s", this, nameForState(m_animationState), isLooping ? "Looping" : "Ending");
m_animationState = isLooping ? AnimationState::Looping : AnimationState::Ending;
}
void AnimationBase::freezeAtTime(double t)
{
if (!m_compositeAnimation)
return;
if (!m_startTime) {
// If we haven't started yet, make it as if we started.
LOG(Animations, "%p AnimationState %s -> StartWaitResponse", this, nameForState(m_animationState));
m_animationState = AnimationState::StartWaitResponse;
onAnimationStartResponse(MonotonicTime::now());
}
ASSERT(m_startTime); // If m_startTime is zero, we haven't started yet, so we'll get a bad pause time.
if (t <= m_animation->delay())
m_pauseTime = m_startTime.valueOr(0);
else
m_pauseTime = m_startTime.valueOr(0) + t - m_animation->delay();
if (auto* renderer = this->renderer())
renderer->suspendAnimations(MonotonicTime::fromRawSeconds(m_pauseTime.value()));
}
double AnimationBase::beginAnimationUpdateTime() const
{
if (!m_compositeAnimation)
return 0;
return m_compositeAnimation->animationController().beginAnimationUpdateTime().secondsSinceEpoch().seconds();
}
double AnimationBase::getElapsedTime() const
{
if (paused()) {
double delayOffset = (!m_startTime && m_animation->delay() < 0) ? m_animation->delay() : 0;
return m_pauseTime.valueOr(0) - m_startTime.valueOr(0) - delayOffset;
}
if (!m_startTime)
return 0;
if (postActive() || fillingForwards())
return m_totalDuration.valueOr(0);
return beginAnimationUpdateTime() - m_startTime.valueOr(0);
}
void AnimationBase::setElapsedTime(double time)
{
// FIXME: implement this method
UNUSED_PARAM(time);
}
void AnimationBase::play()
{
// FIXME: implement this method
}
void AnimationBase::pause()
{
// FIXME: implement this method
}
static bool containsRotation(const Vector<RefPtr<TransformOperation>>& operations)
{
for (const auto& operation : operations) {
if (operation->type() == TransformOperation::ROTATE)
return true;
}
return false;
}
bool AnimationBase::computeTransformedExtentViaTransformList(const FloatRect& rendererBox, const RenderStyle& style, LayoutRect& bounds) const
{
FloatRect floatBounds = bounds;
FloatPoint transformOrigin;
bool applyTransformOrigin = containsRotation(style.transform().operations()) || style.transform().affectedByTransformOrigin();
if (applyTransformOrigin) {
transformOrigin.setX(rendererBox.x() + floatValueForLength(style.transformOriginX(), rendererBox.width()));
transformOrigin.setY(rendererBox.y() + floatValueForLength(style.transformOriginY(), rendererBox.height()));
// Ignore transformOriginZ because we'll bail if we encounter any 3D transforms.
floatBounds.moveBy(-transformOrigin);
}
for (const auto& operation : style.transform().operations()) {
if (operation->type() == TransformOperation::ROTATE) {
// For now, just treat this as a full rotation. This could take angle into account to reduce inflation.
floatBounds = boundsOfRotatingRect(floatBounds);
} else {
TransformationMatrix transform;
operation->apply(transform, rendererBox.size());
if (!transform.isAffine())
return false;
if (operation->type() == TransformOperation::MATRIX || operation->type() == TransformOperation::MATRIX_3D) {
TransformationMatrix::Decomposed2Type toDecomp;
transform.decompose2(toDecomp);
// Any rotation prevents us from using a simple start/end rect union.
if (toDecomp.angle)
return false;
}
floatBounds = transform.mapRect(floatBounds);
}
}
if (applyTransformOrigin)
floatBounds.moveBy(transformOrigin);
bounds = LayoutRect(floatBounds);
return true;
}
bool AnimationBase::computeTransformedExtentViaMatrix(const FloatRect& rendererBox, const RenderStyle& style, LayoutRect& bounds) const
{
TransformationMatrix transform;
style.applyTransform(transform, rendererBox, RenderStyle::IncludeTransformOrigin);
if (!transform.isAffine())
return false;
TransformationMatrix::Decomposed2Type fromDecomp;
transform.decompose2(fromDecomp);
// Any rotation prevents us from using a simple start/end rect union.
if (fromDecomp.angle)
return false;
bounds = LayoutRect(transform.mapRect(bounds));
return true;
}
} // namespace WebCore