qgraphicsitemanimation.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 "qgraphicsitemanimation.h"
 
#include "qgraphicsitem.h"
 
#include <QtCore/qtimeline.h>
#include <QtCore/qpoint.h>
#include <QtCore/qpointer.h>
#include <QtCore/qpair.h>
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
static inline bool check_step_valid(qreal step, const char *method)
{
    if (!(step >= 0 && step <= 1)) {
        qWarning("QGraphicsItemAnimation::%s: invalid step = %f", method, step);
        return false;
    }
    return true;
}
 
class QGraphicsItemAnimationPrivate
{
public:
    inline QGraphicsItemAnimationPrivate()
        : q(nullptr), timeLine(nullptr), item(nullptr), step(0)
    { }
 
    QGraphicsItemAnimation *q;
 
    QPointer<QTimeLine> timeLine;
    QGraphicsItem *item;
 
    QPointF startPos;
    QTransform startTransform;
 
    qreal step;
 
    struct Pair {
        bool operator <(const Pair &other) const
        { return step < other.step; }
        bool operator==(const Pair &other) const
        { return step == other.step; }
        qreal step;
        qreal value;
    };
    QList<Pair> xPosition;
    QList<Pair> yPosition;
    QList<Pair> rotation;
    QList<Pair> verticalScale;
    QList<Pair> horizontalScale;
    QList<Pair> verticalShear;
    QList<Pair> horizontalShear;
    QList<Pair> xTranslation;
    QList<Pair> yTranslation;
 
    qreal linearValueForStep(qreal step, const QList<Pair> &source, qreal defaultValue = 0);
    void insertUniquePair(qreal step, qreal value, QList<Pair> *binList, const char *method);
};
Q_DECLARE_TYPEINFO(QGraphicsItemAnimationPrivate::Pair, Q_PRIMITIVE_TYPE);
 
qreal QGraphicsItemAnimationPrivate::linearValueForStep(qreal step, const QList<Pair> &source,
                                                        qreal defaultValue)
{
    if (source.isEmpty())
        return defaultValue;
    step = qMin<qreal>(qMax<qreal>(step, 0), 1);
 
    if (step == 1)
        return source.back().value;
 
    qreal stepBefore = 0;
    qreal stepAfter = 1;
    qreal valueBefore = source.front().step == 0 ? source.front().value : defaultValue;
    qreal valueAfter = source.back().value;
 
    // Find the closest step and value before the given step.
    for (int i = 0; i < source.size() && step >= source[i].step; ++i) {
        stepBefore = source[i].step;
        valueBefore = source[i].value;
    }
 
    // Find the closest step and value after the given step.
    for (int i = source.size() - 1; i >= 0 && step < source[i].step; --i) {
        stepAfter = source[i].step;
        valueAfter = source[i].value;
    }
 
    // Do a simple linear interpolation.
    return valueBefore + (valueAfter - valueBefore) * ((step - stepBefore) / (stepAfter - stepBefore));
}
 
void QGraphicsItemAnimationPrivate::insertUniquePair(qreal step, qreal value, QList<Pair> *binList,
                                                     const char *method)
{
    if (!check_step_valid(step, method))
        return;
 
    const Pair pair = { step, value };
 
    const QList<Pair>::iterator result = std::lower_bound(binList->begin(), binList->end(), pair);
    if (result == binList->end() || pair < *result)
        binList->insert(result, pair);
    else
        result->value = value;
}
 
QGraphicsItemAnimation::QGraphicsItemAnimation(QObject *parent)
    : QObject(parent), d(new QGraphicsItemAnimationPrivate)
{
    d->q = this;
}
 
QGraphicsItemAnimation::~QGraphicsItemAnimation()
{
    delete d;
}
 
QGraphicsItem *QGraphicsItemAnimation::item() const
{
    return d->item;
}
 
void QGraphicsItemAnimation::setItem(QGraphicsItem *item)
{
    d->item = item;
    d->startPos = d->item->pos();
}
 
