QskBoxShapeMetrics.cpp

/******************************************************************************
 * QSkinny - Copyright (C) The authors
 *           SPDX-License-Identifier: BSD-3-Clause
 *****************************************************************************/
 
#include "QskBoxShapeMetrics.h"
 
#include <qhashfunctions.h>
#include <qvariant.h>
 
#include <algorithm>
 
static void qskRegisterBoxShapeMetrics()
{
    qRegisterMetaType< QskBoxShapeMetrics >();
 
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
    QMetaType::registerEqualsComparator< QskBoxShapeMetrics >();
#endif
 
    QMetaType::registerConverter< int, QskBoxShapeMetrics >(
        []( int radius ) { return QskBoxShapeMetrics( radius ); } );
 
    QMetaType::registerConverter< qreal, QskBoxShapeMetrics >(
        []( qreal radius ) { return QskBoxShapeMetrics( radius ); } );
}
 
Q_CONSTRUCTOR_FUNCTION( qskRegisterBoxShapeMetrics )
 
static inline QSizeF qskInterpolatedSize(
    const QSizeF& from, const QSizeF& to, qreal ratio )
{
    return from + ( to - from ) * ratio;
}
 
static inline qreal qskAbsoluted( qreal length, qreal percentage )
{
    // 100% means -> 0.5 of length
    percentage = qBound( 0.0, percentage, 100.0 );
    return percentage / 100.0 * 0.5 * length;
}
 
static inline void qskSetRadius( qreal rx, qreal ry, QSizeF& radius )
{
    radius.rwidth() = ( rx > 0.0 ) ? rx : 0.0;
    radius.rheight() = ( ry > 0.0 ) ? ry : 0.0;
}
 
void QskBoxShapeMetrics::setRadius(
    qreal topLeftX, qreal topLeftY,
    qreal topRightX, qreal topRightY,
    qreal bottomLeftX, qreal bottomLeftY,
    qreal bottomRightX, qreal bottomRightY ) noexcept
{
    qskSetRadius( topLeftX, topLeftY, m_radii[ Qt::TopLeftCorner ] );
    qskSetRadius( topRightX, topRightY, m_radii[ Qt::TopRightCorner ] );
    qskSetRadius( bottomLeftX, bottomLeftY, m_radii[ Qt::BottomLeftCorner ] );
    qskSetRadius( bottomRightX, bottomRightY, m_radii[ Qt::BottomRightCorner ] );
}
 
void QskBoxShapeMetrics::setRadius( Qt::Corner corner, qreal radiusX, qreal radiusY ) noexcept
{
    if ( ( corner >= Qt::TopLeftCorner ) && ( corner <= Qt::BottomRightCorner ) )
        qskSetRadius( radiusX, radiusY, m_radii[ corner ] );
}
 
void QskBoxShapeMetrics::setTopLeft( const QSizeF& radius ) noexcept
{
    setRadius( Qt::TopLeftCorner, radius );
}
 
void QskBoxShapeMetrics::setTopRight( const QSizeF& radius ) noexcept
{
    setRadius( Qt::TopRightCorner, radius );
}
 
void QskBoxShapeMetrics::setBottomLeft( const QSizeF& radius ) noexcept
{
    setRadius( Qt::BottomLeftCorner, radius );
}
 
void QskBoxShapeMetrics::setBottomRight( const QSizeF& radius ) noexcept
{
    setRadius( Qt::BottomRightCorner, radius );
}
 
QskBoxShapeMetrics QskBoxShapeMetrics::toAbsolute( const QSizeF& size ) const noexcept
{
    if ( m_sizeMode != Qt::RelativeSize )
        return *this;
 
    if ( size.isEmpty() )
        return QskBoxShapeMetrics();
 
    QskBoxShapeMetrics shape = *this;
    shape.m_sizeMode = Qt::AbsoluteSize;
 
    for ( int i = 0; i < 4; i++ )
    {
        auto& radius = shape.m_radii[ i ];
 
        if ( radius.isEmpty() )
        {
            radius.rheight() = radius.rwidth() = 0.0;
            continue;
        }
 
        const qreal rx = qskAbsoluted( size.width(), radius.width() );
        const qreal ry = qskAbsoluted( size.height(), radius.height() );
 
        switch ( m_scalingMode )
        {
            case Symmetric:
            {
                radius.rheight() = radius.rwidth() = std::min( rx, ry );
                break;
            }
            case SymmetricByMaximum:
            {
                radius.rheight() = radius.rwidth() = std::max( rx, ry );
                break;
            }
            default:
            {
                const auto ratio = radius.height() / radius.width();
 
                if ( ratio >= 1.0 )
                {
                    radius.rwidth() = ry / ratio;
                    radius.rheight() = ry;
                }
                else
                {
                    radius.rwidth() = rx;
                    radius.rheight() = rx * ratio;
                }
            }
        }
    }
 
    return shape;
}
 
QskBoxShapeMetrics QskBoxShapeMetrics::interpolated(
    const QskBoxShapeMetrics& to, qreal ratio ) const noexcept
{
    // what about m_aspectRatioMode != to.m_aspectRatioMode ???
 
    if ( ( *this == to ) || ( m_sizeMode != to.m_sizeMode ) )
        return to;
 
    return QskBoxShapeMetrics(
        qskInterpolatedSize( m_radii[ 0 ], to.m_radii[ 0 ], ratio ),
        qskInterpolatedSize( m_radii[ 1 ], to.m_radii[ 1 ], ratio ),
        qskInterpolatedSize( m_radii[ 2 ], to.m_radii[ 2 ], ratio ),
        qskInterpolatedSize( m_radii[ 3 ], to.m_radii[ 3 ], ratio ),
        to.m_sizeMode, to.m_scalingMode );
}
 
QVariant QskBoxShapeMetrics::interpolate(
    const QskBoxShapeMetrics& from, const QskBoxShapeMetrics& to, qreal progress ) noexcept
{
    return QVariant::fromValue( from.interpolated( to, progress ) );
}
 
QskHashValue QskBoxShapeMetrics::hash( QskHashValue seed ) const noexcept
{
    auto hash = qHash( static_cast< int >( m_sizeMode ), seed );
    return qHashBits( m_radii, sizeof( m_radii ), hash );
}
 
#ifndef QT_NO_DEBUG_STREAM
 
#include <qdebug.h>
 
QDebug operator<<( QDebug debug, const QskBoxShapeMetrics& metrics )
{
    QDebugStateSaver saver( debug );
    debug.nospace();
 
    debug << "BoxShape" << '(';
    debug << metrics.sizeMode();
 
    for ( int i = Qt::TopLeftCorner; i <= Qt::BottomRightCorner; i++ )
    {
        const QSizeF r = metrics.radius( static_cast< Qt::Corner >( i ) );
        debug << "(" << r.width() << ',' << r.height() << ")";
    }
 
    debug << ')';
 
    return debug;
}
 
#endif
 
#include "moc_QskBoxShapeMetrics.cpp"