qquickpositioners.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
// Qt-Security score:significant reason:default
 
#include "qquickpositioners_p.h"
#include "qquickpositioners_p_p.h"
 
#include <QtQml/qqml.h>
#include <QtQml/qqmlinfo.h>
#include <QtCore/qcoreapplication.h>
 
#include <QtQuick/private/qquicktransition_p.h>
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
static const QQuickItemPrivate::ChangeTypes positionerWatchedChanges
    = QQuickItemPrivate::Geometry
    | QQuickItemPrivate::SiblingOrder
    | QQuickItemPrivate::Visibility
    | QQuickItemPrivate::Destroyed;
 
void QQuickBasePositionerPrivate::watchChanges(QQuickItem *other)
{
    QQuickItemPrivate *otherPrivate = QQuickItemPrivate::get(other);
    otherPrivate->addItemChangeListener(this, positionerWatchedChanges);
}
 
void QQuickBasePositionerPrivate::unwatchChanges(QQuickItem* other)
{
    QQuickItemPrivate *otherPrivate = QQuickItemPrivate::get(other);
    otherPrivate->removeItemChangeListener(this, positionerWatchedChanges);
}
 
 
QQuickBasePositioner::PositionedItem::PositionedItem(QQuickItem *i)
    : item(i)
#if QT_CONFIG(quick_viewtransitions)
    , transitionableItem(nullptr)
#endif
    , index(-1)
    , isNew(false)
    , isVisible(true)
    , topPadding(0)
    , leftPadding(0)
    , rightPadding(0)
    , bottomPadding(0)
{
}
 
qreal QQuickBasePositioner::PositionedItem::itemX() const
{
    return
#if QT_CONFIG(quick_viewtransitions)
            transitionableItem ? transitionableItem->itemX() :
#endif
            item->x();
}
 
qreal QQuickBasePositioner::PositionedItem::itemY() const
{
    return
#if QT_CONFIG(quick_viewtransitions)
            transitionableItem ? transitionableItem->itemY() :
#endif
            item->y();
}
 
void QQuickBasePositioner::PositionedItem::moveTo(const QPointF &pos)
{
#if QT_CONFIG(quick_viewtransitions)
    if (transitionableItem)
        transitionableItem->moveTo(pos);
    else
#endif
        item->setPosition(pos);
}
 
#if QT_CONFIG(quick_viewtransitions)
void QQuickBasePositioner::PositionedItem::transitionNextReposition(QQuickItemViewTransitioner *transitioner, QQuickItemViewTransitioner::TransitionType type, bool asTarget)
{
    if (!transitioner)
        return;
    if (!transitionableItem)
        transitionableItem = std::make_unique<QQuickItemViewTransitionableItem>(item);
    transitioner->transitionNextReposition(transitionableItem.get(), type, asTarget);
}
 
bool QQuickBasePositioner::PositionedItem::prepareTransition(QQuickItemViewTransitioner *transitioner, const QRectF &viewBounds)
{
    return transitionableItem ? transitionableItem->prepareTransition(transitioner, index, viewBounds) : false;
}
 
void QQuickBasePositioner::PositionedItem::startTransition(QQuickItemViewTransitioner *transitioner)
{
    if (transitionableItem)
        transitionableItem->startTransition(transitioner, index);
}
#endif
 
void QQuickBasePositioner::PositionedItem::updatePadding(qreal lp, qreal tp, qreal rp, qreal bp)
{
    leftPadding = lp;
    topPadding = tp;
    rightPadding = rp;
    bottomPadding = bp;
}
 
QQuickBasePositioner::QQuickBasePositioner(PositionerType at, QQuickItem *parent)
    : QQuickImplicitSizeItem(*(new QQuickBasePositionerPrivate), parent)
{
    Q_D(QQuickBasePositioner);
    d->init(at);
}
/*!
    \internal
    \class QQuickBasePositioner
    \brief For specifying a base for QQuickGraphics layouts
 
    To create a QQuickGraphics Positioner, simply subclass QQuickBasePositioner and implement
    doLayout(), which is automatically called when the layout might need
    updating. In doLayout() use the setX and setY functions from QQuickBasePositioner, and the
    base class will apply the positions along with the appropriate transitions. The items to
    position are provided in order as the protected member positionedItems.
 
    You also need to set a PositionerType, to declare whether you are positioning the x, y or both
    for the child items. Depending on the chosen type, only x or y changes will be applied.
 
    Note that the subclass is responsible for adding the spacing in between items.
 
    Positioning is batched and synchronized with painting to reduce the number of
    calculations needed. This means that positioners may not reposition items immediately
    when changes occur, but it will have moved by the next frame.
*/
 
QQuickBasePositioner::QQuickBasePositioner(QQuickBasePositionerPrivate &dd, PositionerType at, QQuickItem *parent)
    : QQuickImplicitSizeItem(dd, parent)
{
    Q_D(QQuickBasePositioner);
    d->init(at);
}
 
QQuickBasePositioner::~QQuickBasePositioner()
{
    Q_D(QQuickBasePositioner);
#if QT_CONFIG(quick_viewtransitions)
    delete d->transitioner;
#endif
    for (const PositionedItem &pi : positionedItems)
        d->unwatchChanges(pi.item);
    for (const PositionedItem &pi : unpositionedItems)
        d->unwatchChanges(pi.item);
    positionedItems.clear();
    unpositionedItems.clear();
}
 
void QQuickBasePositioner::updatePolish()
{
    Q_D(QQuickBasePositioner);
    if (d->positioningDirty)
        prePositioning();
}
 
qreal QQuickBasePositioner::spacing() const
{
    Q_D(const QQuickBasePositioner);
    return d->spacing;
}
 
void QQuickBasePositioner::setSpacing(qreal s)
{
    Q_D(QQuickBasePositioner);
    if (s == d->spacing)
        return;
    d->spacing = s;
    d->setPositioningDirty();
    emit spacingChanged();
}
 
#if QT_CONFIG(quick_viewtransitions)
QQuickTransition *QQuickBasePositioner::populate() const
{
    Q_D(const QQuickBasePositioner);
    return d->transitioner ? d->transitioner->populateTransition : nullptr;
}
 
void QQuickBasePositioner::setPopulate(QQuickTransition *transition)
{
    Q_D(QQuickBasePositioner);
    if (!d->transitioner)
        d->transitioner = new QQuickItemViewTransitioner;
    if (d->transitioner->populateTransition != transition) {
        d->transitioner->populateTransition = transition;
        emit populateChanged();
    }
}
 
QQuickTransition *QQuickBasePositioner::move() const
{
    Q_D(const QQuickBasePositioner);
    return d->transitioner ? d->transitioner->displacedTransition : nullptr;
}
 
void QQuickBasePositioner::setMove(QQuickTransition *mt)
{
    Q_D(QQuickBasePositioner);
    if (!d->transitioner)
        d->transitioner = new QQuickItemViewTransitioner;
    if (mt == d->transitioner->displacedTransition)
        return;
 
    d->transitioner->displacedTransition = mt;
    emit moveChanged();
}
 
QQuickTransition *QQuickBasePositioner::add() const
{
    Q_D(const QQuickBasePositioner);
    return d->transitioner ? d->transitioner->addTransition : nullptr;
}
 
void QQuickBasePositioner::setAdd(QQuickTransition *add)
{
    Q_D(QQuickBasePositioner);
    if (!d->transitioner)
        d->transitioner = new QQuickItemViewTransitioner;
    if (add == d->transitioner->addTransition)
        return;
 
    d->transitioner->addTransition = add;
    emit addChanged();
}
#endif
 
void QQuickBasePositioner::componentComplete()
{
#if QT_CONFIG(quick_viewtransitions)
    Q_D(QQuickBasePositioner);
#endif
    QQuickItem::componentComplete();
#if QT_CONFIG(quick_viewtransitions)
    if (d->transitioner)
        d->transitioner->setPopulateTransitionEnabled(true);
#endif
    positionedItems.reserve(childItems().size());
    prePositioning();
#if QT_CONFIG(quick_viewtransitions)
    if (d->transitioner)
        d->transitioner->setPopulateTransitionEnabled(false);
#endif
}
 
void QQuickBasePositioner::itemChange(ItemChange change, const ItemChangeData &value)
{
    Q_D(QQuickBasePositioner);
    if (change == ItemChildAddedChange) {
        d->setPositioningDirty();
    } else if (change == ItemChildRemovedChange) {
        QQuickItem *child = value.item;
        auto it = std::find(positionedItems.begin(), positionedItems.end(), child);
        if (it != positionedItems.end()) {
            d->unwatchChanges(child);
            positionedItems.erase(it);
        } else {
            it = std::find(unpositionedItems.begin(), unpositionedItems.end(), child);
            if (it != unpositionedItems.end()) {
                d->unwatchChanges(child);
                unpositionedItems.erase(it);
            }
        }
        d->setPositioningDirty();
    }
 
    QQuickItem::itemChange(change, value);
}
 
void QQuickBasePositioner::forceLayout()
{
    updatePolish();
}
 