QTimeLine *QGraphicsItemAnimation::timeLine() const
{
    return d->timeLine;
}
 
void QGraphicsItemAnimation::setTimeLine(QTimeLine *timeLine)
{
    if (d->timeLine == timeLine)
        return;
    if (d->timeLine)
        delete d->timeLine;
    if (!timeLine)
        return;
    d->timeLine = timeLine;
    connect(timeLine, SIGNAL(valueChanged(qreal)), this, SLOT(setStep(qreal)));
}
 
QPointF QGraphicsItemAnimation::posAt(qreal step) const
{
    check_step_valid(step, "posAt");
    return QPointF(d->linearValueForStep(step, d->xPosition, d->startPos.x()),
                   d->linearValueForStep(step, d->yPosition, d->startPos.y()));
}
 
void QGraphicsItemAnimation::setPosAt(qreal step, const QPointF &pos)
{
    d->insertUniquePair(step, pos.x(), &d->xPosition, "setPosAt");
    d->insertUniquePair(step, pos.y(), &d->yPosition, "setPosAt");
}
 
QList<QPair<qreal, QPointF> > QGraphicsItemAnimation::posList() const
{
    QList<QPair<qreal, QPointF> > list;
    const int xPosCount = d->xPosition.size();
    list.reserve(xPosCount);
    for (int i = 0; i < xPosCount; ++i)
        list << QPair<qreal, QPointF>(d->xPosition.at(i).step, QPointF(d->xPosition.at(i).value, d->yPosition.at(i).value));
 
    return list;
}
 
QTransform QGraphicsItemAnimation::transformAt(qreal step) const
{
    check_step_valid(step, "transformAt");
 
    QTransform transform;
    if (!d->rotation.isEmpty())
        transform.rotate(rotationAt(step));
    if (!d->verticalScale.isEmpty())
        transform.scale(horizontalScaleAt(step), verticalScaleAt(step));
    if (!d->verticalShear.isEmpty())
        transform.shear(horizontalShearAt(step), verticalShearAt(step));
    if (!d->xTranslation.isEmpty())
        transform.translate(xTranslationAt(step), yTranslationAt(step));
    return transform;
}
 
qreal QGraphicsItemAnimation::rotationAt(qreal step) const
{
    check_step_valid(step, "rotationAt");
    return d->linearValueForStep(step, d->rotation);
}
 
void QGraphicsItemAnimation::setRotationAt(qreal step, qreal angle)
{
    d->insertUniquePair(step, angle, &d->rotation, "setRotationAt");
}
 
QList<QPair<qreal, qreal> > QGraphicsItemAnimation::rotationList() const
{
    QList<QPair<qreal, qreal> > list;
    const int numRotations = d->rotation.size();
    list.reserve(numRotations);
    for (int i = 0; i < numRotations; ++i)
        list << QPair<qreal, qreal>(d->rotation.at(i).step, d->rotation.at(i).value);
 
    return list;
}
 
qreal QGraphicsItemAnimation::xTranslationAt(qreal step) const
{
    check_step_valid(step, "xTranslationAt");
    return d->linearValueForStep(step, d->xTranslation);
}
 
qreal QGraphicsItemAnimation::yTranslationAt(qreal step) const
{
    check_step_valid(step, "yTranslationAt");
    return d->linearValueForStep(step, d->yTranslation);
}
 
void QGraphicsItemAnimation::setTranslationAt(qreal step, qreal dx, qreal dy)
{
    d->insertUniquePair(step, dx, &d->xTranslation, "setTranslationAt");
    d->insertUniquePair(step, dy, &d->yTranslation, "setTranslationAt");
}
 
QList<QPair<qreal, QPointF> > QGraphicsItemAnimation::translationList() const
{
    QList<QPair<qreal, QPointF> > list;
    const int numTranslations = d->xTranslation.size();
    list.reserve(numTranslations);
    for (int i = 0; i < numTranslations; ++i)
        list << QPair<qreal, QPointF>(d->xTranslation.at(i).step, QPointF(d->xTranslation.at(i).value, d->yTranslation.at(i).value));
 
    return list;
}
 
