qquicktransition.cpp

Go to the documentation of this file.

// 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
 
#include "qquicktransition_p.h"
 
#include "qquickstate_p.h"
#include "qquickstate_p_p.h"
#include "qquickstatechangescript_p.h"
#include "qquickanimation_p.h"
#include "qquickanimation_p_p.h"
#include "qquicktransitionmanager_p_p.h"
 
#include <private/qquickanimatorjob_p.h>
 
#include "private/qparallelanimationgroupjob_p.h"
 
QT_BEGIN_NAMESPACE
 
//ParallelAnimationWrapper allows us to do a "callback" when the animation finishes, rather than connecting
//and disconnecting signals and slots frequently
class ParallelAnimationWrapper : public QParallelAnimationGroupJob
{
public:
    ParallelAnimationWrapper() : QParallelAnimationGroupJob() {}
    QQuickTransitionManager *manager;
 
protected:
    void updateState(QAbstractAnimationJob::State newState, QAbstractAnimationJob::State oldState) override;
};
 
class QQuickTransitionPrivate : public QObjectPrivate
{
    Q_DECLARE_PUBLIC(QQuickTransition)
public:
    QQuickTransitionPrivate()
    : fromState(QLatin1String("*")), toState(QLatin1String("*"))
    , runningInstanceCount(0), state(QAbstractAnimationJob::Stopped)
    , reversed(false), reversible(false), enabled(true)
    {
    }
 
    static QQuickTransitionPrivate *get(QQuickTransition *q) { return q->d_func(); }
    void animationStateChanged(QAbstractAnimationJob::State newState);
 
    QString fromState;
    QString toState;
    quint32 runningInstanceCount;
    QAbstractAnimationJob::State state;
    bool reversed;
    bool reversible;
    bool enabled;
protected:
 
    static void append_animation(QQmlListProperty<QQuickAbstractAnimation> *list, QQuickAbstractAnimation *a);
    static qsizetype animation_count(QQmlListProperty<QQuickAbstractAnimation> *list);
    static QQuickAbstractAnimation* animation_at(QQmlListProperty<QQuickAbstractAnimation> *list, qsizetype pos);
    static void clear_animations(QQmlListProperty<QQuickAbstractAnimation> *list);
    QList<QQuickAbstractAnimation *> animations;
};
 
void QQuickTransitionPrivate::append_animation(QQmlListProperty<QQuickAbstractAnimation> *list, QQuickAbstractAnimation *a)
{
    QQuickTransition *q = static_cast<QQuickTransition *>(list->object);
    q->d_func()->animations.append(a);
    a->setDisableUserControl();
}
 
qsizetype QQuickTransitionPrivate::animation_count(QQmlListProperty<QQuickAbstractAnimation> *list)
{
    QQuickTransition *q = static_cast<QQuickTransition *>(list->object);
    return q->d_func()->animations.size();
}
 
QQuickAbstractAnimation* QQuickTransitionPrivate::animation_at(QQmlListProperty<QQuickAbstractAnimation> *list, qsizetype pos)
{
    QQuickTransition *q = static_cast<QQuickTransition *>(list->object);
    return q->d_func()->animations.at(pos);
}
 
void QQuickTransitionPrivate::clear_animations(QQmlListProperty<QQuickAbstractAnimation> *list)
{
    QQuickTransition *q = static_cast<QQuickTransition *>(list->object);
    while (q->d_func()->animations.size()) {
        QQuickAbstractAnimation *firstAnim = q->d_func()->animations.at(0);
        q->d_func()->animations.removeAll(firstAnim);
    }
}
 
void QQuickTransitionInstance::animationStateChanged(QAbstractAnimationJob *, QAbstractAnimationJob::State newState, QAbstractAnimationJob::State)
{
    if (!m_transition)
        return;
 
    QQuickTransitionPrivate *transition = QQuickTransitionPrivate::get(m_transition);
    transition->animationStateChanged(newState);
}
 
void QQuickTransitionPrivate::animationStateChanged(QAbstractAnimationJob::State newState)
{
    Q_Q(QQuickTransition);
 
    if (newState == QAbstractAnimationJob::Running) {
        runningInstanceCount++;
        if (runningInstanceCount == 1)
            emit q->runningChanged();
    } else if (newState == QAbstractAnimationJob::Stopped) {
        runningInstanceCount--;
        if (runningInstanceCount == 0)
            emit q->runningChanged();
    }
}
 
void ParallelAnimationWrapper::updateState(QAbstractAnimationJob::State newState, QAbstractAnimationJob::State oldState)
{
    QParallelAnimationGroupJob::updateState(newState, oldState);
    if (newState == Stopped && (duration() == -1
        || (direction() == QAbstractAnimationJob::Forward && currentLoopTime() == duration())
        || (direction() == QAbstractAnimationJob::Backward && currentLoopTime() == 0)))
    {
         manager->complete();
    }
}
 
