qvariantanimation.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 "qvariantanimation.h"
#include "qvariantanimation_p.h"
 
#include <QtCore/qrect.h>
#include <QtCore/qline.h>
#include <QtCore/qmutex.h>
#include <QtCore/private/qlocking_p.h>
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
void QVariantAnimation::updateCurrentValue(const QVariant &) {}
 
static bool animationValueLessThan(const QVariantAnimation::KeyValue &p1, const QVariantAnimation::KeyValue &p2)
{
    return p1.first < p2.first;
}
 
static QVariant defaultInterpolator(const void *, const void *, qreal)
{
    return QVariant();
}
 
template<> Q_INLINE_TEMPLATE QRect _q_interpolate(const QRect &f, const QRect &t, qreal progress)
{
    QRect ret;
    ret.setCoords(_q_interpolate(f.left(), t.left(), progress),
                  _q_interpolate(f.top(), t.top(), progress),
                  _q_interpolate(f.right(), t.right(), progress),
                  _q_interpolate(f.bottom(), t.bottom(), progress));
    return ret;
}
 
template<> Q_INLINE_TEMPLATE QRectF _q_interpolate(const QRectF &f, const QRectF &t, qreal progress)
{
    qreal x1, y1, w1, h1;
    f.getRect(&x1, &y1, &w1, &h1);
    qreal x2, y2, w2, h2;
    t.getRect(&x2, &y2, &w2, &h2);
    return QRectF(_q_interpolate(x1, x2, progress), _q_interpolate(y1, y2, progress),
                  _q_interpolate(w1, w2, progress), _q_interpolate(h1, h2, progress));
}
 
template<> Q_INLINE_TEMPLATE QLine _q_interpolate(const QLine &f, const QLine &t, qreal progress)
{
    return QLine( _q_interpolate(f.p1(), t.p1(), progress), _q_interpolate(f.p2(), t.p2(), progress));
}
 
template<> Q_INLINE_TEMPLATE QLineF _q_interpolate(const QLineF &f, const QLineF &t, qreal progress)
{
    return QLineF( _q_interpolate(f.p1(), t.p1(), progress), _q_interpolate(f.p2(), t.p2(), progress));
}
 
QVariantAnimationPrivate::QVariantAnimationPrivate() : duration(250), interpolator(&defaultInterpolator)
{ }
 
void QVariantAnimationPrivate::convertValues(int t)
{
    auto type = QMetaType(t);
    //this ensures that all the keyValues are of type t
    for (int i = 0; i < keyValues.size(); ++i) {
        QVariantAnimation::KeyValue &pair = keyValues[i];
        pair.second.convert(type);
    }
    //we also need update to the current interval if needed
    currentInterval.start.second.convert(type);
    currentInterval.end.second.convert(type);
 
    //... and the interpolator
    updateInterpolator();
}
 
void QVariantAnimationPrivate::updateInterpolator()
{
    int type = currentInterval.start.second.userType();
    if (type == currentInterval.end.second.userType())
        interpolator = getInterpolator(type);
    else
        interpolator = nullptr;
 
    //we make sure that the interpolator is always set to something
    if (!interpolator)
        interpolator = &defaultInterpolator;
}
 
void QVariantAnimationPrivate::recalculateCurrentInterval(bool force/*=false*/)
{
    // can't interpolate if we don't have at least 2 values
    if ((keyValues.size() + (defaultStartEndValue.isValid() ? 1 : 0)) < 2)
        return;
 
    const qreal endProgress = (direction == QAbstractAnimation::Forward) ? qreal(1) : qreal(0);
    const qreal progress = easing.value().valueForProgress(
            duration == 0 ? endProgress : qreal(currentTime) / qreal(duration));
 
    //0 and 1 are still the boundaries
    if (force || (currentInterval.start.first > 0 && progress < currentInterval.start.first)
        || (currentInterval.end.first < 1 && progress > currentInterval.end.first)) {
        //let's update currentInterval
        QVariantAnimation::KeyValues::const_iterator it = std::lower_bound(keyValues.constBegin(),
                                                                           keyValues.constEnd(),
                                                                           std::pair{progress, QVariant{}},
                                                                           animationValueLessThan);
        if (it == keyValues.constBegin()) {
            //the item pointed to by it is the start element in the range
            if (it->first == 0 && keyValues.size() > 1) {
                currentInterval.start = *it;
                currentInterval.end = *(it+1);
            } else {
                currentInterval.start = {qreal(0), defaultStartEndValue};
                currentInterval.end = *it;
            }
        } else if (it == keyValues.constEnd()) {
            --it; //position the iterator on the last item
            if (it->first == 1 && keyValues.size() > 1) {
                //we have an end value (item with progress = 1)
                currentInterval.start = *(it-1);
                currentInterval.end = *it;
            } else {
                //we use the default end value here
                currentInterval.start = *it;
                currentInterval.end = {qreal(1), defaultStartEndValue};
            }
        } else {
            currentInterval.start = *(it-1);
            currentInterval.end = *it;
        }
 
        // update all the values of the currentInterval
        updateInterpolator();
    }
    setCurrentValueForProgress(progress);
}
 
