QskLinearLayoutEngine.cpp

/******************************************************************************
 * QSkinny - Copyright (C) The authors
 *           SPDX-License-Identifier: BSD-3-Clause
 *****************************************************************************/
 
#include "QskLinearLayoutEngine.h"
#include "QskLayoutMetrics.h"
#include "QskLayoutChain.h"
#include "QskLayoutElement.h"
#include "QskSizePolicy.h"
#include "QskQuick.h"
 
#include <qvector.h>
 
namespace
{
    inline QskLayoutMetrics qskItemMetrics(
        QQuickItem* item, Qt::Orientation orientation, qreal constraint )
    {
        const QskItemLayoutElement layoutItem( item );
        return layoutItem.metrics( orientation, constraint );
    }
 
    class Element
    {
      public:
        Element( QQuickItem* item );
        Element( qreal spacing );
        Element( const Element& );
 
        Element& operator=( const Element& );
 
        qreal spacing() const;
        QQuickItem* item() const;
 
        int stretch() const;
        void setStretch( int );
 
        bool isIgnored() const;
 
        QskLayoutChain::CellData cell(
            Qt::Orientation, bool isLayoutOrientation ) const;
 
      private:
 
        union
        {
            QQuickItem* m_item;
            qreal m_spacing;
        };
 
        int m_stretch = -1;
        bool m_isSpacer;
    };
 
    class ElementsVector : public std::vector< Element >
    {
      public:
        // to avoid warnings when assigning size_t to int
        inline int count() const { return static_cast< int >( size() ); }
    };
}
 
Element::Element( QQuickItem* item )
    : m_item( item )
    , m_isSpacer( false )
{
}
 
Element::Element( qreal spacing )
    : m_spacing( spacing )
    , m_isSpacer( true )
{
}
 
Element::Element( const Element& other )
    : m_stretch( other.m_stretch )
    , m_isSpacer( other.m_isSpacer )
{
    if ( other.m_isSpacer )
        m_spacing = other.m_spacing;
    else
        m_item = other.m_item;
}
 
Element& Element::operator=( const Element& other )
{
    m_isSpacer = other.m_isSpacer;
 
    if ( other.m_isSpacer )
        m_spacing = other.m_spacing;
    else
        m_item = other.m_item;
 
    m_stretch = other.m_stretch;
 
    return *this;
}
 
inline qreal Element::spacing() const
{
    return m_isSpacer ? m_spacing : -1.0;
}
 
inline QQuickItem* Element::item() const
{
    return m_isSpacer ? nullptr : m_item;
}
 
inline int Element::stretch() const
{
    return m_stretch;
}
 
inline void Element::setStretch( int stretch )
{
    m_stretch = stretch;
}
 
bool Element::isIgnored() const
{
    return !( m_isSpacer || qskIsVisibleToLayout( m_item ) );
}
 
QskLayoutChain::CellData Element::cell(
    Qt::Orientation orientation, bool isLayoutOrientation ) const
{
    QskLayoutChain::CellData cell;
    cell.canGrow = true;
    cell.isValid = true;
 
    if ( !m_isSpacer )
    {
        const auto policy = qskSizePolicy( m_item ).policy( orientation );
 
        if ( isLayoutOrientation )
        {
            if ( m_stretch < 0 )
                cell.stretch = ( policy & QskSizePolicy::ExpandFlag ) ? 1 : 0;
            else
                cell.stretch = m_stretch;
        }
 
        cell.canGrow = policy & QskSizePolicy::GrowFlag;
    }
    else
    {
        if ( isLayoutOrientation )
        {
            cell.metrics.setMinimum( m_spacing );
            cell.metrics.setPreferred( m_spacing );
 
            if ( m_stretch <= 0 )
                cell.metrics.setMaximum( m_spacing );
 
            cell.stretch = qMax( m_stretch, 0 );
        }
    }
 
    return cell;
}
 