QQuickTransitionInstance::QQuickTransitionInstance(QQuickTransition *transition, QAbstractAnimationJob *anim)
    : m_transition(transition)
    , m_anim(anim)
{
    anim->addAnimationChangeListener(this, QAbstractAnimationJob::StateChange);
}
 
QQuickTransitionInstance::~QQuickTransitionInstance()
{
    removeStateChangeListener();
    delete m_anim;
}
 
void QQuickTransitionInstance::start()
{
    if (m_anim)
        m_anim->start();
}
 
void QQuickTransitionInstance::stop()
{
    if (m_anim)
        m_anim->stop();
}
 
void QQuickTransitionInstance::complete()
{
    if (m_anim)
        m_anim->complete();
}
 
bool QQuickTransitionInstance::isRunning() const
{
    return m_anim && m_anim->state() == QAbstractAnimationJob::Running;
}
 
QQuickTransition::QQuickTransition(QObject *parent)
    : QObject(*(new QQuickTransitionPrivate), parent)
{
}
 
QQuickTransition::~QQuickTransition()
{
}
 
void QQuickTransition::setReversed(bool r)
{
    Q_D(QQuickTransition);
    d->reversed = r;
}
 
QQuickTransitionInstance *QQuickTransition::prepare(QQuickStateOperation::ActionList &actions,
                            QList<QQmlProperty> &after,
                            QQuickTransitionManager *manager,
                            QObject *defaultTarget)
{
    Q_D(QQuickTransition);
 
    qmlExecuteDeferred(this);
 
    ParallelAnimationWrapper *group = new ParallelAnimationWrapper();
    group->manager = manager;
 
    QQuickAbstractAnimation::TransitionDirection direction = d->reversed ? QQuickAbstractAnimation::Backward : QQuickAbstractAnimation::Forward;
    int start = d->reversed ? d->animations.size() - 1 : 0;
    int end = d->reversed ? -1 : d->animations.size();
 
    QAbstractAnimationJob *anim = nullptr;
    for (int i = start; i != end;) {
        anim = d->animations.at(i)->transition(actions, after, direction, defaultTarget);
        if (anim) {
            if (d->animations.at(i)->threadingModel() == QQuickAbstractAnimation::RenderThread)
                anim = new QQuickAnimatorProxyJob(anim, d->animations.at(i));
            d->reversed ? group->prependAnimation(anim) : group->appendAnimation(anim);
        }
        d->reversed ? --i : ++i;
    }
 
    group->setDirection(d->reversed ? QAbstractAnimationJob::Backward : QAbstractAnimationJob::Forward);
 
    QQuickTransitionInstance *wrapper = new QQuickTransitionInstance(this, group);
    return wrapper;
}
 
QString QQuickTransition::fromState() const
{
    Q_D(const QQuickTransition);
    return d->fromState;
}
 
void QQuickTransition::setFromState(const QString &f)
{
    Q_D(QQuickTransition);
    if (f == d->fromState)
        return;
 
    d->fromState = f;
    emit fromChanged();
}
 
bool QQuickTransition::reversible() const
{
    Q_D(const QQuickTransition);
    return d->reversible;
}
 
void QQuickTransition::setReversible(bool r)
{
    Q_D(QQuickTransition);
    if (r == d->reversible)
        return;
 
    d->reversible = r;
    emit reversibleChanged();
}
 
QString QQuickTransition::toState() const
{
    Q_D(const QQuickTransition);
    return d->toState;
}
 
void QQuickTransition::setToState(const QString &t)
{
    Q_D(QQuickTransition);
    if (t == d->toState)
        return;
 
    d->toState = t;
    emit toChanged();
}
 
bool QQuickTransition::enabled() const
{
    Q_D(const QQuickTransition);
    return d->enabled;
}
 
void QQuickTransition::setEnabled(bool enabled)
{
    Q_D(QQuickTransition);
    if (d->enabled == enabled)
        return;
    d->enabled = enabled;
    emit enabledChanged();
}
 
bool QQuickTransition::running() const
{
    Q_D(const QQuickTransition);
    return d->runningInstanceCount;
}
 
 
QQmlListProperty<QQuickAbstractAnimation> QQuickTransition::animations()
{
    Q_D(QQuickTransition);
    return QQmlListProperty<QQuickAbstractAnimation>(this, &d->animations, QQuickTransitionPrivate::append_animation,
                                                                   QQuickTransitionPrivate::animation_count,
                                                                   QQuickTransitionPrivate::animation_at,
                                                                   QQuickTransitionPrivate::clear_animations);
}
 
QT_END_NAMESPACE
 
//#include <qquicktransition.moc>
 
#include "moc_qquicktransition_p.cpp"