void AnimationPlayer::setStartTimeInternal(double newStartTime)
{
ASSERT(!m_paused);
ASSERT(std::isfinite(newStartTime));
ASSERT(newStartTime != m_startTime);
bool hadStartTime = hasStartTime();
double previousCurrentTime = currentTimeInternal();
m_startTime = newStartTime;
if (m_held && m_playbackRate) {
// If held, the start time would still be derrived from the hold time.
// Force a new, limited, current time.
m_held = false;
double currentTime = calculateCurrentTime();
if (m_playbackRate > 0 && currentTime > sourceEnd()) {
currentTime = sourceEnd();
} else if (m_playbackRate < 0 && currentTime < 0) {
currentTime = 0;
}
setCurrentTimeInternal(currentTime, TimingUpdateOnDemand);
}
updateCurrentTimingState(TimingUpdateOnDemand);
double newCurrentTime = currentTimeInternal();
if (previousCurrentTime != newCurrentTime) {
setOutdated();
} else if (!hadStartTime && m_timeline) {
// Even though this player is not outdated, time to effect change is
// infinity until start time is set.
m_timeline->wake();
}
}
void AnimationPlayer::setCurrentTimeInternal(double newCurrentTime, TimingUpdateReason reason)
{
ASSERT(std::isfinite(newCurrentTime));
bool oldHeld = m_held;
bool outdated = false;
bool isLimited = limited(newCurrentTime);
m_held = m_paused || !m_playbackRate || isLimited || std::isnan(m_startTime);
if (m_held) {
if (!oldHeld || m_holdTime != newCurrentTime)
outdated = true;
m_holdTime = newCurrentTime;
if (m_paused || !m_playbackRate) {
m_startTime = nullValue();
} else if (isLimited && std::isnan(m_startTime) && reason == TimingUpdateForAnimationFrame) {
m_startTime = calculateStartTime(newCurrentTime);
}
} else {
m_holdTime = nullValue();
m_startTime = calculateStartTime(newCurrentTime);
m_finished = false;
outdated = true;
}
if (outdated) {
setOutdated();
}
}
void AnimationPlayer::updateTimingState(double newCurrentTime)
{
ASSERT(!isNull(newCurrentTime));
bool oldHeld = m_held;
m_held = m_paused || !m_playbackRate || limited(newCurrentTime);
if (m_held) {
if (!oldHeld || m_holdTime != newCurrentTime)
setOutdated();
m_holdTime = newCurrentTime;
m_storedTimeLag = nullValue();
} else {
m_holdTime = nullValue();
m_storedTimeLag = currentTimeWithoutLag() - newCurrentTime;
setOutdated();
}
}
void AnimationPlayer::setStartTime(double newStartTime)
{
if (!std::isfinite(newStartTime))
return;
updateCurrentTimingState(); // Update the value of held
m_startTime = newStartTime;
if (m_held)
return;
updateCurrentTimingState();
setOutdated();
}
void AnimationPlayer::setSource(AnimationNode* newSource)
{
if (m_content == newSource)
return;
setCompositorPending(true);
double storedCurrentTime = currentTimeInternal();
if (m_content)
m_content->detach();
m_content = newSource;
if (newSource) {
// FIXME: This logic needs to be updated once groups are implemented
if (newSource->player())
newSource->player()->cancel();
newSource->attach(this);
setOutdated();
}
setCurrentTimeInternal(storedCurrentTime, TimingUpdateOnDemand);
}
void Animation::setEffect(AnimationEffect* newEffect)
{
if (m_content == newEffect)
return;
PlayStateUpdateScope updateScope(*this, TimingUpdateOnDemand, SetCompositorPendingWithEffectChanged);
double storedCurrentTime = currentTimeInternal();
if (m_content)
m_content->detach();
m_content = newEffect;
if (newEffect) {
// FIXME: This logic needs to be updated once groups are implemented
if (newEffect->animation()) {
newEffect->animation()->cancel();
newEffect->animation()->setEffect(0);
}
newEffect->attach(this);
setOutdated();
}
setCurrentTimeInternal(storedCurrentTime, TimingUpdateOnDemand);
}
