QskVariantAnimator.cpp

/******************************************************************************
 * QSkinny - Copyright (C) The authors
 *           SPDX-License-Identifier: BSD-3-Clause
 *****************************************************************************/
 
#include "QskVariantAnimator.h"
#include "QskArcMetrics.h"
#include "QskBoxBorderColors.h"
#include "QskBoxBorderMetrics.h"
#include "QskBoxShapeMetrics.h"
#include "QskShadowMetrics.h"
#include "QskStippleMetrics.h"
#include "QskGraduationMetrics.h"
#include "QskColorFilter.h"
#include "QskGradient.h"
#include "QskMargins.h"
#include "QskIntervalF.h"
#include "QskTextColors.h"
#include "QskInternalMacros.h"
 
// Even if we don't use the standard Qt animation system we
// use its registry of interpolators: why adding our own ...
 
#include <qvariantanimation.h>
 
QSK_QT_PRIVATE_BEGIN
 
#if QT_VERSION >= QT_VERSION_CHECK( 6, 2, 0 )
    #ifndef emit
        #define emit
        #include <private/qabstractanimation_p.h>
        #undef emit
    #endif
#endif
 
#include <private/qvariantanimation_p.h>
 
QSK_QT_PRIVATE_END
 
#if 1
static void qskRegisterInterpolator()
{
    qRegisterAnimationInterpolator< QskColorFilter >( QskColorFilter::interpolate );
    qRegisterAnimationInterpolator< QskIntervalF >( QskIntervalF::interpolate );
    qRegisterAnimationInterpolator< QskMargins >( QskMargins::interpolate );
    qRegisterAnimationInterpolator< QskGradient >( QskGradient::interpolate );
    qRegisterAnimationInterpolator< QskBoxShapeMetrics >( QskBoxShapeMetrics::interpolate );
    qRegisterAnimationInterpolator< QskBoxBorderMetrics >( QskBoxBorderMetrics::interpolate );
    qRegisterAnimationInterpolator< QskBoxBorderColors >( QskBoxBorderColors::interpolate );
    qRegisterAnimationInterpolator< QskTextColors >( QskTextColors::interpolate );
    qRegisterAnimationInterpolator< QskShadowMetrics >( QskShadowMetrics::interpolate );
    qRegisterAnimationInterpolator< QskStippleMetrics >( QskStippleMetrics::interpolate );
    qRegisterAnimationInterpolator< QskArcMetrics >( QskArcMetrics::interpolate );
    qRegisterAnimationInterpolator< QskGraduationMetrics >( QskGraduationMetrics::interpolate );
}
 
Q_CONSTRUCTOR_FUNCTION( qskRegisterInterpolator )
#endif
 
#if defined( Q_CC_CLANG )
    #if __has_feature( address_sanitizer )
        #define QSK_DECL_INSANE __attribute__( ( no_sanitize( "undefined" ) ) )
    #endif
#endif
 
#if !defined( QSK_DECL_INSANE )
    #define QSK_DECL_INSANE
#endif
 
QSK_DECL_INSANE static inline QVariant qskInterpolate(
    void ( *interpolator )(), const QVariant& from, const QVariant& to, qreal progress )
{
#if 1
    /*
        how to get rid of the reported runtime error from the clang sanitizer,
        when calling F( const T&, ... ) as G( const void* ... ); TODO ...
     */
#endif
 
    auto f = reinterpret_cast< QVariantAnimation::Interpolator >( interpolator );
    return f( from.constData(), to.constData(), progress );
}
 
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
 
using QskMetaType = int;
static inline QskMetaType qskMetaType( const QVariant& v ) { return v.userType(); }
 
#else
 
using QskMetaType = QMetaType;
static inline QskMetaType qskMetaType( const QVariant& v ) { return v.metaType(); }
 
#endif
 
static inline QVariant qskDefaultVariant( QskMetaType type )
{
    return QVariant( type, nullptr );
}
 
static inline QVariant qskConvertedVariant( const QVariant& from, QskMetaType type )
{
    auto v = from;
    v.convert( type );
 
    return v;
}
 
QskVariantAnimator::QskVariantAnimator()
    : m_interpolator( nullptr )
{
}
 
QskVariantAnimator::~QskVariantAnimator()
{
}
 
void QskVariantAnimator::setStartValue( const QVariant& value )
{
    stop();
    m_startValue = value;
}
 
void QskVariantAnimator::setEndValue( const QVariant& value )
{
    stop();
    m_endValue = value;
}
 
void QskVariantAnimator::setCurrentValue( const QVariant& value )
{
    m_currentValue = value;
}
 
bool QskVariantAnimator::convertValues( QVariant& v1, QVariant& v2 )
{
    if ( !v1.isValid() && !v2.isValid() )
        return false;
 
    const auto type1 = qskMetaType( v1 );
    const auto type2 = qskMetaType( v2 );
 
    if ( !v1.isValid() )
    {
        v1 = qskDefaultVariant( type2 );
        return true;
    }
 
    if ( !v2.isValid() )
    {
        v2 = qskDefaultVariant( type1 );
        return true;
    }
 
    if ( type1 != type2 )
    {
        if ( v1.canConvert( type2 ) )
        {
            v1.convert( type2 );
            return true;
        }
 
        if ( v2.canConvert( type1 ) )
        {
            v2.convert( type1 );
            return true;
        }
 
        return false;
    }
 
    return true;
}
 
void QskVariantAnimator::setup()
{
    m_interpolator = nullptr;
 
    if ( convertValues( m_startValue, m_endValue ) )
    {
        if ( m_startValue != m_endValue )
        {
            const auto id = m_startValue.userType();
 
            // all what has been registered by qRegisterAnimationInterpolator
            m_interpolator = reinterpret_cast< void ( * )() >(
                QVariantAnimationPrivate::getInterpolator( id ) );
        }
    }
 
    m_currentValue = m_interpolator ? m_startValue : m_endValue;
}
 
void QskVariantAnimator::advance( qreal progress )
{
    if ( m_interpolator )
    {
        if ( qFuzzyCompare( progress, 1.0 ) )
            progress = 1.0;
 
        Q_ASSERT( qskMetaType( m_startValue ) == qskMetaType( m_endValue ) );
 
        m_currentValue = qskInterpolate( m_interpolator,
            m_startValue, m_endValue, progress );
    }
}
 
void QskVariantAnimator::done()
{
    m_interpolator = nullptr;
}
 
bool QskVariantAnimator::maybeInterpolate(
    const QVariant& value1, const QVariant& value2, bool acceptIdentity )
{
    if ( !value1.isValid() && !value2.isValid() )
        return false;
 
    if ( acceptIdentity )
    {
        if ( value1.isValid() && value2.isValid() )
        {
            const auto type1 = qskMetaType( value1 );
            const auto type2 = qskMetaType( value2 );
 
            if ( type1 != type2 )
                return value1.canConvert( type2 ) || value2.canConvert( type1 );
        }
 
        return true;
    }
    else
    {
        const auto type1 = qskMetaType( value1 );
        const auto type2 = qskMetaType( value2 );
 
        if ( !value1.isValid() )
            return value2 != qskDefaultVariant( type2 );
 
        if ( !value2.isValid() )
            return value1 != qskDefaultVariant( type1 );
 
        if ( type1 != type2 )
        {
            if ( value1.canConvert( type2 ) )
                return value2 != qskConvertedVariant( value1, type2 );
 
            if ( value2.canConvert( type1 ) )
                return value1 != qskConvertedVariant( value2, type1 );
 
            return false;
        }
 
        return value1 != value2;
    }
}