void QQuickBasePositioner::prePositioning()
{
    Q_D(QQuickBasePositioner);
    if (!isComponentComplete())
        return;
 
    if (d->doingPositioning)
        return;
 
    d->positioningDirty = false;
    d->doingPositioning = true;
    //Need to order children by creation order modified by stacking order
    QList<QQuickItem *> children = childItems();
 
    std::vector<PositionedItem> oldItems;
    oldItems.reserve(positionedItems.size() + unpositionedItems.size());
 
    std::move(positionedItems.begin(), positionedItems.end(),
              std::back_inserter(oldItems));
    positionedItems.clear();
 
    std::move(unpositionedItems.begin(), unpositionedItems.end(),
              std::back_inserter(oldItems));
    unpositionedItems.clear();
 
#if QT_CONFIG(quick_viewtransitions)
    int addedIndex = -1;
#endif
 
    for (int ii = 0; ii < children.size(); ++ii) {
        QQuickItem *child = children.at(ii);
        if (QQuickItemPrivate::get(child)->isTransparentForPositioner())
            continue;
        QQuickItemPrivate *childPrivate = QQuickItemPrivate::get(child);
        PositionedItem posItem(child);
        auto it = std::find(oldItems.begin(), oldItems.end(), posItem);
        if (it == oldItems.end()) {
            // This is a newly added item.
            d->watchChanges(child);
            posItem.isNew = true;
            if (!childPrivate->explicitVisible || !child->width() || !child->height()) {
                posItem.isVisible = false;
                posItem.index = -1;
                // If we hide a zero-width or height item by setting visible to false,
                // the !childPrivate->explicitVisible will then always trigger. We can't
                // overwrite what the user has set, and we don't want to introduce a separate
                // flag to track whether the visible property was actually explicitly set so
                // that we can implicitly set it, so instead we use culled for this.
                childPrivate->setCulled(true);
                unpositionedItems.push_back(std::move(posItem));
            } else {
                const int posIndex = int(positionedItems.size());
                posItem.index = posIndex;
                positionedItems.push_back(std::move(posItem));
 
#if QT_CONFIG(quick_viewtransitions)
                if (d->transitioner) {
                    if (addedIndex < 0)
                        addedIndex = posIndex;
                    PositionedItem *theItem = &positionedItems.back();
                    if (d->transitioner->canTransition(QQuickItemViewTransitioner::PopulateTransition, true))
                        theItem->transitionNextReposition(d->transitioner, QQuickItemViewTransitioner::PopulateTransition, true);
                    else if (!d->transitioner->populateTransitionEnabled())
                        theItem->transitionNextReposition(d->transitioner, QQuickItemViewTransitioner::AddTransition, true);
                }
#endif
            }
        } else {
            // This item already existed within us.
            PositionedItem *item = &*it;
            // Items are only omitted from positioning if they are explicitly hidden
            // i.e. their positioning is not affected if an ancestor is hidden.
            if (!childPrivate->explicitVisible || !child->width() || !child->height()) {
                item->isVisible = false;
                item->index = -1;
                childPrivate->setCulled(true);
                unpositionedItems.push_back(std::move(*item));
            } else if (!item->isVisible) {
                // item changed from non-visible to visible, treat it as a "new" item
                item->isVisible = true;
                item->isNew = true;
                const int itemIndex = int(positionedItems.size());
                item->index = itemIndex;
                childPrivate->setCulled(false);
                positionedItems.push_back(std::move(*item));
 
#if QT_CONFIG(quick_viewtransitions)
                if (d->transitioner) {
                    if (addedIndex < 0)
                        addedIndex = itemIndex;
                    positionedItems.back().transitionNextReposition(d->transitioner, QQuickItemViewTransitioner::AddTransition, true);
                }
#endif
            } else {
                item->isNew = false;
                const int itemIndex = int(positionedItems.size());
                item->index = itemIndex;
                positionedItems.push_back(std::move(*item));
            }
        }
    }
 
#if QT_CONFIG(quick_viewtransitions)
    if (d->transitioner) {
        for (PositionedItem &item : positionedItems) {
            if (!item.isNew) {
                if (addedIndex >= 0) {
                    item.transitionNextReposition(d->transitioner, QQuickItemViewTransitioner::AddTransition, false);
                } else {
                    // just queue the item for a move-type displace - if the item hasn't
                    // moved anywhere, it won't be transitioned anyway
                    item.transitionNextReposition(d->transitioner, QQuickItemViewTransitioner::MoveTransition, false);
                }
            }
        }
    }
#endif
 
    QSizeF contentSize(0,0);
    reportConflictingAnchors();
    if (!d->anchorConflict) {
        doPositioning(&contentSize);
        updateAttachedProperties();
    }
 
#if QT_CONFIG(quick_viewtransitions)
    if (d->transitioner) {
        QRectF viewBounds(QPointF(), contentSize);
        for (PositionedItem &item : positionedItems)
            item.prepareTransition(d->transitioner, viewBounds);
        for (PositionedItem &item : positionedItems)
            item.startTransition(d->transitioner);
        d->transitioner->resetTargetLists();
    }
#endif
 
    d->doingPositioning = false;
 
    //Set implicit size to the size of its children
    setImplicitSize(contentSize.width(), contentSize.height());
 
    emit positioningComplete();
}
 
void QQuickBasePositioner::positionItem(qreal x, qreal y, PositionedItem *target)
{
    if ( target->itemX() != x || target->itemY() != y )
        target->moveTo(QPointF(x, y));
}
 
void QQuickBasePositioner::positionItemX(qreal x, PositionedItem *target)
{
    Q_D(QQuickBasePositioner);
    if (target->itemX() != x
            && (d->type == Horizontal || d->type == Both)) {
        target->moveTo(QPointF(x, target->itemY()));
    }
}
 
void QQuickBasePositioner::positionItemY(qreal y, PositionedItem *target)
{
    Q_D(QQuickBasePositioner);
    if (target->itemY() != y
            && (d->type == Vertical || d->type == Both)) {
        target->moveTo(QPointF(target->itemX(), y));
    }
}
 
QQuickPositionerAttached *QQuickBasePositioner::qmlAttachedProperties(QObject *obj)
{
    return new QQuickPositionerAttached(obj);
}
 
void QQuickBasePositioner::updateAttachedProperties(QQuickPositionerAttached *specificProperty, QQuickItem *specificPropertyOwner) const
{
    // If this function is deemed too expensive or shows up in profiles, it could
    // be changed to run only when there are attached properties present. This
    // could be a flag in the positioner that is set by the attached property
    // constructor.
    QQuickPositionerAttached *prevLastProperty = nullptr;
    QQuickPositionerAttached *lastProperty = nullptr;
 
    const int positionedItemsSize = int(positionedItems.size());
    for (int ii = 0; ii < positionedItemsSize; ++ii) {
        const PositionedItem &child = positionedItems[ii];
        if (!child.item)
            continue;
 
        QQuickPositionerAttached *property = nullptr;
 
        if (specificProperty) {
            if (specificPropertyOwner == child.item) {
                property = specificProperty;
            }
        } else {
            property = static_cast<QQuickPositionerAttached *>(qmlAttachedPropertiesObject<QQuickBasePositioner>(child.item, false));
        }
 
        if (property) {
            property->setIndex(ii);
            property->setIsFirstItem(ii == 0);
 
            if (property->isLastItem()) {
                if (prevLastProperty)
                    prevLastProperty->setIsLastItem(false); // there can be only one last property
                prevLastProperty = property;
            }
        }
 
        lastProperty = property;
    }
 
    if (prevLastProperty && prevLastProperty != lastProperty)
        prevLastProperty->setIsLastItem(false);
    if (lastProperty)
        lastProperty->setIsLastItem(true);
 
    // clear attached properties for unpositioned items
    for (const PositionedItem &child : unpositionedItems) {
        if (!child.item)
            continue;
 
        QQuickPositionerAttached *property = nullptr;
 
        if (specificProperty) {
            if (specificPropertyOwner == child.item) {
                property = specificProperty;
            }
        } else {
            property = static_cast<QQuickPositionerAttached *>(qmlAttachedPropertiesObject<QQuickBasePositioner>(child.item, false));
        }
 
        if (property) {
            property->setIndex(-1);
            property->setIsFirstItem(false);
            property->setIsLastItem(false);
        }
    }
}
 
qreal QQuickBasePositioner::padding() const
{
    Q_D(const QQuickBasePositioner);
    return d->padding();
}
 
void QQuickBasePositioner::setPadding(qreal padding)
{
    Q_D(QQuickBasePositioner);
    if (qFuzzyCompare(d->padding(), padding))
        return;
 
    d->extra.value().padding = padding;
    d->setPositioningDirty();
    emit paddingChanged();
    if (!d->extra.isAllocated() || !d->extra->explicitTopPadding)
        emit topPaddingChanged();
    if (!d->extra.isAllocated() || !d->extra->explicitLeftPadding)
        emit leftPaddingChanged();
    if (!d->extra.isAllocated() || !d->extra->explicitRightPadding)
        emit rightPaddingChanged();
    if (!d->extra.isAllocated() || !d->extra->explicitBottomPadding)
        emit bottomPaddingChanged();
}
 
void QQuickBasePositioner::resetPadding()
{
    setPadding(0);
}
 
qreal QQuickBasePositioner::topPadding() const
{
    Q_D(const QQuickBasePositioner);
    if (d->extra.isAllocated() && d->extra->explicitTopPadding)
        return d->extra->topPadding;
    return d->padding();
}
 
