qquickanimator.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 "qquickanimator_p_p.h"
#include "qquickanimatorjob_p.h"
 
#include <private/qquickitem_p.h>
 
QT_BEGIN_NAMESPACE
 
QQuickAnimator::QQuickAnimator(QQuickAnimatorPrivate &dd, QObject *parent)
    : QQuickAbstractAnimation(dd, parent)
{
}
 
QQuickAnimator::QQuickAnimator(QObject *parent)
    : QQuickAbstractAnimation(*new QQuickAnimatorPrivate, parent)
{
}
 
void QQuickAnimator::setTargetItem(QQuickItem *target)
{
    Q_D(QQuickAnimator);
    if (target == d->target)
        return;
    d->target = target;
    Q_EMIT targetItemChanged(d->target);
}
 
QQuickItem *QQuickAnimator::targetItem() const
{
    Q_D(const QQuickAnimator);
    return d->target;
}
 
void QQuickAnimator::setDuration(int duration)
{
    Q_D(QQuickAnimator);
    if (duration == d->duration)
        return;
    d->duration = duration;
    Q_EMIT durationChanged(duration);
}
 
int QQuickAnimator::duration() const
{
    Q_D(const QQuickAnimator);
    return d->duration;
}
 
void QQuickAnimator::setEasing(const QEasingCurve &easing)
{
    Q_D(QQuickAnimator);
    if (easing == d->easing)
        return;
    d->easing = easing;
    Q_EMIT easingChanged(d->easing);
}
 
QEasingCurve QQuickAnimator::easing() const
{
    Q_D(const QQuickAnimator);
    return d->easing;
}
 
void QQuickAnimator::setTo(qreal to)
{
    Q_D(QQuickAnimator);
    if (to == d->to)
        return;
    d->toIsDefined = true;
    d->to = to;
    Q_EMIT toChanged(d->to);
}
 
qreal QQuickAnimator::to() const
{
    Q_D(const QQuickAnimator);
    return d->to;
}
 
void QQuickAnimator::setFrom(qreal from)
{
    Q_D(QQuickAnimator);
    d->fromIsDefined = true;
    if (from == d->from)
        return;
    d->from = from;
    Q_EMIT fromChanged(d->from);
}
 
qreal QQuickAnimator::from() const
{
    Q_D(const QQuickAnimator);
    return d->from;
}
 
void QQuickAnimatorPrivate::apply(QQuickAnimatorJob *job,
                                     const QString &propertyName,
                                     QQuickStateActions &actions,
                                     QQmlProperties &modified,
                                     QObject *defaultTarget)
{
 
    if (actions.size()) {
        for (int i=0; i<actions.size(); ++i) {
            QQuickStateAction &action = actions[i];
            if (action.property.name() != propertyName)
                continue;
            modified << action.property;
 
            job->setTarget(qobject_cast<QQuickItem *>(action.property.object()));
 
            if (fromIsDefined)
                job->setFrom(from);
            else if (action.fromValue.isValid())
                job->setFrom(action.fromValue.toReal());
            else
                job->setFrom(action.property.read().toReal());
 
            if (toIsDefined)
                job->setTo(to);
            else if (action.toValue.isValid())
                job->setTo(action.toValue.toReal());
            else
                job->setTo(action.property.read().toReal());
 
            // This magic line is in sync with what PropertyAnimation does
            // and prevents the animation to end up in the "completeList"
            // which forces action.toValue to be written directly to
            // the item when a transition is cancelled.
            action.fromValue = action.toValue;
       }
    }
 
    if (modified.isEmpty()) {
        job->setTarget(target);
        if (fromIsDefined)
            job->setFrom(from);
        job->setTo(to);
    }
 
    if (!job->target()) {
        if (defaultProperty.object())
            job->setTarget(qobject_cast<QQuickItem *>(defaultProperty.object()));
        else
            job->setTarget(qobject_cast<QQuickItem *>(defaultTarget));
    }
 
    if (modified.isEmpty() && !fromIsDefined && job->target())
        job->setFrom(job->target()->property(propertyName.toLatin1()).toReal());
 
    job->setDuration(duration);
    job->setLoopCount(loopCount);
    job->setEasingCurve(easing);
}
 