class QskLinearLayoutEngine::PrivateData
{
  public:
 
    PrivateData( Qt::Orientation orientation, uint dimension )
        : dimension( dimension )
        , sumIgnored( -1 )
        , orientation( orientation )
    {
    }
 
    inline Element* elementAt( int index ) const
    {
        if ( ( index < 0 ) || ( index >= this->elements.count() ) )
            return nullptr;
 
        return const_cast< Element* >( &this->elements[index] );
    }
 
    ElementsVector elements;
 
    uint dimension;
 
    mutable int sumIgnored : 30;
    unsigned int orientation : 2;
};
 
QskLinearLayoutEngine::QskLinearLayoutEngine(
        Qt::Orientation orientation, uint dimension )
    : m_data( new PrivateData( orientation, dimension ) )
{
}
 
QskLinearLayoutEngine::~QskLinearLayoutEngine()
{
}
 
bool QskLinearLayoutEngine::setOrientation( Qt::Orientation orientation )
{
    if ( m_data->orientation != orientation )
    {
        m_data->orientation = orientation;
        invalidate( LayoutCache );
 
        return true;
    }
 
    return false;
}
 
Qt::Orientation QskLinearLayoutEngine::orientation() const
{
    return static_cast< Qt::Orientation >( m_data->orientation );
}
 
bool QskLinearLayoutEngine::setDimension( uint dimension )
{
    if ( dimension < 1 )
        dimension = 1;
 
    if ( m_data->dimension != dimension )
    {
        m_data->dimension = dimension;
        invalidate( LayoutCache );
 
        return true;
    }
 
    return false;
}
 
uint QskLinearLayoutEngine::dimension() const
{
    return m_data->dimension;
}
 
int QskLinearLayoutEngine::count() const
{
    return m_data->elements.count();
}
 
bool QskLinearLayoutEngine::setStretchFactorAt( int index, int stretchFactor )
{
    if ( auto element = m_data->elementAt( index ) )
    {
        if ( stretchFactor < 0 )
            stretchFactor = -1;
 
        if ( element->stretch() != stretchFactor )
        {
            element->setStretch( stretchFactor );
            invalidate( LayoutCache );
 
            return true;
        }
    }
 
    return false;
}
 
int QskLinearLayoutEngine::stretchFactorAt( int index ) const
{
    if ( const auto element = m_data->elementAt( index ) )
        return element->stretch();
 
    return -1;
}
 
int QskLinearLayoutEngine::insertItem( QQuickItem* item, int index )
{
    auto& elements = m_data->elements;
 
    if ( index < 0 || index > count() )
    {
        index = elements.count();
        elements.emplace_back( item );
    }
    else
    {
        elements.emplace( elements.begin() + index, item );
    }
 
    invalidate();
    return index;
}
 
int QskLinearLayoutEngine::insertSpacerAt( int index, qreal spacing )
{
    spacing = qMax( spacing, static_cast< qreal >( 0.0 ) );
 
    auto& elements = m_data->elements;
 
    if ( index < 0 || index > count() )
    {
        index = elements.count();
        elements.emplace_back( spacing );
    }
    else
    {
        elements.emplace( elements.begin() + index, spacing );
    }
 
    invalidate( LayoutCache );
    return index;
}
 
bool QskLinearLayoutEngine::removeAt( int index )
{
    auto element = m_data->elementAt( index );
    if ( element == nullptr )
        return false;
 
    if ( element->isIgnored() )
        m_data->sumIgnored--;
 
    const auto itemType = qskSizePolicy( element->item() ).constraintType();
 
    int invalidationMode = LayoutCache;
 
    if ( itemType > QskSizePolicy::Unconstrained )
        invalidationMode |= ElementCache;
 
    m_data->elements.erase( m_data->elements.begin() + index );
    invalidate( invalidationMode );
 
    return true;
}
 
