qquickcontainer.cpp

Go to the documentation of this file.

// Copyright (C) 2020 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
 
#include "qquickcontainer_p.h"
#include "qquickcontainer_p_p.h"
 
#include <QtQuick/private/qquickflickable_p.h>
 
QT_BEGIN_NAMESPACE
 
 
static QQuickItem *effectiveContentItem(QQuickItem *item)
{
    QQuickFlickable *flickable = qobject_cast<QQuickFlickable *>(item);
    if (flickable)
        return flickable->contentItem();
    return item;
}
 
void QQuickContainerPrivate::init()
{
    Q_Q(QQuickContainer);
    contentModel = new QQmlObjectModel(q);
    QObject::connect(contentModel, &QQmlObjectModel::countChanged, q, &QQuickContainer::countChanged);
    QObject::connect(contentModel, &QQmlObjectModel::childrenChanged, q, &QQuickContainer::contentChildrenChanged);
    connect(q, &QQuickControl::implicitContentWidthChanged, this, &QQuickContainerPrivate::updateContentWidth);
    connect(q, &QQuickControl::implicitContentHeightChanged, this, &QQuickContainerPrivate::updateContentHeight);
}
 
void QQuickContainerPrivate::cleanup()
{
    Q_Q(QQuickContainer);
    // ensure correct destruction order (QTBUG-46798)
    const int count = contentModel->count();
    for (int i = 0; i < count; ++i) {
        QQuickItem *item = itemAt(i);
        if (item)
            QQuickItemPrivate::get(item)->removeItemChangeListener(this, changeTypes);
    }
 
    if (contentItem) {
        QQuickItem *focusItem = QQuickItemPrivate::get(contentItem)->subFocusItem;
        if (focusItem && window)
            QQuickWindowPrivate::get(window)->clearFocusInScope(contentItem, focusItem, Qt::OtherFocusReason);
 
        q->contentItemChange(nullptr, contentItem);
        QQuickControlPrivate::hideOldItem(contentItem);
    }
 
    QObject::disconnect(contentModel, &QQmlObjectModel::countChanged, q, &QQuickContainer::countChanged);
    QObject::disconnect(contentModel, &QQmlObjectModel::childrenChanged, q, &QQuickContainer::contentChildrenChanged);
    delete contentModel;
    contentModel = nullptr;
}
 
QQuickItem *QQuickContainerPrivate::itemAt(int index) const
{
    return qobject_cast<QQuickItem *>(contentModel->get(index));
}
 
void QQuickContainerPrivate::insertItem(int index, QQuickItem *item)
{
    Q_Q(QQuickContainer);
    if (!q->isContent(item))
        return;
    contentData.append(item);
 
    updatingCurrent = true;
 
    item->setParentItem(effectiveContentItem(q->contentItem()));
    QQuickItemPrivate::get(item)->addItemChangeListener(this, changeTypes);
    contentModel->insert(index, item);
 
    q->itemAdded(index, item);
 
    int count = contentModel->count();
    for (int i = index + 1; i < count; ++i)
        q->itemMoved(i, itemAt(i));
 
    if (count == 1 && currentIndex == -1)
        q->setCurrentIndex(index);
 
    updatingCurrent = false;
}
 
void QQuickContainerPrivate::moveItem(int from, int to, QQuickItem *item)
{
    Q_Q(QQuickContainer);
    int oldCurrent = currentIndex;
    contentModel->move(from, to);
 
    updatingCurrent = true;
 
    q->itemMoved(to, item);
 
    if (from < to) {
        for (int i = from; i < to; ++i)
            q->itemMoved(i, itemAt(i));
    } else {
        for (int i = from; i > to; --i)
            q->itemMoved(i, itemAt(i));
    }
 
    if (from == oldCurrent)
        q->setCurrentIndex(to);
    else if (from < oldCurrent && to >= oldCurrent)
        q->setCurrentIndex(oldCurrent - 1);
    else if (from > oldCurrent && to <= oldCurrent)
        q->setCurrentIndex(oldCurrent + 1);
 
    updatingCurrent = false;
}
 
void QQuickContainerPrivate::removeItem(int index, QQuickItem *item)
{
    Q_Q(QQuickContainer);
    if (!q->isContent(item))
        return;
    contentData.removeOne(item);
 
    updatingCurrent = true;
 
    int count = contentModel->count();
    bool currentChanged = false;
    if (index == currentIndex && (index != 0 || count == 1)) {
        q->setCurrentIndex(currentIndex - 1);
    } else if (index < currentIndex) {
        --currentIndex;
        currentChanged = true;
    }
 
    QQuickItemPrivate::get(item)->removeItemChangeListener(this, changeTypes);
    item->setParentItem(nullptr);
    contentModel->remove(index);
    --count;
 
    q->itemRemoved(index, item);
 
    for (int i = index; i < count; ++i)
        q->itemMoved(i, itemAt(i));
 
    if (currentChanged)
        emit q->currentIndexChanged();
 
    updatingCurrent = false;
}
 