void QQuickBasePositioner::setTopPadding(qreal padding)
{
    Q_D(QQuickBasePositioner);
    d->setTopPadding(padding);
}
 
void QQuickBasePositioner::resetTopPadding()
{
    Q_D(QQuickBasePositioner);
    d->setTopPadding(0, true);
}
 
qreal QQuickBasePositioner::leftPadding() const
{
    Q_D(const QQuickBasePositioner);
    if (d->extra.isAllocated() && d->extra->explicitLeftPadding)
        return d->extra->leftPadding;
    return d->padding();
}
 
void QQuickBasePositioner::setLeftPadding(qreal padding)
{
    Q_D(QQuickBasePositioner);
    d->setLeftPadding(padding);
}
 
void QQuickBasePositioner::resetLeftPadding()
{
    Q_D(QQuickBasePositioner);
    d->setLeftPadding(0, true);
}
 
qreal QQuickBasePositioner::rightPadding() const
{
    Q_D(const QQuickBasePositioner);
    if (d->extra.isAllocated() && d->extra->explicitRightPadding)
        return d->extra->rightPadding;
    return d->padding();
}
 
void QQuickBasePositioner::setRightPadding(qreal padding)
{
    Q_D(QQuickBasePositioner);
    d->setRightPadding(padding);
}
 
void QQuickBasePositioner::resetRightPadding()
{
    Q_D(QQuickBasePositioner);
    d->setRightPadding(0, true);
}
 
qreal QQuickBasePositioner::bottomPadding() const
{
    Q_D(const QQuickBasePositioner);
    if (d->extra.isAllocated() && d->extra->explicitBottomPadding)
        return d->extra->bottomPadding;
    return d->padding();
}
 
void QQuickBasePositioner::setBottomPadding(qreal padding)
{
    Q_D(QQuickBasePositioner);
    d->setBottomPadding(padding);
}
 
void QQuickBasePositioner::resetBottomPadding()
{
    Q_D(QQuickBasePositioner);
    d->setBottomPadding(0, true);
}
 
QQuickBasePositionerPrivate::ExtraData::ExtraData()
    : padding(0)
    , topPadding(0)
    , leftPadding(0)
    , rightPadding(0)
    , bottomPadding(0)
    , explicitTopPadding(false)
    , explicitLeftPadding(false)
    , explicitRightPadding(false)
    , explicitBottomPadding(false)
{
}
 
void QQuickBasePositionerPrivate::setTopPadding(qreal value, bool reset)
{
    Q_Q(QQuickBasePositioner);
    qreal oldPadding = q->topPadding();
    if (!reset || extra.isAllocated()) {
        extra.value().topPadding = value;
        extra.value().explicitTopPadding = !reset;
    }
    if ((!reset && !qFuzzyCompare(oldPadding, value)) || (reset && !qFuzzyCompare(oldPadding, padding()))) {
        setPositioningDirty();
        emit q->topPaddingChanged();
    }
}
 
void QQuickBasePositionerPrivate::setLeftPadding(qreal value, bool reset)
{
    Q_Q(QQuickBasePositioner);
    qreal oldPadding = q->leftPadding();
    if (!reset || extra.isAllocated()) {
        extra.value().leftPadding = value;
        extra.value().explicitLeftPadding = !reset;
    }
    if ((!reset && !qFuzzyCompare(oldPadding, value)) || (reset && !qFuzzyCompare(oldPadding, padding()))) {
        setPositioningDirty();
        emit q->leftPaddingChanged();
    }
}
 
void QQuickBasePositionerPrivate::setRightPadding(qreal value, bool reset)
{
    Q_Q(QQuickBasePositioner);
    qreal oldPadding = q->rightPadding();
    if (!reset || extra.isAllocated()) {
        extra.value().rightPadding = value;
        extra.value().explicitRightPadding = !reset;
    }
    if ((!reset && !qFuzzyCompare(oldPadding, value)) || (reset && !qFuzzyCompare(oldPadding, padding()))) {
        setPositioningDirty();
        emit q->rightPaddingChanged();
    }
}
 
void QQuickBasePositionerPrivate::setBottomPadding(qreal value, bool reset)
{
    Q_Q(QQuickBasePositioner);
    qreal oldPadding = q->bottomPadding();
    if (!reset || extra.isAllocated()) {
        extra.value().bottomPadding = value;
        extra.value().explicitBottomPadding = !reset;
    }
    if ((!reset && !qFuzzyCompare(oldPadding, value)) || (reset && !qFuzzyCompare(oldPadding, padding()))) {
        setPositioningDirty();
        emit q->bottomPaddingChanged();
    }
}
 
/*!
    \qmltype Positioner
    \nativetype QQuickPositionerAttached
    \inqmlmodule QtQuick
    \ingroup qtquick-positioners
    \brief Provides attached properties that contain details on where an item exists in a positioner.
 
    An object of type Positioner is attached to the top-level child item within a
    Column, Row, Flow or Grid. It provides properties that allow a child item to determine
    where it exists within the layout of its parent Column, Row, Flow or Grid.
 
    For example, below is a \l Grid with 16 child rectangles, as created through a \l Repeater.
    Each \l Rectangle displays its index in the Grid using \l {Positioner::index}{Positioner.index}, and the first
    item is colored differently by taking \l {Positioner::isFirstItem}{Positioner.isFirstItem} into account:
 
    \code
    Grid {
        Repeater {
            model: 16
 
            Rectangle {
                id: rect
                width: 30; height: 30
                border.width: 1
                color: Positioner.isFirstItem ? "yellow" : "lightsteelblue"
 
                Text { text: rect.Positioner.index }
            }
        }
    }
    \endcode
 
    \image positioner-example.png {Grid with 16 rectangles numbered 0-15,
           first item yellow indicating Positioner.isFirstItem}
*/
 
QQuickPositionerAttached::QQuickPositionerAttached(QObject *parent) : QObject(parent), m_index(-1), m_isFirstItem(false), m_isLastItem(false)
{
    QQuickItem *attachedItem = qobject_cast<QQuickItem *>(parent);
    if (attachedItem) {
        QQuickBasePositioner *positioner = qobject_cast<QQuickBasePositioner *>(attachedItem->parent());
        if (positioner) {
            positioner->updateAttachedProperties(this, attachedItem);
        }
    }
}
 
/*!
    \qmlattachedproperty int QtQuick::Positioner::index
 
    This property allows the item to determine
    its index within the positioner.
*/
void QQuickPositionerAttached::setIndex(int index)
{
    if (m_index == index)
        return;
    m_index = index;
    emit indexChanged();
}
 
/*!
    \qmlattachedproperty bool QtQuick::Positioner::isFirstItem
    \qmlattachedproperty bool QtQuick::Positioner::isLastItem
 
    These properties allow the item to determine if it
    is the first or last item in the positioner, respectively.
*/
void QQuickPositionerAttached::setIsFirstItem(bool isFirstItem)
{
    if (m_isFirstItem == isFirstItem)
        return;
    m_isFirstItem = isFirstItem;
    emit isFirstItemChanged();
}
 
void QQuickPositionerAttached::setIsLastItem(bool isLastItem)
{
    if (m_isLastItem == isLastItem)
        return;
    m_isLastItem = isLastItem;
    emit isLastItemChanged();
}
 