bool QskLinearLayoutEngine::clear()
{
    if ( count() <= 0 )
        return false;
 
    m_data->elements.clear();
    invalidate();
 
    return true;
}
 
QskSizePolicy QskLinearLayoutEngine::sizePolicyAt( int index ) const
{
    return qskSizePolicy( itemAt( index ) );
}
 
int QskLinearLayoutEngine::indexOf( const QQuickItem* item ) const
{
    if ( item )
    {
        /*
           indexOf is often called after inserting an item to
           set additinal properties. So we search in reverse order
         */
 
        for ( int i = count() - 1; i >= 0; --i )
        {
            if ( itemAt( i ) == item )
                return i;
        }
    }
 
    return -1;
}
 
QQuickItem* QskLinearLayoutEngine::itemAt( int index ) const
{
    if ( const auto element = m_data->elementAt( index ) )
        return element->item();
 
    return nullptr;
}
 
qreal QskLinearLayoutEngine::spacerAt( int index ) const
{
    if ( const auto element = m_data->elementAt( index ) )
        return element->spacing();
 
    return -1.0;
}
 
void QskLinearLayoutEngine::layoutItems()
{
    uint row = 0;
    uint col = 0;
 
    for ( const auto& element : m_data->elements )
    {
        if ( element.isIgnored() )
            continue;
 
        if ( auto item = element.item() )
        {
            if ( qskIsAdjustableByLayout( item ) )
            {
                const QRect grid( col, row, 1, 1 );
 
                const QskItemLayoutElement layoutElement( item );
 
                const auto rect = geometryAt( &layoutElement, grid );
                if ( rect.size().isValid() )
                    qskSetItemGeometry( item, rect );
            }
        }
 
        if ( m_data->orientation == Qt::Horizontal )
        {
            if ( ++col == m_data->dimension )
            {
                col = 0;
                row++;
            }
        }
        else
        {
            if ( ++row == m_data->dimension )
            {
                row = 0;
                col++;
            }
        }
    }
}
 
int QskLinearLayoutEngine::effectiveCount( Qt::Orientation orientation ) const
{
    const uint cellCount = effectiveCount();
 
    if ( orientation == m_data->orientation )
    {
        return qMin( cellCount, m_data->dimension );
    }
    else
    {
        int count = cellCount / m_data->dimension;
        if ( cellCount % m_data->dimension )
            count++;
 
        return count;
    }
}
 
int QskLinearLayoutEngine::effectiveCount() const
{
    if ( m_data->sumIgnored < 0 )
    {
        m_data->sumIgnored = 0;
 
        for ( const auto& element : m_data->elements )
        {
            if ( element.isIgnored() )
                m_data->sumIgnored++;
        }
    }
 
    return m_data->elements.count() - m_data->sumIgnored;
}
 
void QskLinearLayoutEngine::invalidateElementCache()
{
    m_data->sumIgnored = -1;
}
 
void QskLinearLayoutEngine::setupChain( Qt::Orientation orientation,
    const QskLayoutChain::Segments& constraints, QskLayoutChain& chain ) const
{
    uint index1 = 0;
    uint index2 = 0;
 
    const bool isLayoutOrientation = ( orientation == m_data->orientation );
 
    qreal constraint = -1.0;
 
    for ( const auto& element : m_data->elements )
    {
        if ( element.isIgnored() )
            continue;
 
        if ( !constraints.isEmpty() )
            constraint = constraints[index1].length;
 
        auto cell = element.cell( orientation, isLayoutOrientation );
 
        if ( element.item() )
            cell.metrics = qskItemMetrics( element.item(), orientation, constraint );
 
        chain.expandCell( index2, cell );
 
        if ( isLayoutOrientation )
        {
            if ( ++index2 == m_data->dimension )
            {
                index2 = 0;
                index1++;
            }
        }
        else
        {
            if ( ++index1 == m_data->dimension )
            {
                index1 = 0;
                index2++;
            }
        }
    }
}