void QQuickContainerPrivate::reorderItems()
{
    Q_Q(QQuickContainer);
    if (!contentItem)
        return;
 
    QList<QQuickItem *> siblings = effectiveContentItem(contentItem)->childItems();
 
    int to = 0;
    for (int i = 0; i < siblings.size(); ++i) {
        QQuickItem* sibling = siblings.at(i);
        if (QQuickItemPrivate::get(sibling)->isTransparentForPositioner())
            continue;
        int index = contentModel->indexOf(sibling, nullptr);
        q->moveItem(index, to++);
    }
}
 
void QQuickContainerPrivate::_q_currentIndexChanged()
{
    Q_Q(QQuickContainer);
    if (!updatingCurrent)
        q->setCurrentIndex(contentItem ? contentItem->property("currentIndex").toInt() : -1);
}
 
void QQuickContainerPrivate::itemChildAdded(QQuickItem *, QQuickItem *child)
{
    // add dynamically reparented items (eg. by a Repeater)
    if (!QQuickItemPrivate::get(child)->isTransparentForPositioner() && !contentData.contains(child))
        insertItem(contentModel->count(), child);
}
 
void QQuickContainerPrivate::itemParentChanged(QQuickItem *item, QQuickItem *parent)
{
    // remove dynamically unparented items (eg. by a Repeater)
    if (!parent)
        removeItem(contentModel->indexOf(item, nullptr), item);
}
 
void QQuickContainerPrivate::itemSiblingOrderChanged(QQuickItem *)
{
    if (!componentComplete)
        return;
 
    // reorder the restacked items (eg. by a Repeater)
    reorderItems();
}
 
void QQuickContainerPrivate::itemDestroyed(QQuickItem *item)
{
    int index = contentModel->indexOf(item, nullptr);
    if (index != -1)
        removeItem(index, item);
    else
        QQuickControlPrivate::itemDestroyed(item);
}
 
void QQuickContainerPrivate::contentData_append(QQmlListProperty<QObject> *prop, QObject *obj)
{
    QQuickContainer *q = static_cast<QQuickContainer *>(prop->object);
    QQuickContainerPrivate *p = QQuickContainerPrivate::get(q);
    QQuickItem *item = qobject_cast<QQuickItem *>(obj);
    if (item) {
        if (QQuickItemPrivate::get(item)->isTransparentForPositioner())
            item->setParentItem(effectiveContentItem(q->contentItem()));
        else if (p->contentModel->indexOf(item, nullptr) == -1)
            q->addItem(item);
    } else {
        p->contentData.append(obj);
    }
}
 
qsizetype QQuickContainerPrivate::contentData_count(QQmlListProperty<QObject> *prop)
{
    QQuickContainer *q = static_cast<QQuickContainer *>(prop->object);
    return QQuickContainerPrivate::get(q)->contentData.size();
}
 
QObject *QQuickContainerPrivate::contentData_at(QQmlListProperty<QObject> *prop, qsizetype index)
{
    QQuickContainer *q = static_cast<QQuickContainer *>(prop->object);
    return QQuickContainerPrivate::get(q)->contentData.value(index);
}
 
void QQuickContainerPrivate::contentData_clear(QQmlListProperty<QObject> *prop)
{
    QQuickContainer *q = static_cast<QQuickContainer *>(prop->object);
    return QQuickContainerPrivate::get(q)->contentData.clear();
}
 
void QQuickContainerPrivate::contentChildren_append(QQmlListProperty<QQuickItem> *prop, QQuickItem *item)
{
    QQuickContainer *q = static_cast<QQuickContainer *>(prop->object);
    q->addItem(item);
}
 
qsizetype QQuickContainerPrivate::contentChildren_count(QQmlListProperty<QQuickItem> *prop)
{
    QQuickContainer *q = static_cast<QQuickContainer *>(prop->object);
    return QQuickContainerPrivate::get(q)->contentModel->count();
}
 
QQuickItem *QQuickContainerPrivate::contentChildren_at(QQmlListProperty<QQuickItem> *prop, qsizetype index)
{
    QQuickContainer *q = static_cast<QQuickContainer *>(prop->object);
    return q->itemAt(index);
}
 
void QQuickContainerPrivate::contentChildren_clear(QQmlListProperty<QQuickItem> *prop)
{
    QQuickContainer *q = static_cast<QQuickContainer *>(prop->object);
    return QQuickContainerPrivate::get(q)->contentModel->clear();
}
 