/*!
    \qmltype Column
    \nativetype QQuickColumn
    \inqmlmodule QtQuick
    \inherits Item
    \ingroup qtquick-positioners
    \brief Positions its children in a column.
 
    Column is a type that positions its child items along a single column.
    It can be used as a convenient way to vertically position a series of items without
    using \l {Positioning with Anchors}{anchors}.
 
    Below is a Column that contains three rectangles of various sizes:
 
    \snippet qml/column/vertical-positioner.qml document
 
    The Column automatically positions these items in a vertical formation, like this:
 
    \image verticalpositioner_example.png {Three colored rectangles
           stacked vertically in a Column}
 
    If an item within a Column is not \l {Item::}{visible}, or if it has a width or
    height of 0, the item will not be laid out and it will not be visible within the
    column. Also, since a Column automatically positions its children vertically, a child
    item within a Column should not set its \l {Item::y}{y} position or vertically
    anchor itself using the \l {Item::anchors.top}{top}, \l {Item::anchors.bottom}{bottom},
    \l {Item::anchors.verticalCenter}{anchors.verticalCenter}, \l {Item::anchors.fill}{fill}
    or \l {Item::anchors.centerIn}{centerIn} anchors. If you need to perform these actions,
    consider positioning the items without the use of a Column.
 
    Note that items in a Column can use the \l Positioner attached property to access
    more information about its position within the Column.
 
    For more information on using Column and other related positioner-types, see
    \l{Item Positioners}.
 
 
    \section1 Using Transitions
 
    A Column animate items using specific transitions when items are added to or moved
    within a Column.
 
    For example, the Column below sets the \l move property to a specific \l Transition:
 
    \snippet qml/column/column-transitions.qml document
 
    When the Space key is pressed, the \l {Item::visible}{visible} value of the green
    \l Rectangle is toggled. As it appears and disappears, the blue \l Rectangle moves within
    the Column, and the \l move transition is automatically applied to the blue \l Rectangle:
 
    \image verticalpositioner_transition.gif {Blue rectangle animating
           up and down as green rectangle toggles visibility}
 
    \sa Row, Grid, Flow, Positioner, ColumnLayout, {Qt Quick Examples - Positioners}
*/
/*!
    \since 5.6
    \qmlproperty real QtQuick::Column::padding
    \qmlproperty real QtQuick::Column::topPadding
    \qmlproperty real QtQuick::Column::leftPadding
    \qmlproperty real QtQuick::Column::bottomPadding
    \qmlproperty real QtQuick::Column::rightPadding
 
    These properties hold the padding around the content.
*/
/*!
    \qmlproperty Transition QtQuick::Column::populate
 
    This property holds the transition to be run for items that are part of
    this positioner at the time of its creation. The transition is run when the positioner
    is first created.
 
    The transition can use the \l ViewTransition property to access more details about
    the item that is being added. See the \l ViewTransition documentation for more details
    and examples on using these transitions.
 
    \sa add, ViewTransition, {Qt Quick Examples - Positioners}
*/
/*!
    \qmlproperty Transition QtQuick::Column::add
 
    This property holds the transition to be run for items that are added to this
    positioner. For a positioner, this applies to:
 
    \list
    \li Items that are created or reparented as a child of the positioner after the
        positioner has been created
    \li Child items that change their \l Item::visible property from false to true, and thus
       are now visible
    \endlist
 
    The transition can use the \l ViewTransition property to access more details about
    the item that is being added. See the \l ViewTransition documentation for more details
    and examples on using these transitions.
 
    \note This transition is not applied to the items that are already part of the positioner
    at the time of its creation. In this case, the \l populate transition is applied instead.
 
    \sa populate, ViewTransition, {Qt Quick Examples - Positioners}
*/
/*!
    \qmlproperty Transition QtQuick::Column::move
 
    This property holds the transition to run for items that have moved within the
    positioner. For a positioner, this applies to:
 
    \list
    \li Child items that move when they are displaced due to the addition, removal or
       rearrangement of other items in the positioner
    \li Child items that are repositioned due to the resizing of other items in the positioner
    \endlist
 
    The transition can use the \l ViewTransition property to access more details about
    the item that is being moved. Note, however, that for this move transition, the
    ViewTransition.targetIndexes and ViewTransition.targetItems lists are only set when
    this transition is triggered by the addition of other items in the positioner; in other
    cases, these lists will be empty.  See the \l ViewTransition documentation for more details
    and examples on using these transitions.
 
    \sa add, populate, ViewTransition, {Qt Quick Examples - Positioners}
*/
/*!
  \qmlproperty real QtQuick::Column::spacing
 
  The spacing is the amount in pixels left empty between adjacent
  items. The default spacing is 0.
 
  \sa Grid::spacing
*/
/*!
    \qmlmethod void QtQuick::Column::forceLayout()
    \since 5.9
 
    Column typically positions its children once per frame. This means that
    inside script blocks it is possible for the underlying children to have changed,
    but the Column to have not yet been updated accordingly.
 
    This method forces the Column to immediately respond to any outstanding
    changes in its children.
 
    \b Note: methods in general should only be called after the Component has completed.
*/
/*!
    \qmlsignal QtQuick::Column::positioningComplete()
    \since 5.9
 
    This signal is emitted when positioning has been completed.
*/
 
QQuickColumn::QQuickColumn(QQuickItem *parent)
: QQuickBasePositioner(Vertical, parent)
{
}
 
void QQuickColumn::doPositioning(QSizeF *contentSize)
{
    //Precondition: All items in the positioned list have a valid item pointer and should be positioned
    qreal voffset = topPadding();
    const qreal padding = leftPadding() + rightPadding();
    contentSize->setWidth(qMax(contentSize->width(), padding));
 
    for (PositionedItem &child : positionedItems) {
        positionItem(child.itemX() + leftPadding() - child.leftPadding, voffset, &child);
        child.updatePadding(leftPadding(), topPadding(), rightPadding(), bottomPadding());
        contentSize->setWidth(qMax(contentSize->width(), child.item->width() + padding));
 
        voffset += child.item->height();
        voffset += spacing();
    }
 
    if (voffset - topPadding() != 0)//If we positioned any items, undo the spacing from the last item
        voffset -= spacing();
    contentSize->setHeight(voffset + bottomPadding());
}
 
void QQuickColumn::reportConflictingAnchors()
{
    QQuickBasePositionerPrivate *d = static_cast<QQuickBasePositionerPrivate*>(QQuickBasePositionerPrivate::get(this));
    for (const PositionedItem &child : positionedItems) {
        if (child.item) {
            QQuickAnchors *anchors = QQuickItemPrivate::get(static_cast<QQuickItem *>(child.item))->_anchors;
            if (anchors) {
                QQuickAnchors::Anchors usedAnchors = anchors->usedAnchors();
                if (usedAnchors & QQuickAnchors::TopAnchor ||
                    usedAnchors & QQuickAnchors::BottomAnchor ||
                    usedAnchors & QQuickAnchors::VCenterAnchor ||
                    anchors->fill() || anchors->centerIn()) {
                    d->anchorConflict = true;
                    break;
                }
            }
        }
    }
    if (d->anchorConflict) {
        qmlWarning(this) << "Cannot specify top, bottom, verticalCenter, fill or centerIn anchors for items inside Column."
            << " Column will not function.";
    }
}
/*!
    \qmltype Row
    \nativetype QQuickRow
    \inqmlmodule QtQuick
    \inherits Item
    \ingroup qtquick-positioners
    \brief Positions its children in a row.
 
    Row is a type that positions its child items along a single row.
    It can be used as a convenient way to horizontally position a series of items without
    using \l {Positioning with Anchors}{anchors}.
 
    Below is a Row that contains three rectangles of various sizes:
 
    \snippet qml/row/row.qml document
 
    The Row automatically positions these items in a horizontal formation, like this:
 
    \image horizontalpositioner_example.png {Three colored rectangles
           arranged horizontally in a Row}
 
    If an item within a Row is not \l {Item::}{visible}, or if it has a width or
    height of 0, the item will not be laid out and it will not be visible within the
    row. Also, since a Row automatically positions its children horizontally, a child
    item within a Row should not set its \l {Item::x}{x} position or horizontally
    anchor itself using the \l {Item::anchors.left}{left}, \l {Item::anchors.right}{right},
    \l {Item::anchors.horizontalCenter}{anchors.horizontalCenter}, \l {Item::anchors.fill}{fill}
    or \l {Item::anchors.centerIn}{centerIn} anchors. If you need to perform these actions,
    consider positioning the items without the use of a Row.
 
    Note that items in a Row can use the \l Positioner attached property to access
    more information about its position within the Row.
 
    For more information on using Row and other related positioner-types, see
    \l{Item Positioners}.
 
 
    \sa Column, Grid, Flow, Positioner, RowLayout, {Qt Quick Examples - Positioners}
*/
/*!
    \since 5.6
    \qmlproperty real QtQuick::Row::padding
    \qmlproperty real QtQuick::Row::topPadding
    \qmlproperty real QtQuick::Row::leftPadding
    \qmlproperty real QtQuick::Row::bottomPadding
    \qmlproperty real QtQuick::Row::rightPadding
 
    These properties hold the padding around the content.
*/
/*!
    \qmlproperty Transition QtQuick::Row::populate
 
    This property holds the transition to be run for items that are part of
    this positioner at the time of its creation. The transition is run when the positioner
    is first created.
 
    The transition can use the \l ViewTransition property to access more details about
    the item that is being added. See the \l ViewTransition documentation for more details
    and examples on using these transitions.
 
    \sa add, ViewTransition, {Qt Quick Examples - Positioners}
*/
/*!
    \qmlproperty Transition QtQuick::Row::add
 
    This property holds the transition to be run for items that are added to this
    positioner. For a positioner, this applies to:
 
    \list
    \li Items that are created or reparented as a child of the positioner after the
        positioner has been created
    \li Child items that change their \l Item::visible property from false to true, and thus
       are now visible
    \endlist
 
    The transition can use the \l ViewTransition property to access more details about
    the item that is being added. See the \l ViewTransition documentation for more details
    and examples on using these transitions.
 
    \note This transition is not applied to the items that are already part of the positioner
    at the time of its creation. In this case, the \l populate transition is applied instead.
 
    \sa populate, ViewTransition, {Qt Quick Examples - Positioners}
*/
/*!
    \qmlproperty Transition QtQuick::Row::move
 
    This property holds the transition to run for items that have moved within the
    positioner. For a positioner, this applies to:
 
    \list
    \li Child items that move when they are displaced due to the addition, removal or
       rearrangement of other items in the positioner
    \li Child items that are repositioned due to the resizing of other items in the positioner
    \endlist
 
    The transition can use the \l ViewTransition property to access more details about
    the item that is being moved. Note, however, that for this move transition, the
    ViewTransition.targetIndexes and ViewTransition.targetItems lists are only set when
    this transition is triggered by the addition of other items in the positioner; in other
    cases, these lists will be empty.  See the \l ViewTransition documentation for more details
    and examples on using these transitions.
 
    \sa add, populate, ViewTransition, {Qt Quick Examples - Positioners}
*/
/*!
  \qmlproperty real QtQuick::Row::spacing
 
  The spacing is the amount in pixels left empty between adjacent
  items. The default spacing is 0.
 
  \sa Grid::spacing
*/
/*!
    \qmlmethod void QtQuick::Row::forceLayout()
    \since 5.9
 
    Row typically positions its children once per frame. This means that
    inside script blocks it is possible for the underlying children to have changed,
    but the Row to have not yet been updated accordingly.
 
    This method forces the Row to immediately respond to any outstanding
    changes in its children.
 
    \b Note: methods in general should only be called after the Component has completed.
*/
/*!
    \qmlsignal QtQuick::Row::positioningComplete()
    \since 5.9
 
    This signal is emitted when positioning has been completed.
*/
 
