Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant
#include "private/qparallelanimationgroupjob_p.h"
#include "private/qanimationjobutil_p.h"
QT_BEGIN_NAMESPACE
QParallelAnimationGroupJob::QParallelAnimationGroupJob()
: QAnimationGroupJob()
, m_previousLoop(0)
, m_previousCurrentTime(0)
{
}
QParallelAnimationGroupJob::~QParallelAnimationGroupJob()
{
}
int QParallelAnimationGroupJob::duration() const
{
int ret = 0;
for (const QAbstractAnimationJob *animation : m_children) {
int currentDuration = animation->totalDuration();
if (currentDuration == -1)
return -1; // Undetermined length
ret = qMax(ret, currentDuration);
}
return ret;
}
void QParallelAnimationGroupJob::updateCurrentTime(int /*currentTime*/)
{
if (m_children.isEmpty())
return;
if (m_currentLoop > m_previousLoop) {
// simulate completion of the loop
int dura = duration();
if (dura < 0) {
// For an uncontrolled parallel group, we need to simulate the end of running animations.
// As uncontrolled animation finish time is already reset for this next loop, we pick the
// longest of the known stop times.
for (QAbstractAnimationJob *animation : m_children) {
int currentDuration = animation->totalDuration();
if (currentDuration >= 0)
dura = qMax(dura, currentDuration);
}
}
if (dura > 0) {
for (QAbstractAnimationJob *animation : m_children) {
if (!animation->isStopped())
RETURN_IF_DELETED(animation->setCurrentTime(dura)); // will stop
}
}
} else if (m_currentLoop < m_previousLoop) {
// simulate completion of the loop seeking backwards
for (QAbstractAnimationJob *animation : m_children) {
//we need to make sure the animation is in the right state
//and then rewind it
applyGroupState(animation);
RETURN_IF_DELETED(animation->setCurrentTime(0));
animation->stop();
}
}
// finally move into the actual time of the current loop
for (QAbstractAnimationJob *animation : m_children) {
const int dura = animation->totalDuration();
//if the loopcount is bigger we should always start all animations
if (m_currentLoop > m_previousLoop
//if we're at the end of the animation, we need to start it if it wasn't already started in this loop
//this happens in Backward direction where not all animations are started at the same time
|| shouldAnimationStart(animation, m_previousCurrentTime > dura /*startIfAtEnd*/)) {
applyGroupState(animation);
}
if (animation->state() == state()) {
RETURN_IF_DELETED(animation->setCurrentTime(m_currentTime));
if (dura > 0 && m_currentTime > dura)
animation->stop();
}
}
m_previousLoop = m_currentLoop;
m_previousCurrentTime = m_currentTime;
}
void QParallelAnimationGroupJob::updateState(QAbstractAnimationJob::State newState,
QAbstractAnimationJob::State oldState)
{
QAnimationGroupJob::updateState(newState, oldState);
switch (newState) {
case Stopped:
for (QAbstractAnimationJob *animation : m_children)
animation->stop();
break;
case Paused:
for (QAbstractAnimationJob *animation : m_children)
if (animation->isRunning())
animation->pause();
break;
case Running:
for (QAbstractAnimationJob *animation : m_children) {
if (oldState == Stopped) {
animation->stop();
m_previousLoop = m_direction == Forward ? 0 : m_loopCount - 1;
}
RETURN_IF_DELETED(resetUncontrolledAnimationFinishTime(animation));
animation->setDirection(m_direction);
if (shouldAnimationStart(animation, oldState == Stopped))
RETURN_IF_DELETED(animation->start());
}
break;
}
}
bool QParallelAnimationGroupJob::shouldAnimationStart(QAbstractAnimationJob *animation, bool startIfAtEnd) const
{
const int dura = animation->totalDuration();
if (dura == -1)
return uncontrolledAnimationFinishTime(animation) == -1;
if (startIfAtEnd)
return m_currentTime <= dura;
if (m_direction == Forward)
return m_currentTime < dura;
else //direction == Backward
return m_currentTime && m_currentTime <= dura;
}
void QParallelAnimationGroupJob::applyGroupState(QAbstractAnimationJob *animation)
{
switch (m_state)
{
case Running:
animation->start();
break;
case Paused:
animation->pause();
break;
case Stopped:
default:
break;
}
}
void QParallelAnimationGroupJob::updateDirection(QAbstractAnimationJob::Direction direction)
{
//we need to update the direction of the current animation
if (!isStopped()) {
for (QAbstractAnimationJob *animation : m_children) {
animation->setDirection(direction);
}
} else {
if (direction == Forward) {
m_previousLoop = 0;
m_previousCurrentTime = 0;
} else {
// Looping backwards with loopCount == -1 does not really work well...
m_previousLoop = (m_loopCount == -1 ? 0 : m_loopCount - 1);
m_previousCurrentTime = duration();
}
}
}
void QParallelAnimationGroupJob::uncontrolledAnimationFinished(QAbstractAnimationJob *animation)
{
Q_ASSERT(animation && (animation->duration() == -1 || animation->loopCount() < 0));
int uncontrolledRunningCount = 0;
for (QAbstractAnimationJob *child : m_children) {
if (child == animation) {
setUncontrolledAnimationFinishTime(animation, animation->currentTime());
} else if (child->duration() == -1 || child->loopCount() < 0) {
if (uncontrolledAnimationFinishTime(child) == -1)
++uncontrolledRunningCount;
}
}
if (uncontrolledRunningCount > 0)
return;
int maxDuration = 0;
bool running = false;
for (QAbstractAnimationJob *job : m_children) {
if (job->state() == Running)
running = true;
maxDuration = qMax(maxDuration, job->totalDuration());
}
setUncontrolledAnimationFinishTime(this, qMax(maxDuration + m_currentLoopStartTime, currentTime()));
if (!running
&& ((m_direction == Forward && m_currentLoop == m_loopCount -1)
|| (m_direction == Backward && m_currentLoop == 0))) {
stop();
}
}
void QParallelAnimationGroupJob::debugAnimation(QDebug d) const
{
d << "ParallelAnimationGroupJob(" << Qt::hex << (const void *) this << Qt::dec << ")";
debugChildren(d);
}
QT_END_NAMESPACE