void QQuickContainerPrivate::updateContentWidth()
{
    Q_Q(QQuickContainer);
    if (hasContentWidth || qFuzzyCompare(contentWidth, implicitContentWidth) || !contentModel)
        return;
 
    contentWidth = implicitContentWidth;
    emit q->contentWidthChanged();
}
 
void QQuickContainerPrivate::updateContentHeight()
{
    Q_Q(QQuickContainer);
    if (hasContentHeight || qFuzzyCompare(contentHeight, implicitContentHeight) || !contentModel)
        return;
 
    contentHeight = implicitContentHeight;
    emit q->contentHeightChanged();
}
 
QQuickContainer::QQuickContainer(QQuickItem *parent)
    : QQuickControl(*(new QQuickContainerPrivate), parent)
{
    Q_D(QQuickContainer);
    d->init();
}
 
QQuickContainer::QQuickContainer(QQuickContainerPrivate &dd, QQuickItem *parent)
    : QQuickControl(dd, parent)
{
    Q_D(QQuickContainer);
    d->init();
}
 
QQuickContainer::~QQuickContainer()
{
    Q_D(QQuickContainer);
    d->cleanup();
}
 
int QQuickContainer::count() const
{
    Q_D(const QQuickContainer);
    return d->contentModel->count();
}
 
QQuickItem *QQuickContainer::itemAt(int index) const
{
    Q_D(const QQuickContainer);
    return d->itemAt(index);
}
 
void QQuickContainer::addItem(QQuickItem *item)
{
    Q_D(QQuickContainer);
    insertItem(d->contentModel->count(), item);
}
 
void QQuickContainer::insertItem(int index, QQuickItem *item)
{
    Q_D(QQuickContainer);
    if (!item)
        return;
    const int count = d->contentModel->count();
    if (index < 0 || index > count)
        index = count;
 
    int oldIndex = d->contentModel->indexOf(item, nullptr);
    if (oldIndex != -1) {
        if (oldIndex < index)
            --index;
        if (oldIndex != index)
            d->moveItem(oldIndex, index, item);
    } else {
        d->insertItem(index, item);
    }
}
 
void QQuickContainer::moveItem(int from, int to)
{
    Q_D(QQuickContainer);
    const int count = d->contentModel->count();
    if (from < 0 || from > count - 1)
        return;
    if (to < 0 || to > count - 1)
        to = count - 1;
 
    if (from != to)
        d->moveItem(from, to, d->itemAt(from));
}
 
void QQuickContainer::removeItem(QQuickItem *item)
{
    Q_D(QQuickContainer);
    if (!item)
        return;
 
    const int index = d->contentModel->indexOf(item, nullptr);
    if (index == -1)
        return;
 
    d->removeItem(index, item);
    item->deleteLater();
}
 
QQuickItem *QQuickContainer::takeItem(int index)
{
    Q_D(QQuickContainer);
    const int count = d->contentModel->count();
    if (index < 0 || index >= count)
        return nullptr;
 
    QQuickItem *item = itemAt(index);
    if (item)
        d->removeItem(index, item);
    return item;
}
 
QVariant QQuickContainer::contentModel() const
{
    Q_D(const QQuickContainer);
    return QVariant::fromValue(d->contentModel);
}
 
QQmlListProperty<QObject> QQuickContainer::contentData()
{
    Q_D(QQuickContainer);
    if (!d->contentItem)
        d->executeContentItem();
    return QQmlListProperty<QObject>(this, nullptr,
                                     QQuickContainerPrivate::contentData_append,
                                     QQuickContainerPrivate::contentData_count,
                                     QQuickContainerPrivate::contentData_at,
                                     QQuickContainerPrivate::contentData_clear);
}
 
QQmlListProperty<QQuickItem> QQuickContainer::contentChildren()
{
    return QQmlListProperty<QQuickItem>(this, nullptr,
                                        QQuickContainerPrivate::contentChildren_append,
                                        QQuickContainerPrivate::contentChildren_count,
                                        QQuickContainerPrivate::contentChildren_at,
                                        QQuickContainerPrivate::contentChildren_clear);
}
 
int QQuickContainer::currentIndex() const
{
    Q_D(const QQuickContainer);
    return d->currentIndex;
}
 
void QQuickContainer::setCurrentIndex(int index)
{
    Q_D(QQuickContainer);
    if (d->currentIndex == index)
        return;
 
    d->currentIndex = index;
    emit currentIndexChanged();
    emit currentItemChanged();
}
 
void QQuickContainer::incrementCurrentIndex()
{
    Q_D(QQuickContainer);
    if (d->currentIndex < count() - 1)
        setCurrentIndex(d->currentIndex + 1);
}
 
void QQuickContainer::decrementCurrentIndex()
{
    Q_D(QQuickContainer);
    if (d->currentIndex > 0)
        setCurrentIndex(d->currentIndex - 1);
}
 