class QQuickRowPrivate : public QQuickBasePositionerPrivate
{
    Q_DECLARE_PUBLIC(QQuickRow)
 
public:
    QQuickRowPrivate()
        : QQuickBasePositionerPrivate()
    {}
 
    void effectiveLayoutDirectionChange() override
    {
        Q_Q(QQuickRow);
        // For RTL layout the positioning changes when the width changes.
        if (getEffectiveLayoutDirection(q) == Qt::RightToLeft)
            addItemChangeListener(this, QQuickItemPrivate::Geometry);
        else
            removeItemChangeListener(this, QQuickItemPrivate::Geometry);
        // Don't postpone, as it might be the only trigger for visible changes.
        q->prePositioning();
        emit q->effectiveLayoutDirectionChanged();
    }
};
 
QQuickRow::QQuickRow(QQuickItem *parent)
: QQuickBasePositioner(*new QQuickRowPrivate, Horizontal, parent)
{
}
/*!
    \qmlproperty enumeration QtQuick::Row::layoutDirection
 
    This property holds the layoutDirection of the row.
 
    Possible values:
 
    \value Qt.LeftToRight   (default) Items are laid out from left to right. If the width of the row is
                            explicitly set, the left anchor remains to the left of the row.
    \value Qt.RightToLeft   Items are laid out from right to left. If the width of the row is
                            explicitly set, the right anchor remains to the right of the row.
 
    \sa Grid::layoutDirection, Flow::layoutDirection
*/
 
Qt::LayoutDirection QQuickRow::layoutDirection() const
{
    return QQuickBasePositionerPrivate::getLayoutDirection(this);
}
 
void QQuickRow::setLayoutDirection(Qt::LayoutDirection layoutDirection)
{
    QQuickBasePositionerPrivate *d = static_cast<QQuickBasePositionerPrivate* >(QQuickBasePositionerPrivate::get(this));
    if (d->layoutDirection != layoutDirection) {
        d->layoutDirection = layoutDirection;
        emit layoutDirectionChanged();
        d->effectiveLayoutDirectionChange();
    }
}
/*!
    \qmlproperty enumeration QtQuick::Row::effectiveLayoutDirection
    This property holds the effective layout direction of the row.
 
    When using the attached property \l {LayoutMirroring::enabled}{LayoutMirroring::enabled} for locale layouts,
    the visual layout direction of the row positioner will be mirrored. However, the
    property \l {Row::layoutDirection}{layoutDirection} will remain unchanged.
 
    \sa Row::layoutDirection, {LayoutMirroring}{LayoutMirroring}
*/
 
Qt::LayoutDirection QQuickRow::effectiveLayoutDirection() const
{
    return QQuickBasePositionerPrivate::getEffectiveLayoutDirection(this);
}
 
void QQuickRow::doPositioning(QSizeF *contentSize)
{
    //Precondition: All items in the positioned list have a valid item pointer and should be positioned
    QQuickBasePositionerPrivate *d = static_cast<QQuickBasePositionerPrivate* >(QQuickBasePositionerPrivate::get(this));
    qreal hoffset1 = leftPadding();
    qreal hoffset2 = rightPadding();
    if (!d->isLeftToRight())
        qSwap(hoffset1, hoffset2);
    qreal hoffset = hoffset1;
    const qreal padding = topPadding() + bottomPadding();
    contentSize->setHeight(qMax(contentSize->height(), padding));
 
    QList<qreal> hoffsets;
    for (PositionedItem &child : positionedItems) {
        if (d->isLeftToRight()) {
            positionItem(hoffset, child.itemY() + topPadding() - child.topPadding, &child);
            child.updatePadding(leftPadding(), topPadding(), rightPadding(), bottomPadding());
        } else {
            hoffsets << hoffset;
        }
 
        contentSize->setHeight(qMax(contentSize->height(), child.item->height() + padding));
 
        hoffset += child.item->width();
        hoffset += spacing();
    }
 
    if (hoffset - hoffset1 != 0)//If we positioned any items, undo the extra spacing from the last item
        hoffset -= spacing();
    contentSize->setWidth(hoffset + hoffset2);
 
    if (d->isLeftToRight())
        return;
 
    //Right to Left layout
    qreal end = 0;
    if (!widthValid())
        end = contentSize->width();
    else
        end = width();
 
    int acc = 0;
    for (PositionedItem &child : positionedItems) {
        hoffset = end - hoffsets[acc++] - child.item->width();
        positionItem(hoffset, child.itemY() + topPadding() - child.topPadding, &child);
        child.updatePadding(leftPadding(), topPadding(), rightPadding(), bottomPadding());
    }
}
 
void QQuickRow::reportConflictingAnchors()
{
    QQuickBasePositionerPrivate *d = static_cast<QQuickBasePositionerPrivate*>(QQuickBasePositionerPrivate::get(this));
    for (const PositionedItem &child : positionedItems) {
        if (child.item) {
            QQuickAnchors *anchors = QQuickItemPrivate::get(static_cast<QQuickItem *>(child.item))->_anchors;
            if (anchors) {
                QQuickAnchors::Anchors usedAnchors = anchors->usedAnchors();
                if (usedAnchors & QQuickAnchors::LeftAnchor ||
                    usedAnchors & QQuickAnchors::RightAnchor ||
                    usedAnchors & QQuickAnchors::HCenterAnchor ||
                    anchors->fill() || anchors->centerIn()) {
                    d->anchorConflict = true;
                    break;
                }
            }
        }
    }
    if (d->anchorConflict)
        qmlWarning(this) << "Cannot specify left, right, horizontalCenter, fill or centerIn anchors for items inside Row."
            << " Row will not function.";
}
 
/*!
    \qmltype Grid
    \nativetype QQuickGrid
    \inqmlmodule QtQuick
    \inherits Item
    \ingroup qtquick-positioners
    \brief Positions its children in grid formation.
 
    Grid is a type that positions its child items in grid formation.
 
    A Grid creates a grid of cells that is large enough to hold all of its
    child items, and places these items in the cells from left to right
    and top to bottom. Each item is positioned at the top-left corner of its
    cell with position (0, 0).
 
    A Grid defaults to four columns, and creates as many rows as are necessary to
    fit all of its child items. The number of rows and columns can be constrained
    by setting the \l rows and \l columns properties.
 
    For example, below is a Grid that contains five rectangles of various sizes:
 
    \snippet qml/grid/grid.qml document
 
    The Grid automatically positions the child items in a grid formation:
 
    \image gridLayout_example.png {Five colored rectangles arranged
           in a grid formation}
 
    If an item within a Grid is not \l {Item::}{visible}, or if it has a width or
    height of 0, the item will not be laid out and it will not be visible within the
    column. Also, since a Grid automatically positions its children, a child
    item within a Grid should not set its \l {Item::x}{x} or \l {Item::y}{y} positions
    or anchor itself with any of the \l {Item::anchors}{anchor} properties.
 
    For more information on using Grid and other related positioner-types, see
    \l{Item Positioners}.
 
 
    \sa Flow, Row, Column, Positioner, GridLayout, {Qt Quick Examples - Positioners}
*/
/*!
    \since 5.6
    \qmlproperty real QtQuick::Grid::padding
    \qmlproperty real QtQuick::Grid::topPadding
    \qmlproperty real QtQuick::Grid::leftPadding
    \qmlproperty real QtQuick::Grid::bottomPadding
    \qmlproperty real QtQuick::Grid::rightPadding
 
    These properties hold the padding around the content.
*/
/*!
    \qmlproperty Transition QtQuick::Grid::populate
 
    This property holds the transition to be run for items that are part of
    this positioner at the time of its creation. The transition is run when the positioner
    is first created.
 
    The transition can use the \l ViewTransition property to access more details about
    the item that is being added. See the \l ViewTransition documentation for more details
    and examples on using these transitions.
 
    \sa add, ViewTransition, {Qt Quick Examples - Positioners}
*/
/*!
    \qmlproperty Transition QtQuick::Grid::add
 
    This property holds the transition to be run for items that are added to this
    positioner. For a positioner, this applies to:
 
    \list
    \li Items that are created or reparented as a child of the positioner after the
        positioner has been created
    \li Child items that change their \l Item::visible property from false to true, and thus
       are now visible
    \endlist
 
    The transition can use the \l ViewTransition property to access more details about
    the item that is being added. See the \l ViewTransition documentation for more details
    and examples on using these transitions.
 
    \note This transition is not applied to the items that are already part of the positioner
    at the time of its creation. In this case, the \l populate transition is applied instead.
 
    \sa populate, ViewTransition, {Qt Quick Examples - Positioners}
*/
/*!
    \qmlproperty Transition QtQuick::Grid::move
 
    This property holds the transition to run for items that have moved within the
    positioner. For a positioner, this applies to:
 
    \list
    \li Child items that move when they are displaced due to the addition, removal or
       rearrangement of other items in the positioner
    \li Child items that are repositioned due to the resizing of other items in the positioner
    \endlist
 
    The transition can use the \l ViewTransition property to access more details about
    the item that is being moved. Note, however, that for this move transition, the
    ViewTransition.targetIndexes and ViewTransition.targetItems lists are only set when
    this transition is triggered by the addition of other items in the positioner; in other
    cases, these lists will be empty.  See the \l ViewTransition documentation for more details
    and examples on using these transitions.
 
    \sa add, populate, ViewTransition, {Qt Quick Examples - Positioners}
*/
/*!
  \qmlproperty real QtQuick::Grid::spacing
 
  The spacing is the amount in pixels left empty between adjacent
  items. The amount of spacing applied will be the same in the
  horizontal and vertical directions. The default spacing is 0.
 
  The below example places a Grid containing a red, a blue and a
  green rectangle on a gray background. The area the grid positioner
  occupies is colored white. The positioner on the left has the
  no spacing (the default), and the positioner on the right has
  a spacing of 6.
 
  \inlineimage qml-grid-no-spacing.png
               {Four colored squares in a grid with no spacing}
  \inlineimage qml-grid-spacing.png
               {Four colored squares in a grid with spacing between them}
 
  \sa rows, columns
*/
/*!
    \qmlmethod void QtQuick::Grid::forceLayout()
    \since 5.9
 
    Grid typically positions its children once per frame. This means that
    inside script blocks it is possible for the underlying children to have changed,
    but the Grid to have not yet been updated accordingly.
 
    This method forces the Grid to immediately respond to any outstanding
    changes in its children.
 
    \b Note: methods in general should only be called after the Component has completed.
*/
/*!
    \qmlsignal QtQuick::Grid::positioningComplete()
    \since 5.9
 
    This signal is emitted when positioning has been completed.
*/
 
