QskShadowMetrics.cpp

/******************************************************************************
 * QSkinny - Copyright (C) The authors
 *           SPDX-License-Identifier: BSD-3-Clause
 *****************************************************************************/
 
#include "QskShadowMetrics.h"
 
#include <qhashfunctions.h>
#include <qrect.h>
#include <qvariant.h>
 
static void qskRegisterShadowMetrics()
{
    qRegisterMetaType< QskShadowMetrics >();
 
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
    QMetaType::registerEqualsComparator< QskShadowMetrics >();
#endif
}
 
Q_CONSTRUCTOR_FUNCTION( qskRegisterShadowMetrics )
 
static inline qreal qskInterpolated( qreal from, qreal to, qreal ratio )
{
    return from + ( to - from ) * ratio;
}
 
static inline qreal qskToAbsolute( qreal length, qreal percentage )
{
    percentage = qBound( 0.0, percentage, 100.0 );
    return percentage / 100.0 * length;
}
 
QskShadowMetrics QskShadowMetrics::toAbsolute( const QSizeF& size ) const noexcept
{
    if ( m_sizeMode != Qt::RelativeSize )
        return *this;
 
    if ( size.isEmpty() )
        return QskShadowMetrics( 0.0, 0.0, QPointF() );
 
    const qreal length = std::max( size.width(), size.height() );
 
    const qreal spreadRadius = qskToAbsolute( length, m_spreadRadius );
    const qreal blurRadius = qskToAbsolute( length, m_spreadRadius );
    const qreal dx = qskToAbsolute( size.width(), m_offset.x() );
    const qreal dy = qskToAbsolute( size.height(), m_offset.x() );
 
    return QskShadowMetrics( spreadRadius, blurRadius, QPointF( dx, dy ) );
}
 
QskShadowMetrics QskShadowMetrics::interpolated(
    const QskShadowMetrics& to, qreal ratio ) const noexcept
{
    if ( ( *this == to ) || ( m_sizeMode != to.m_sizeMode ) )
        return to;
 
    const QPointF offset(
        qskInterpolated( m_offset.x(), to.m_offset.x(), ratio ),
        qskInterpolated( m_offset.y(), to.m_offset.y(), ratio ) );
 
    QskShadowMetrics metrics(
        qskInterpolated( m_spreadRadius, to.m_spreadRadius, ratio ),
        qskInterpolated( m_blurRadius, to.m_blurRadius, ratio ),
        offset );
    metrics.m_sizeMode = m_sizeMode;
 
    return metrics;
}
 
QVariant QskShadowMetrics::interpolate(
    const QskShadowMetrics& from, const QskShadowMetrics& to,
    qreal progress )
{
    return QVariant::fromValue( from.interpolated( to, progress ) );
}
 
QRectF QskShadowMetrics::shadowRect( const QRectF& sourceRect ) const
{
    const auto metrics = toAbsolute( sourceRect.size() );
    const auto extent = metrics.m_spreadRadius + metrics.m_blurRadius;
 
    return QRectF(
        sourceRect.x() + metrics.m_offset.x() - extent,
        sourceRect.y() + metrics.m_offset.y() - extent,
        sourceRect.width() + 2 * extent,
        sourceRect.height() + 2 * extent );
}
 
QskHashValue QskShadowMetrics::hash( QskHashValue seed ) const noexcept
{
    QskHashValue hash;
 
    hash = qHash( m_offset.x(), seed );
    hash = qHash( m_offset.y(), seed );
    hash = qHash( m_spreadRadius, hash );
    hash = qHash( m_blurRadius, hash );
    hash = qHash( m_sizeMode, hash );
    hash = qHash( m_shapeMode, hash );
 
    return hash;
}
 
#ifndef QT_NO_DEBUG_STREAM
 
#include <qdebug.h>
 
QDebug operator<<( QDebug debug, const QskShadowMetrics& metrics )
{
    QDebugStateSaver saver( debug );
    debug.nospace();
 
    debug << "Shadow" << '(';
    debug << " spread:" << metrics.spreadRadius();
    debug << " blur:" << metrics.blurRadius();
    debug << " dx:" << metrics.offset().x();
    debug << " dy:" << metrics.offset().y();
    debug << " )";
 
    return debug;
}
 
#endif
 
#include "moc_QskShadowMetrics.cpp"