void QVariantAnimationPrivate::setCurrentValueForProgress(const qreal progress)
{
    Q_Q(QVariantAnimation);
 
    const qreal startProgress = currentInterval.start.first;
    const qreal endProgress = currentInterval.end.first;
    const qreal localProgress =
            qIsNull(progress - startProgress) ? 0.0 // avoid 0/0 below
            /* else */                        : (progress - startProgress) / (endProgress - startProgress);
 
    QVariant ret = q->interpolated(currentInterval.start.second,
                                   currentInterval.end.second,
                                   localProgress);
    qSwap(currentValue, ret);
    q->updateCurrentValue(currentValue);
    Q_CONSTINIT static QBasicAtomicInt changedSignalIndex = Q_BASIC_ATOMIC_INITIALIZER(0);
    if (!changedSignalIndex.loadRelaxed()) {
        //we keep the mask so that we emit valueChanged only when needed (for performance reasons)
        changedSignalIndex.testAndSetRelaxed(0, signalIndex("valueChanged(QVariant)"));
    }
    if (isSignalConnected(changedSignalIndex.loadRelaxed()) && currentValue != ret) {
        //the value has changed
        emit q->valueChanged(currentValue);
    }
}
 
QVariant QVariantAnimationPrivate::valueAt(qreal step) const
{
    const auto sought = std::pair{step, QVariant()};
    const auto result = std::lower_bound(keyValues.cbegin(), keyValues.cend(), sought,
                                         animationValueLessThan);
    if (result != keyValues.cend() && !animationValueLessThan(sought, *result))
        return result->second;
 
    return QVariant();
}
 
void QVariantAnimationPrivate::setValueAt(qreal step, const QVariant &value)
{
    if (step < qreal(0.0) || step > qreal(1.0)) {
        qWarning("QVariantAnimation::setValueAt: invalid step = %f", step);
        return;
    }
 
    QVariantAnimation::KeyValue pair(step, value);
 
    QVariantAnimation::KeyValues::iterator result = std::lower_bound(keyValues.begin(), keyValues.end(), pair, animationValueLessThan);
    if (result == keyValues.end() || result->first != step) {
        keyValues.insert(result, pair);
    } else {
        if (value.isValid())
            result->second = value; // replaces the previous value
        else
            keyValues.erase(result); // removes the previous value
    }
 
    recalculateCurrentInterval(/*force=*/true);
}
 
void QVariantAnimationPrivate::setDefaultStartEndValue(const QVariant &value)
{
    defaultStartEndValue = value;
    recalculateCurrentInterval(/*force=*/true);
}
 
QVariantAnimation::QVariantAnimation(QObject *parent) : QAbstractAnimation(*new QVariantAnimationPrivate, parent)
{
}
 
QVariantAnimation::QVariantAnimation(QVariantAnimationPrivate &dd, QObject *parent) : QAbstractAnimation(dd, parent)
{
}
 
QVariantAnimation::~QVariantAnimation()
{
}
 
QEasingCurve QVariantAnimation::easingCurve() const
{
    Q_D(const QVariantAnimation);
    return d->easing;
}
 
void QVariantAnimation::setEasingCurve(const QEasingCurve &easing)
{
    Q_D(QVariantAnimation);
    d->easing.removeBindingUnlessInWrapper();
    const bool valueChanged = easing != d->easing.valueBypassingBindings();
    d->easing.setValueBypassingBindings(easing);
    d->recalculateCurrentInterval();
    if (valueChanged)
        d->easing.notify();
}
 
QBindable<QEasingCurve> QVariantAnimation::bindableEasingCurve()
{
    Q_D(QVariantAnimation);
    return &d->easing;
}
 
typedef QList<QVariantAnimation::Interpolator> QInterpolatorVector;
Q_GLOBAL_STATIC(QInterpolatorVector, registeredInterpolators)
Q_CONSTINIT static QBasicMutex registeredInterpolatorsMutex;
 
void QVariantAnimation::registerInterpolator(QVariantAnimation::Interpolator func, int interpolationType)
{
    // will override any existing interpolators
    QInterpolatorVector *interpolators = registeredInterpolators();
    // When built on solaris with GCC, the destructors can be called
    // in such an order that we get here with interpolators == NULL,
    // to continue causes the app to crash on exit with a SEGV
    if (interpolators) {
        const auto locker = qt_scoped_lock(registeredInterpolatorsMutex);
        if (interpolationType >= interpolators->size())
            interpolators->resize(interpolationType + 1);
        interpolators->replace(interpolationType, func);
    }
}
 
 
template<typename T> static inline QVariantAnimation::Interpolator castToInterpolator(QVariant (*func)(const T &from, const T &to, qreal progress))
{
     return reinterpret_cast<QVariantAnimation::Interpolator>(reinterpret_cast<void(*)()>(func));
}
 