class QQuickGridPrivate : public QQuickBasePositionerPrivate
{
    Q_DECLARE_PUBLIC(QQuickGrid)
 
public:
    QQuickGridPrivate()
        : QQuickBasePositionerPrivate()
    {}
 
    void effectiveLayoutDirectionChange() override
    {
        Q_Q(QQuickGrid);
        // For RTL layout the positioning changes when the width changes.
        if (getEffectiveLayoutDirection(q) == Qt::RightToLeft)
            addItemChangeListener(this, QQuickItemPrivate::Geometry);
        else
            removeItemChangeListener(this, QQuickItemPrivate::Geometry);
        // Don't postpone, as it might be the only trigger for visible changes.
        q->prePositioning();
        emit q->effectiveLayoutDirectionChanged();
        emit q->effectiveHorizontalAlignmentChanged(q->effectiveHAlign());
    }
};
 
QQuickGrid::QQuickGrid(QQuickItem *parent)
    : QQuickBasePositioner(*new QQuickGridPrivate, Both, parent)
    , m_rows(-1)
    , m_columns(-1)
    , m_rowSpacing(-1)
    , m_columnSpacing(-1)
    , m_useRowSpacing(false)
    , m_useColumnSpacing(false)
    , m_flow(LeftToRight)
    , m_hItemAlign(AlignLeft)
    , m_vItemAlign(AlignTop)
{
}
 
/*!
    \qmlproperty int QtQuick::Grid::columns
 
    This property holds the number of columns in the grid. The default
    number of columns is 4.
 
    If the grid does not have enough items to fill the specified
    number of columns, some columns will be of zero width.
*/
 
/*!
    \qmlproperty int QtQuick::Grid::rows
    This property holds the number of rows in the grid.
 
    If the grid does not have enough items to fill the specified
    number of rows, some rows will be of zero width.
*/
 
void QQuickGrid::setColumns(const int columns)
{
    if (columns == m_columns)
        return;
    m_columns = columns;
    prePositioning();
    emit columnsChanged();
}
 
void QQuickGrid::setRows(const int rows)
{
    if (rows == m_rows)
        return;
    m_rows = rows;
    prePositioning();
    emit rowsChanged();
}
 
/*!
    \qmlproperty enumeration QtQuick::Grid::flow
    This property holds the flow of the layout.
 
    Possible values are:
 
    \list
    \li Grid.LeftToRight (default) - Items are positioned next to
       each other in the \l layoutDirection, then wrapped to the next line.
    \li Grid.TopToBottom - Items are positioned next to each
       other from top to bottom, then wrapped to the next column.
    \endlist
*/
QQuickGrid::Flow QQuickGrid::flow() const
{
    return m_flow;
}
 
void QQuickGrid::setFlow(Flow flow)
{
    if (m_flow != flow) {
        m_flow = flow;
        prePositioning();
        emit flowChanged();
    }
}
 
/*!
    \qmlproperty real QtQuick::Grid::rowSpacing
 
    This property holds the spacing in pixels between rows.
 
    If this property is not set, then spacing is used for the row spacing.
 
    By default this property is not set.
 
    \sa columnSpacing
    \since 5.0
*/
void QQuickGrid::setRowSpacing(const qreal rowSpacing)
{
    if (rowSpacing == m_rowSpacing)
        return;
    m_rowSpacing = rowSpacing;
    m_useRowSpacing = true;
    prePositioning();
    emit rowSpacingChanged();
}
 
/*!
    \qmlproperty real QtQuick::Grid::columnSpacing
 
    This property holds the spacing in pixels between columns.
 
    If this property is not set, then spacing is used for the column spacing.
 
    By default this property is not set.
 
    \sa rowSpacing
    \since 5.0
*/
void QQuickGrid::setColumnSpacing(const qreal columnSpacing)
{
    if (columnSpacing == m_columnSpacing)
        return;
    m_columnSpacing = columnSpacing;
    m_useColumnSpacing = true;
    prePositioning();
    emit columnSpacingChanged();
}
 
/*!
    \qmlproperty enumeration QtQuick::Grid::layoutDirection
 
    This property holds the layout direction of the layout.
 
    Possible values are:
 
    \list
    \li Qt.LeftToRight (default) - Items are positioned from the top to bottom,
    and left to right. The flow direction is dependent on the
    \l Grid::flow property.
    \li Qt.RightToLeft - Items are positioned from the top to bottom,
    and right to left. The flow direction is dependent on the
    \l Grid::flow property.
    \endlist
 
    \sa Flow::layoutDirection, Row::layoutDirection
*/
Qt::LayoutDirection QQuickGrid::layoutDirection() const
{
    return QQuickBasePositionerPrivate::getLayoutDirection(this);
}
 
void QQuickGrid::setLayoutDirection(Qt::LayoutDirection layoutDirection)
{
    QQuickBasePositionerPrivate *d = static_cast<QQuickBasePositionerPrivate*>(QQuickBasePositionerPrivate::get(this));
    if (d->layoutDirection != layoutDirection) {
        d->layoutDirection = layoutDirection;
        emit layoutDirectionChanged();
        d->effectiveLayoutDirectionChange();
    }
}
 
/*!
    \qmlproperty enumeration QtQuick::Grid::effectiveLayoutDirection
    This property holds the effective layout direction of the grid.
 
    When using the attached property \l {LayoutMirroring::enabled}{LayoutMirroring::enabled} for locale layouts,
    the visual layout direction of the grid positioner will be mirrored. However, the
    property \l {Grid::layoutDirection}{layoutDirection} will remain unchanged.
 
    \sa Grid::layoutDirection, {LayoutMirroring}{LayoutMirroring}
*/
Qt::LayoutDirection QQuickGrid::effectiveLayoutDirection() const
{
    return QQuickBasePositionerPrivate::getEffectiveLayoutDirection(this);
}
 
/*!
    \qmlproperty enumeration QtQuick::Grid::horizontalItemAlignment
    \qmlproperty enumeration QtQuick::Grid::verticalItemAlignment
    \qmlproperty enumeration QtQuick::Grid::effectiveHorizontalItemAlignment
    \since 5.1
 
    Sets the horizontal and vertical alignment of items in the Grid. By default,
    the items are vertically aligned to the top. Horizontal
    alignment follows the layoutDirection of the Grid, for example when having a layoutDirection
    from LeftToRight, the items will be aligned on the left.
 
    The valid values for \c horizontalItemAlignment are, \c Grid.AlignLeft, \c Grid.AlignRight and
    \c Grid.AlignHCenter.
 
    The valid values for \c verticalItemAlignment are \c Grid.AlignTop, \c Grid.AlignBottom
    and \c Grid.AlignVCenter.
 
    The below images show three examples of how to align items.
 
    \table
    \row
        \li
        \li \inlineimage gridLayout_aligntopleft.png
            {Colored rectangles aligned top-left in grid cells}
        \li \inlineimage gridLayout_aligntop.png
            {Colored rectangles aligned top-center in grid cells}
        \li \inlineimage gridLayout_aligncenter.png
            {Colored rectangles centered in grid cells}
    \row
        \li Horizontal alignment
        \li AlignLeft
        \li AlignHCenter
        \li AlignHCenter
    \row
        \li Vertical alignment
        \li AlignTop
        \li AlignTop
        \li AlignVCenter
    \endtable
 
 
    When mirroring the layout using either the attached property LayoutMirroring::enabled or
    by setting the layoutDirection, the horizontal alignment of items will be mirrored as well.
    However, the property \c horizontalItemAlignment will remain unchanged.
    To query the effective horizontal alignment of items, use the read-only property
    \c effectiveHorizontalItemAlignment.
 
    \sa Grid::layoutDirection, {LayoutMirroring}{LayoutMirroring}
*/
QQuickGrid::HAlignment QQuickGrid::hItemAlign() const
{
    return m_hItemAlign;
}
void QQuickGrid::setHItemAlign(HAlignment align)
{
    if (m_hItemAlign != align) {
        m_hItemAlign = align;
        prePositioning();
        emit horizontalAlignmentChanged(align);
        emit effectiveHorizontalAlignmentChanged(effectiveHAlign());
    }
}
 