QAbstractAnimationJob *QQuickAnimator::transition(QQuickStateActions &actions,
                                                  QQmlProperties &modified,
                                                  TransitionDirection direction,
                                                  QObject *defaultTarget)
{
    Q_D(QQuickAnimator);
 
    if (d->defaultProperty.isValid() && propertyName() != d->defaultProperty.name()) {
        qmlWarning(this) << "property name conflict: \""
            << propertyName() << "\" != \"" << d->defaultProperty.name() << "\"";
        return nullptr;
    }
 
    // The animation system cannot handle backwards uncontrolled animations.
    if (direction == Backward)
        return nullptr;
 
    QQuickAnimatorJob *job = createJob();
    if (!job)
        return nullptr;
 
    d->apply(job, propertyName(), actions, modified, defaultTarget);
 
    if (!job->target()) {
        delete job;
        return nullptr;
    }
 
    return job;
}
 
QQuickXAnimator::QQuickXAnimator(QObject *parent) : QQuickAnimator(parent) {}
 
QQuickAnimatorJob *QQuickXAnimator::createJob() const { return new QQuickXAnimatorJob(); }
 
QQuickYAnimator::QQuickYAnimator(QObject *parent) : QQuickAnimator(parent) {}
 
QQuickAnimatorJob *QQuickYAnimator::createJob() const { return new QQuickYAnimatorJob(); }
 
QQuickScaleAnimator::QQuickScaleAnimator(QObject *parent) : QQuickAnimator(parent) {}
 
QQuickAnimatorJob *QQuickScaleAnimator::createJob() const { return new QQuickScaleAnimatorJob(); }
 
QQuickOpacityAnimator::QQuickOpacityAnimator(QObject *parent) : QQuickAnimator(parent) {}
 
QQuickAnimatorJob *QQuickOpacityAnimator::createJob() const { return new QQuickOpacityAnimatorJob(); }
 
QQuickRotationAnimator::QQuickRotationAnimator(QObject *parent)
    : QQuickAnimator(*new QQuickRotationAnimatorPrivate, parent)
{
}
 
QQuickAnimatorJob *QQuickRotationAnimator::createJob() const {
    Q_D(const QQuickRotationAnimator);
    QQuickRotationAnimatorJob *job = new QQuickRotationAnimatorJob();
    job->setDirection(d->direction);
    return job;
}
 
void QQuickRotationAnimator::setDirection(RotationDirection dir)
{
    Q_D(QQuickRotationAnimator);
    if (d->direction == dir)
        return;
    d->direction = dir;
    Q_EMIT directionChanged(d->direction);
}
 
QQuickRotationAnimator::RotationDirection QQuickRotationAnimator::direction() const
{
    Q_D(const QQuickRotationAnimator);
    return d->direction;
}
 
#if QT_CONFIG(quick_shadereffect)
QQuickUniformAnimator::QQuickUniformAnimator(QObject *parent)
    : QQuickAnimator(*new QQuickUniformAnimatorPrivate, parent)
{
}
 
void QQuickUniformAnimator::setUniform(const QString &uniform)
{
    Q_D(QQuickUniformAnimator);
    if (d->uniform == uniform)
        return;
    d->uniform = uniform;
    Q_EMIT uniformChanged(d->uniform);
}
 
QString QQuickUniformAnimator::uniform() const
{
    Q_D(const QQuickUniformAnimator);
    return d->uniform;
}
 
QString QQuickUniformAnimator::propertyName() const
{
    Q_D(const QQuickUniformAnimator);
    if (!d->uniform.isEmpty())
        return d->uniform;
    return d->defaultProperty.name();
}
 
QQuickAnimatorJob *QQuickUniformAnimator::createJob() const
{
    QString u = propertyName();
    if (u.isEmpty())
        return nullptr;
 
    QQuickUniformAnimatorJob *job = new QQuickUniformAnimatorJob();
    job->setUniform(u.toLatin1());
    return job;
}
#endif
 
QT_END_NAMESPACE
 
#include "moc_qquickanimator_p.cpp"