qreal QGraphicsItemAnimation::verticalScaleAt(qreal step) const
{
    check_step_valid(step, "verticalScaleAt");
 
    return d->linearValueForStep(step, d->verticalScale, 1);
}
 
qreal QGraphicsItemAnimation::horizontalScaleAt(qreal step) const
{
    check_step_valid(step, "horizontalScaleAt");
    return d->linearValueForStep(step, d->horizontalScale, 1);
}
 
void QGraphicsItemAnimation::setScaleAt(qreal step, qreal sx, qreal sy)
{
    d->insertUniquePair(step, sx, &d->horizontalScale, "setScaleAt");
    d->insertUniquePair(step, sy, &d->verticalScale, "setScaleAt");
}
 
QList<QPair<qreal, QPointF> > QGraphicsItemAnimation::scaleList() const
{
    QList<QPair<qreal, QPointF> > list;
    const int numScales = d->horizontalScale.size();
    list.reserve(numScales);
    for (int i = 0; i < numScales; ++i)
        list << QPair<qreal, QPointF>(d->horizontalScale.at(i).step, QPointF(d->horizontalScale.at(i).value, d->verticalScale.at(i).value));
 
    return list;
}
 
qreal QGraphicsItemAnimation::verticalShearAt(qreal step) const
{
    check_step_valid(step, "verticalShearAt");
    return d->linearValueForStep(step, d->verticalShear, 0);
}
 
qreal QGraphicsItemAnimation::horizontalShearAt(qreal step) const
{
    check_step_valid(step, "horizontalShearAt");
    return d->linearValueForStep(step, d->horizontalShear, 0);
}
 
void QGraphicsItemAnimation::setShearAt(qreal step, qreal sh, qreal sv)
{
    d->insertUniquePair(step, sh, &d->horizontalShear, "setShearAt");
    d->insertUniquePair(step, sv, &d->verticalShear, "setShearAt");
}
 
QList<QPair<qreal, QPointF> > QGraphicsItemAnimation::shearList() const
{
    QList<QPair<qreal, QPointF> > list;
    const int numShears = d->horizontalShear.size();
    list.reserve(numShears);
    for (int i = 0; i < numShears; ++i)
        list << QPair<qreal, QPointF>(d->horizontalShear.at(i).step, QPointF(d->horizontalShear.at(i).value, d->verticalShear.at(i).value));
 
    return list;
}
 
void QGraphicsItemAnimation::clear()
{
    d->xPosition.clear();
    d->yPosition.clear();
    d->rotation.clear();
    d->verticalScale.clear();
    d->horizontalScale.clear();
    d->verticalShear.clear();
    d->horizontalShear.clear();
    d->xTranslation.clear();
    d->yTranslation.clear();
}
 
void QGraphicsItemAnimation::setStep(qreal step)
{
    if (!check_step_valid(step, "setStep"))
        return;
 
    beforeAnimationStep(step);
 
    d->step = step;
    if (d->item) {
        if (!d->xPosition.isEmpty() || !d->yPosition.isEmpty())
            d->item->setPos(posAt(step));
        if (!d->rotation.isEmpty()
            || !d->verticalScale.isEmpty()
            || !d->horizontalScale.isEmpty()
            || !d->verticalShear.isEmpty()
            || !d->horizontalShear.isEmpty()
            || !d->xTranslation.isEmpty()
            || !d->yTranslation.isEmpty()) {
            d->item->setTransform(d->startTransform * transformAt(step));
        }
    }
 
    afterAnimationStep(step);
}
 
void QGraphicsItemAnimation::beforeAnimationStep(qreal step)
{
    Q_UNUSED(step);
}
 
void QGraphicsItemAnimation::afterAnimationStep(qreal step)
{
    Q_UNUSED(step);
}
 
QT_END_NAMESPACE
 
#include "moc_qgraphicsitemanimation.cpp"