QQuickGrid::HAlignment QQuickGrid::effectiveHAlign() const
{
    HAlignment effectiveAlignment = m_hItemAlign;
    if (effectiveLayoutDirection() == Qt::RightToLeft) {
        switch (hItemAlign()) {
        case AlignLeft:
            effectiveAlignment = AlignRight;
            break;
        case AlignRight:
            effectiveAlignment = AlignLeft;
            break;
        default:
            break;
        }
    }
    return effectiveAlignment;
}
 
 
QQuickGrid::VAlignment QQuickGrid::vItemAlign() const
{
    return m_vItemAlign;
}
void QQuickGrid::setVItemAlign(VAlignment align)
{
    if (m_vItemAlign != align) {
        m_vItemAlign = align;
        prePositioning();
        emit verticalAlignmentChanged(align);
    }
}
 
void QQuickGrid::doPositioning(QSizeF *contentSize)
{
    //Precondition: All items in the positioned list have a valid item pointer and should be positioned
    QQuickBasePositionerPrivate *d = static_cast<QQuickBasePositionerPrivate*>(QQuickBasePositionerPrivate::get(this));
    int c = m_columns;
    int r = m_rows;
    const int numVisible = int(positionedItems.size());
 
    if (m_columns <= 0 && m_rows <= 0) {
        c = 4;
        r = (numVisible+3)/4;
    } else if (m_rows <= 0) {
        r = (numVisible+(m_columns-1))/m_columns;
    } else if (m_columns <= 0) {
        c = (numVisible+(m_rows-1))/m_rows;
    }
 
    if (r == 0 || c == 0) {
        contentSize->setHeight(topPadding() + bottomPadding());
        contentSize->setWidth(leftPadding() + rightPadding());
        return; //Nothing else to do
    }
 
    if (numVisible > r * c) {
        qmlWarning(this) << "Grid contains more visible items (" << numVisible << ") than rows*columns (" << r * c << ")";
    }
 
    QList<qreal> maxColWidth;
    QList<qreal> maxRowHeight;
    int childIndex =0;
    if (m_flow == LeftToRight) {
        for (int i = 0; i < r; i++) {
            for (int j = 0; j < c; j++) {
                if (j == 0)
                    maxRowHeight << 0;
                if (i == 0)
                    maxColWidth << 0;
 
                if (childIndex == numVisible)
                    break;
 
                const PositionedItem &child = positionedItems[childIndex++];
                if (child.item->width() > maxColWidth[j])
                    maxColWidth[j] = child.item->width();
                if (child.item->height() > maxRowHeight[i])
                    maxRowHeight[i] = child.item->height();
            }
        }
    } else {
        for (int j = 0; j < c; j++) {
            for (int i = 0; i < r; i++) {
                if (j == 0)
                    maxRowHeight << 0;
                if (i == 0)
                    maxColWidth << 0;
 
                if (childIndex == numVisible)
                    break;
 
                const PositionedItem &child = positionedItems[childIndex++];
                if (child.item->width() > maxColWidth[j])
                    maxColWidth[j] = child.item->width();
                if (child.item->height() > maxRowHeight[i])
                    maxRowHeight[i] = child.item->height();
            }
        }
    }
 
    qreal columnSpacing = m_useColumnSpacing ? m_columnSpacing : spacing();
    qreal rowSpacing = m_useRowSpacing ? m_rowSpacing : spacing();
 
    qreal widthSum = 0;
    for (int j = 0; j < maxColWidth.size(); j++) {
        if (j)
            widthSum += columnSpacing;
        widthSum += maxColWidth[j];
    }
    widthSum += leftPadding() + rightPadding();
 
    qreal heightSum = 0;
    for (int i = 0; i < maxRowHeight.size(); i++) {
        if (i)
            heightSum += rowSpacing;
        heightSum += maxRowHeight[i];
    }
    heightSum += topPadding() + bottomPadding();
 
    contentSize->setHeight(heightSum);
    contentSize->setWidth(widthSum);
 
    int end = 0;
    if (widthValid())
        end = width();
    else
        end = widthSum;
 
    qreal xoffset = leftPadding();
    if (!d->isLeftToRight())
        xoffset = end - rightPadding();
    qreal yoffset = topPadding();
    int curRow =0;
    int curCol =0;
    for (PositionedItem &child : positionedItems) {
        qreal childXOffset = xoffset;
 
        if (effectiveHAlign() == AlignRight)
            childXOffset += maxColWidth[curCol] - child.item->width();
        else if (hItemAlign() == AlignHCenter)
            childXOffset += (maxColWidth[curCol] - child.item->width())/2.0;
 
        if (!d->isLeftToRight())
            childXOffset -= maxColWidth[curCol];
 
        qreal alignYOffset = yoffset;
        if (m_vItemAlign == AlignVCenter)
            alignYOffset += (maxRowHeight[curRow] - child.item->height())/2.0;
        else if (m_vItemAlign == AlignBottom)
            alignYOffset += maxRowHeight[curRow] - child.item->height();
 
        positionItem(childXOffset, alignYOffset, &child);
        child.updatePadding(leftPadding(), topPadding(), rightPadding(), bottomPadding());
 
        if (m_flow == LeftToRight) {
            if (d->isLeftToRight())
                xoffset += maxColWidth[curCol]+columnSpacing;
            else
                xoffset -= maxColWidth[curCol]+columnSpacing;
            curCol++;
            curCol %= c;
            if (!curCol) {
                yoffset += maxRowHeight[curRow]+rowSpacing;
                if (d->isLeftToRight())
                    xoffset = leftPadding();
                else
                    xoffset = end - rightPadding();
                curRow++;
                if (curRow>=r)
                    break;
            }
        } else {
            yoffset += maxRowHeight[curRow]+rowSpacing;
            curRow++;
            curRow %= r;
            if (!curRow) {
                if (d->isLeftToRight())
                    xoffset += maxColWidth[curCol]+columnSpacing;
                else
                    xoffset -= maxColWidth[curCol]+columnSpacing;
                yoffset = topPadding();
                curCol++;
                if (curCol>=c)
                    break;
            }
        }
    }
}
 
void QQuickGrid::reportConflictingAnchors()
{
    QQuickBasePositionerPrivate *d = static_cast<QQuickBasePositionerPrivate*>(QQuickBasePositionerPrivate::get(this));
    for (const PositionedItem &child : positionedItems) {
        if (child.item) {
            QQuickAnchors *anchors = QQuickItemPrivate::get(static_cast<QQuickItem *>(child.item))->_anchors;
            if (anchors && (anchors->usedAnchors() || anchors->fill() || anchors->centerIn())) {
                d->anchorConflict = true;
                break;
            }
        }
    }
    if (d->anchorConflict)
        qmlWarning(this) << "Cannot specify anchors for items inside Grid." << " Grid will not function.";
}
 