QVariantAnimation::Interpolator QVariantAnimationPrivate::getInterpolator(int interpolationType)
{
    {
        QInterpolatorVector *interpolators = registeredInterpolators();
        const auto locker = qt_scoped_lock(registeredInterpolatorsMutex);
        QVariantAnimation::Interpolator ret = nullptr;
        if (interpolationType < interpolators->size()) {
            ret = interpolators->at(interpolationType);
            if (ret) return ret;
        }
    }
 
    switch(interpolationType)
    {
    case QMetaType::Int:
        return castToInterpolator(_q_interpolateVariant<int>);
    case QMetaType::UInt:
        return castToInterpolator(_q_interpolateVariant<uint>);
    case QMetaType::Double:
        return castToInterpolator(_q_interpolateVariant<double>);
    case QMetaType::Float:
        return castToInterpolator(_q_interpolateVariant<float>);
    case QMetaType::QLine:
        return castToInterpolator(_q_interpolateVariant<QLine>);
    case QMetaType::QLineF:
        return castToInterpolator(_q_interpolateVariant<QLineF>);
    case QMetaType::QPoint:
        return castToInterpolator(_q_interpolateVariant<QPoint>);
    case QMetaType::QPointF:
        return castToInterpolator(_q_interpolateVariant<QPointF>);
    case QMetaType::QSize:
        return castToInterpolator(_q_interpolateVariant<QSize>);
    case QMetaType::QSizeF:
        return castToInterpolator(_q_interpolateVariant<QSizeF>);
    case QMetaType::QRect:
        return castToInterpolator(_q_interpolateVariant<QRect>);
    case QMetaType::QRectF:
        return castToInterpolator(_q_interpolateVariant<QRectF>);
    default:
        return nullptr; //this type is not handled
    }
}
 
int QVariantAnimation::duration() const
{
    Q_D(const QVariantAnimation);
    return d->duration;
}
 
void QVariantAnimation::setDuration(int msecs)
{
    Q_D(QVariantAnimation);
    if (msecs < 0) {
        qWarning("QVariantAnimation::setDuration: cannot set a negative duration");
        return;
    }
    d->duration.removeBindingUnlessInWrapper();
    if (d->duration.valueBypassingBindings() != msecs) {
        d->duration.setValueBypassingBindings(msecs);
        d->recalculateCurrentInterval();
        d->duration.notify();
    }
}
 
QBindable<int> QVariantAnimation::bindableDuration()
{
    Q_D(QVariantAnimation);
    return &d->duration;
}
 
QVariant QVariantAnimation::startValue() const
{
    return keyValueAt(0);
}
 
void QVariantAnimation::setStartValue(const QVariant &value)
{
    setKeyValueAt(0, value);
}
 
QVariant QVariantAnimation::endValue() const
{
    return keyValueAt(1);
}
 
void QVariantAnimation::setEndValue(const QVariant &value)
{
    setKeyValueAt(1, value);
}
 
 
QVariant QVariantAnimation::keyValueAt(qreal step) const
{
    return d_func()->valueAt(step);
}
 
void QVariantAnimation::setKeyValueAt(qreal step, const QVariant &value)
{
    d_func()->setValueAt(step, value);
}
 
QVariantAnimation::KeyValues QVariantAnimation::keyValues() const
{
    return d_func()->keyValues;
}
 
void QVariantAnimation::setKeyValues(const KeyValues &keyValues)
{
    Q_D(QVariantAnimation);
    d->keyValues = keyValues;
    std::sort(d->keyValues.begin(), d->keyValues.end(), animationValueLessThan);
    d->recalculateCurrentInterval(/*force=*/true);
}
 
QVariant QVariantAnimation::currentValue() const
{
    Q_D(const QVariantAnimation);
    if (!d->currentValue.isValid())
        const_cast<QVariantAnimationPrivate*>(d)->recalculateCurrentInterval();
    return d->currentValue;
}
 
bool QVariantAnimation::event(QEvent *event)
{
    return QAbstractAnimation::event(event);
}
 
void QVariantAnimation::updateState(QAbstractAnimation::State newState,
                                    QAbstractAnimation::State oldState)
{
    Q_UNUSED(oldState);
    Q_UNUSED(newState);
}
 
QVariant QVariantAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const
{
    return d_func()->interpolator(from.constData(), to.constData(), progress);
}
 
void QVariantAnimation::updateCurrentTime(int)
{
    d_func()->recalculateCurrentInterval();
}
 
QT_END_NAMESPACE
 
#include "moc_qvariantanimation.cpp"