QQuickItem *QQuickContainer::currentItem() const
{
    Q_D(const QQuickContainer);
    return itemAt(d->currentIndex);
}
 
qreal QQuickContainer::contentWidth() const
{
    Q_D(const QQuickContainer);
    return d->contentWidth;
}
 
void QQuickContainer::setContentWidth(qreal width)
{
    Q_D(QQuickContainer);
    d->hasContentWidth = true;
    if (qFuzzyCompare(d->contentWidth, width))
        return;
 
    d->contentWidth = width;
    d->resizeContent();
    emit contentWidthChanged();
}
 
void QQuickContainer::resetContentWidth()
{
    Q_D(QQuickContainer);
    if (!d->hasContentWidth)
        return;
 
    d->hasContentWidth = false;
    d->updateContentWidth();
}
 
qreal QQuickContainer::contentHeight() const
{
    Q_D(const QQuickContainer);
    return d->contentHeight;
}
 
void QQuickContainer::setContentHeight(qreal height)
{
    Q_D(QQuickContainer);
    d->hasContentHeight = true;
    if (qFuzzyCompare(d->contentHeight, height))
        return;
 
    d->contentHeight = height;
    d->resizeContent();
    emit contentHeightChanged();
}
 
void QQuickContainer::resetContentHeight()
{
    Q_D(QQuickContainer);
    if (!d->hasContentHeight)
        return;
 
    d->hasContentHeight = false;
    d->updateContentHeight();
}
 
void QQuickContainer::componentComplete()
{
    Q_D(QQuickContainer);
    QQuickControl::componentComplete();
    d->reorderItems();
}
 
void QQuickContainer::itemChange(ItemChange change, const ItemChangeData &data)
{
    Q_D(QQuickContainer);
    QQuickControl::itemChange(change, data);
    if (change == QQuickItem::ItemChildAddedChange && isComponentComplete() && data.item != d->background && data.item != d->contentItem) {
        if (!QQuickItemPrivate::get(data.item)->isTransparentForPositioner() && d->contentModel->indexOf(data.item, nullptr) == -1)
            addItem(data.item);
    }
}
 
void QQuickContainer::contentItemChange(QQuickItem *newItem, QQuickItem *oldItem)
{
    Q_D(QQuickContainer);
    QQuickControl::contentItemChange(newItem, oldItem);
 
    static const int slotIndex = metaObject()->indexOfSlot("_q_currentIndexChanged()");
 
    if (oldItem) {
        QQuickItemPrivate::get(oldItem)->removeItemChangeListener(d, QQuickItemPrivate::Children | QQuickItemPrivate::ImplicitWidth | QQuickItemPrivate::ImplicitHeight);
        QQuickItem *oldContentItem = effectiveContentItem(oldItem);
        if (oldContentItem != oldItem)
            QQuickItemPrivate::get(oldContentItem)->removeItemChangeListener(d, QQuickItemPrivate::Children);
 
        int signalIndex = oldItem->metaObject()->indexOfSignal("currentIndexChanged()");
        if (signalIndex != -1)
            QMetaObject::disconnect(oldItem, signalIndex, this, slotIndex);
    }
 
    if (newItem) {
        QQuickItemPrivate::get(newItem)->addItemChangeListener(d, QQuickItemPrivate::Children | QQuickItemPrivate::ImplicitWidth | QQuickItemPrivate::ImplicitHeight);
        QQuickItem *newContentItem = effectiveContentItem(newItem);
        if (newContentItem != newItem)
            QQuickItemPrivate::get(newContentItem)->addItemChangeListener(d, QQuickItemPrivate::Children);
 
        int signalIndex = newItem->metaObject()->indexOfSignal("currentIndexChanged()");
        if (signalIndex != -1)
            QMetaObject::connect(newItem, signalIndex, this, slotIndex);
    }
}
 
bool QQuickContainer::isContent(QQuickItem *item) const
{
    // If the item has a QML context associated to it (it was created in QML),
    // we add it to the content model. Otherwise, it's probably the default
    // highlight item that is always created by the item views, which we need
    // to exclude.
    //
    // TODO: Find a better way to identify/exclude the highlight item...
    return qmlContext(item);
}
 
void QQuickContainer::itemAdded(int index, QQuickItem *item)
{
    Q_UNUSED(index);
    Q_UNUSED(item);
}
 
void QQuickContainer::itemMoved(int index, QQuickItem *item)
{
    Q_UNUSED(index);
    Q_UNUSED(item);
}
 
void QQuickContainer::itemRemoved(int index, QQuickItem *item)
{
    Q_UNUSED(index);
    Q_UNUSED(item);
}
 
QT_END_NAMESPACE
 
#include "moc_qquickcontainer_p.cpp"