/*!
    \qmltype Flow
    \nativetype QQuickFlow
    \inqmlmodule QtQuick
    \inherits Item
    \ingroup qtquick-positioners
    \brief Positions its children side by side, wrapping as necessary.
 
    The Flow item positions its child items like words on a page, wrapping them
    to create rows or columns of items.
 
    Below is a Flow that contains various \l Text items:
 
    \snippet qml/flow.qml flow item
 
    The Flow item automatically positions the child \l Text items side by
    side, wrapping as necessary:
 
    \image qml-flow-snippet.png {Text items wrapped like words on a page
           within a Flow positioner}
 
    If an item within a Flow is not \l {Item::}{visible}, or if it has a width or
    height of 0, the item will not be laid out and it will not be visible within the
    Flow. Also, since a Flow automatically positions its children, a child
    item within a Flow should not set its \l {Item::x}{x} or \l {Item::y}{y} positions
    or anchor itself with any of the \l {Item::anchors}{anchor} properties.
 
    For more information on using Flow and other related positioner-types, see
    \l{Item Positioners}.
 
  \sa Column, Row, Grid, Positioner, {Qt Quick Examples - Positioners}
*/
/*!
    \since 5.6
    \qmlproperty real QtQuick::Flow::padding
    \qmlproperty real QtQuick::Flow::topPadding
    \qmlproperty real QtQuick::Flow::leftPadding
    \qmlproperty real QtQuick::Flow::bottomPadding
    \qmlproperty real QtQuick::Flow::rightPadding
 
    These properties hold the padding around the content.
*/
/*!
    \qmlproperty Transition QtQuick::Flow::populate
 
    This property holds the transition to be run for items that are part of
    this positioner at the time of its creation. The transition is run when the positioner
    is first created.
 
    The transition can use the \l ViewTransition property to access more details about
    the item that is being added. See the \l ViewTransition documentation for more details
    and examples on using these transitions.
 
    \sa add, ViewTransition, {Qt Quick Examples - Positioners}
*/
/*!
    \qmlproperty Transition QtQuick::Flow::add
 
    This property holds the transition to be run for items that are added to this
    positioner. For a positioner, this applies to:
 
    \list
    \li Items that are created or reparented as a child of the positioner after the
        positioner has been created
    \li Child items that change their \l Item::visible property from false to true, and thus
       are now visible
    \endlist
 
    The transition can use the \l ViewTransition property to access more details about
    the item that is being added. See the \l ViewTransition documentation for more details
    and examples on using these transitions.
 
    \note This transition is not applied to the items that are already part of the positioner
    at the time of its creation. In this case, the \l populate transition is applied instead.
 
    \sa populate, ViewTransition, {Qt Quick Examples - Positioners}
*/
/*!
    \qmlproperty Transition QtQuick::Flow::move
 
    This property holds the transition to run for items that have moved within the
    positioner. For a positioner, this applies to:
 
    \list
    \li Child items that move when they are displaced due to the addition, removal or
       rearrangement of other items in the positioner
    \li Child items that are repositioned due to the resizing of other items in the positioner
    \endlist
 
    The transition can use the \l ViewTransition property to access more details about
    the item that is being moved. Note, however, that for this move transition, the
    ViewTransition.targetIndexes and ViewTransition.targetItems lists are only set when
    this transition is triggered by the addition of other items in the positioner; in other
    cases, these lists will be empty.  See the \l ViewTransition documentation for more details
    and examples on using these transitions.
 
    \sa add, populate, ViewTransition, {Qt Quick Examples - Positioners}
*/
/*!
  \qmlproperty real QtQuick::Flow::spacing
 
  spacing is the amount in pixels left empty between each adjacent
  item, and defaults to 0.
 
  \sa Grid::spacing
*/
/*!
    \qmlmethod void QtQuick::Flow::forceLayout()
    \since 5.9
 
    Flow typically positions its children once per frame. This means that
    inside script blocks it is possible for the underlying children to have changed,
    but the Flow to have not yet been updated accordingly.
 
    This method forces the Flow to immediately respond to any outstanding
    changes in its children.
 
 
    \b Note: methods in general should only be called after the Component has completed.
*/
/*!
    \qmlsignal QtQuick::Flow::positioningComplete()
    \since 5.9
 
    This signal is emitted when positioning has been completed.
*/
 
class QQuickFlowPrivate : public QQuickBasePositionerPrivate
{
    Q_DECLARE_PUBLIC(QQuickFlow)
 
public:
    QQuickFlowPrivate()
        : QQuickBasePositionerPrivate(), flow(QQuickFlow::LeftToRight)
    {}
 
    void effectiveLayoutDirectionChange() override
    {
        Q_Q(QQuickFlow);
        // Don't postpone, as it might be the only trigger for visible changes.
        q->prePositioning();
        emit q->effectiveLayoutDirectionChanged();
    }
 
    QQuickFlow::Flow flow;
};
 
QQuickFlow::QQuickFlow(QQuickItem *parent)
: QQuickBasePositioner(*(new QQuickFlowPrivate), Both, parent)
{
    Q_D(QQuickFlow);
    // Flow layout requires relayout if its own size changes too.
    d->addItemChangeListener(d, QQuickItemPrivate::Geometry);
}
 
/*!
    \qmlproperty enumeration QtQuick::Flow::flow
    This property holds the flow of the layout.
 
    Possible values are:
 
    \list
    \li Flow.LeftToRight (default) - Items are positioned next to
    to each other according to the \l layoutDirection until the width of the Flow
    is exceeded, then wrapped to the next line.
    \li Flow.TopToBottom - Items are positioned next to each
    other from top to bottom until the height of the Flow is exceeded,
    then wrapped to the next column.
    \endlist
*/
QQuickFlow::Flow QQuickFlow::flow() const
{
    Q_D(const QQuickFlow);
    return d->flow;
}
 
void QQuickFlow::setFlow(Flow flow)
{
    Q_D(QQuickFlow);
    if (d->flow != flow) {
        d->flow = flow;
        prePositioning();
        emit flowChanged();
    }
}
 
/*!
    \qmlproperty enumeration QtQuick::Flow::layoutDirection
 
    This property holds the layout direction of the layout.
 
    Possible values are:
 
    \list
    \li Qt.LeftToRight (default) - Items are positioned from the top to bottom,
    and left to right. The flow direction is dependent on the
    \l Flow::flow property.
    \li Qt.RightToLeft - Items are positioned from the top to bottom,
    and right to left. The flow direction is dependent on the
    \l Flow::flow property.
    \endlist
 
    \sa Grid::layoutDirection, Row::layoutDirection
*/
 
Qt::LayoutDirection QQuickFlow::layoutDirection() const
{
    Q_D(const QQuickFlow);
    return d->layoutDirection;
}
 
void QQuickFlow::setLayoutDirection(Qt::LayoutDirection layoutDirection)
{
    Q_D(QQuickFlow);
    if (d->layoutDirection != layoutDirection) {
        d->layoutDirection = layoutDirection;
        emit layoutDirectionChanged();
        d->effectiveLayoutDirectionChange();
    }
}
 
/*!
    \qmlproperty enumeration QtQuick::Flow::effectiveLayoutDirection
    This property holds the effective layout direction of the flow.
 
    When using the attached property \l {LayoutMirroring::enabled}{LayoutMirroring::enabled} for locale layouts,
    the visual layout direction of the grid positioner will be mirrored. However, the
    property \l {Flow::layoutDirection}{layoutDirection} will remain unchanged.
 
    \sa Flow::layoutDirection, {LayoutMirroring}{LayoutMirroring}
*/
 
Qt::LayoutDirection QQuickFlow::effectiveLayoutDirection() const
{
    return QQuickBasePositionerPrivate::getEffectiveLayoutDirection(this);
}
 
void QQuickFlow::doPositioning(QSizeF *contentSize)
{
    //Precondition: All items in the positioned list have a valid item pointer and should be positioned
    Q_D(QQuickFlow);
 
    qreal hoffset1 = leftPadding();
    qreal hoffset2 = rightPadding();
    if (!d->isLeftToRight())
        qSwap(hoffset1, hoffset2);
    qreal hoffset = hoffset1;
    const qreal voffset1 = topPadding();
    qreal voffset = voffset1;
    qreal linemax = 0;
    QList<qreal> hoffsets;
    contentSize->setWidth(qMax(contentSize->width(), hoffset1 + hoffset2));
    contentSize->setHeight(qMax(contentSize->height(), voffset + bottomPadding()));
 
    for (PositionedItem &child : positionedItems) {
        if (d->flow == LeftToRight)  {
            if (widthValid() && hoffset != hoffset1 && hoffset + child.item->width() + hoffset2 > width()) {
                hoffset = hoffset1;
                voffset += linemax + spacing();
                linemax = 0;
            }
        } else {
            if (heightValid() && voffset != voffset1 && voffset + child.item->height() + bottomPadding() > height()) {
                voffset = voffset1;
                hoffset += linemax + spacing();
                linemax = 0;
            }
        }
 
        if (d->isLeftToRight()) {
            positionItem(hoffset, voffset, &child);
            child.updatePadding(leftPadding(), topPadding(), rightPadding(), bottomPadding());
        } else {
            hoffsets << hoffset;
            positionItemY(voffset, &child);
            child.topPadding = topPadding();
            child.bottomPadding = bottomPadding();
        }
 
        contentSize->setWidth(qMax(contentSize->width(), hoffset + child.item->width() + hoffset2));
        contentSize->setHeight(qMax(contentSize->height(), voffset + child.item->height() + bottomPadding()));
 
        if (d->flow == LeftToRight)  {
            hoffset += child.item->width();
            hoffset += spacing();
            linemax = qMax(linemax, child.item->height());
        } else {
            voffset += child.item->height();
            voffset += spacing();
            linemax = qMax(linemax, child.item->width());
        }
    }
 
    if (d->isLeftToRight())
        return;
 
    qreal end;
    if (widthValid())
        end = width();
    else
        end = contentSize->width();
    int acc = 0;
    for (PositionedItem &child : positionedItems) {
        hoffset = end - hoffsets[acc++] - child.item->width();
        positionItemX(hoffset, &child);
        child.leftPadding = leftPadding();
        child.rightPadding = rightPadding();
    }
}
 
void QQuickFlow::reportConflictingAnchors()
{
    Q_D(QQuickFlow);
    for (const PositionedItem &child : positionedItems) {
        if (child.item) {
            QQuickAnchors *anchors = QQuickItemPrivate::get(static_cast<QQuickItem *>(child.item))->_anchors;
            if (anchors && (anchors->usedAnchors() || anchors->fill() || anchors->centerIn())) {
                d->anchorConflict = true;
                break;
            }
        }
    }
    if (d->anchorConflict)
        qmlWarning(this) << "Cannot specify anchors for items inside Flow." << " Flow will not function.";
}
 
QT_END_NAMESPACE
 
#include "moc_qquickpositioners_p.cpp"