Revision control
Copy as Markdown
// 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
// Qt-Security score:significant reason:default
#include "qquickcontainer_p.h"
#include "qquickcontainer_p_p.h"
#include <QtQuick/private/qquickflickable_p.h>
#include <QtQuick/private/qquickitemview_p.h>
QT_BEGIN_NAMESPACE
/*!
\qmltype Container
\inherits Control
//! \nativetype QQuickContainer
\inqmlmodule QtQuick.Controls
\since 5.7
\ingroup qtquickcontrols-containers
\brief Abstract base type providing functionality common to containers.
Container is the base type of container-like user interface controls that
allow dynamic insertion and removal of items.
\section2 Using Containers
Typically, items are statically declared as children of Container, but it
is also possible to \l {addItem}{add}, \l {insertItem}{insert},
\l {moveItem}{move} and \l {removeItem}{remove} items dynamically. The
items in a container can be accessed using \l itemAt() or
\l contentChildren.
Most containers have the concept of a "current" item. The current item is
specified via the \l currentIndex property, and can be accessed using the
read-only \l currentItem property.
The following example illustrates dynamic insertion of items to a \l TabBar,
which is one of the concrete implementations of Container.
\code
Row {
TabBar {
id: tabBar
currentIndex: 0
width: parent.width - addButton.width
TabButton { text: "TabButton" }
}
Component {
id: tabButton
TabButton { text: "TabButton" }
}
Button {
id: addButton
text: "+"
flat: true
onClicked: {
tabBar.addItem(tabButton.createObject(tabBar))
console.log("added:", tabBar.itemAt(tabBar.count - 1))
}
}
}
\endcode
\section2 Managing the Current Index
When using multiple containers, such as \l TabBar and \l SwipeView, together,
their \l currentIndex properties can be bound to each other to keep them in
sync. When the user interacts with either container, its current index changes
automatically propagate to the other container.
Notice, however, that assigning a \c currentIndex value in JavaScript removes
the respective binding. In order to retain the bindings, use the following
methods to alter the current index:
\list
\li \l incrementCurrentIndex()
\li \l decrementCurrentIndex()
\li \l setCurrentIndex()
\endlist
\code
TabBar {
id: tabBar
currentIndex: swipeView.currentIndex
}
SwipeView {
id: swipeView
currentIndex: tabBar.currentIndex
}
Button {
text: qsTr("Home")
onClicked: swipeView.setCurrentIndex(0)
enabled: swipeView.currentIndex != 0
}
Button {
text: qsTr("Previous")
onClicked: swipeView.decrementCurrentIndex()
enabled: swipeView.currentIndex > 0
}
Button {
text: qsTr("Next")
onClicked: swipeView.incrementCurrentIndex()
enabled: swipeView.currentIndex < swipeView.count - 1
}
\endcode
\section2 Implementing Containers
Container does not provide any default visualization. It is used to implement
such containers as \l SwipeView and \l TabBar. When implementing a custom
container, the most important part of the API is \l contentModel, which provides
the contained items in a way that it can be used as an object model for item
views and repeaters.
\code
Container {
id: container
contentItem: ListView {
model: container.contentModel
snapMode: ListView.SnapOneItem
orientation: ListView.Horizontal
}
Text {
text: "Page 1"
width: container.width
height: container.height
}
Text {
text: "Page 2"
width: container.width
height: container.height
}
}
\endcode
Notice how the sizes of the page items are set by hand. This is because the
example uses a plain Container, which does not make any assumptions on the
visual layout. It is typically not necessary to specify sizes for items in
concrete Container implementations, such as \l SwipeView and \l TabBar.
\sa {Container Controls}
*/
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);
setSizePolicy(QLayoutPolicy::Preferred, QLayoutPolicy::Preferred);
}
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)
deliveryAgentPrivate()->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()));
maybeCullItem(item);
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);
const bool item_inDestructor = QQuickItemPrivate::get(item)->inDestructor;
if (!item_inDestructor && !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;
}
if (!item_inDestructor) {
// already handled by ~QQuickItem
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;
// The item view eventually reparents all the items of the content model
// from the container. At this stage (during component complete), however, due
// to optimisation strategies in the item views, this doesn't happen when the
// visible area of the item view is less than the total content width of the items
// within the content model. This can cause issues while reordering. Thus, it's
// better to skip reordering the item within the content model once it's known
// that it will be reparented to the item views.
bool allowReorder = true;
if (!qobject_cast<QQuickFlickable *>(contentItem)) {
for (int index = 0; index < contentModel->count(); index++) {
if (const auto *item = qobject_cast<QQuickItem *>(contentModel->get(index))) {
const auto *parentItem = item->parentItem();
if (parentItem && !qobject_cast<QQuickItemView *>(parentItem->parentItem())) {
allowReorder = false;
break;
}
}
}
}
if (allowReorder) {
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;
const int index = contentModel->indexOf(sibling, nullptr);
if (index >= 0)
q->moveItem(index, to++);
}
}
}
void QQuickContainerPrivate::maybeCullItem(QQuickItem *item)
{
if (QQuickItemPrivate::get(item)->isTransparentForPositioner())
return;
// Items like Repeater don't control the visibility of the items they create,
// so we can't expected them to uncull items added dynamically. As mentioned
// below, Repeater _does_ uncull items added to it, but unlike e.g. ListView,
// it shouldn't care if its size becomes zero and so it shouldn't manage
// the culled state of items in the same way.
if (!qobject_cast<QQuickItemView *>(contentItem))
return;
// Only cull items if the contentItem has a zero size; otherwise let the
// contentItem manage it.
const bool hasZeroSize = qFuzzyIsNull(width) && qFuzzyIsNull(height);
if (!hasZeroSize)
return;
QQuickItemPrivate::get(item)->setCulled(true);
}
void QQuickContainerPrivate::maybeCullItems()
{
if (!contentItem)
return;
const QList<QQuickItem *> childItems = effectiveContentItem(contentItem)->childItems();
for (auto &childItem : childItems)
maybeCullItem(childItem);
}
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();
}
/*!
\qmlproperty int QtQuick.Controls::Container::count
\readonly
This property holds the number of items.
*/
int QQuickContainer::count() const
{
Q_D(const QQuickContainer);
return d->contentModel->count();
}
/*!
\qmlmethod Item QtQuick.Controls::Container::itemAt(int index)
Returns the item at \a index, or \c null if it does not exist.
*/
QQuickItem *QQuickContainer::itemAt(int index) const
{
Q_D(const QQuickContainer);
return d->itemAt(index);
}
/*!
\qmlmethod void QtQuick.Controls::Container::addItem(Item item)
Adds an \a item.
*/
void QQuickContainer::addItem(QQuickItem *item)
{
Q_D(QQuickContainer);
insertItem(d->contentModel->count(), item);
}
/*!
\qmlmethod void QtQuick.Controls::Container::insertItem(int index, Item item)
Inserts an \a item at \a index.
*/
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);
}
}
/*!
\qmlmethod void QtQuick.Controls::Container::moveItem(int from, int to)
Moves an item \a from one index \a to another.
*/
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));
}
/*!
\since QtQuick.Controls 2.3 (Qt 5.10)
\qmlmethod void QtQuick.Controls::Container::removeItem(Item item)
Removes and destroys the specified \a item.
*/
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();
}
/*!
\since QtQuick.Controls 2.3 (Qt 5.10)
\qmlmethod Item QtQuick.Controls::Container::takeItem(int index)
Removes and returns the item at \a index.
\note The ownership of the item is transferred to the caller.
*/
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;
}
/*!
\qmlproperty model QtQuick.Controls::Container::contentModel
\readonly
This property holds the content model of items.
The content model is provided for visualization purposes. It can be assigned
as a model to a content item that presents the contents of the container.
\code
Container {
id: container
contentItem: ListView {
model: container.contentModel
}
}
\endcode
\sa contentData, contentChildren
*/
QVariant QQuickContainer::contentModel() const
{
Q_D(const QQuickContainer);
return QVariant::fromValue(d->contentModel);
}
/*!
\qmlproperty list<QtObject> QtQuick.Controls::Container::contentData
\qmldefault
This property holds the list of content data.
The list contains all objects that have been declared in QML as children
of the container, and also items that have been dynamically added or
inserted using the \l addItem() and \l insertItem() methods, respectively.
\note Unlike \c contentChildren, \c contentData does include non-visual QML
objects. It is not re-ordered when items are inserted or moved.
\sa Item::data, contentChildren
*/
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);
}
/*!
\qmlproperty list<Item> QtQuick.Controls::Container::contentChildren
This property holds the list of content children.
The list contains all items that have been declared in QML as children
of the container, and also items that have been dynamically added or
inserted using the \l addItem() and \l insertItem() methods, respectively.
\note Unlike \c contentData, \c contentChildren does not include non-visual
QML objects. It is re-ordered when items are inserted or moved.
\sa Item::children, contentData
*/
QQmlListProperty<QQuickItem> QQuickContainer::contentChildren()
{
return QQmlListProperty<QQuickItem>(this, nullptr,
QQuickContainerPrivate::contentChildren_append,
QQuickContainerPrivate::contentChildren_count,
QQuickContainerPrivate::contentChildren_at,
QQuickContainerPrivate::contentChildren_clear);
}
/*!
\qmlproperty int QtQuick.Controls::Container::currentIndex
This property holds the index of the current item.
\sa currentItem, {Managing the Current Index}
*/
int QQuickContainer::currentIndex() const
{
Q_D(const QQuickContainer);
return d->currentIndex;
}
/*!
\qmlmethod void QtQuick.Controls::Container::setCurrentIndex(int index)
Sets the current \a index of the container.
This method can be called to set a specific current index without breaking
existing \c currentIndex bindings.
\sa currentIndex, {Managing the Current Index}
*/
void QQuickContainer::setCurrentIndex(int index)
{
Q_D(QQuickContainer);
if (d->currentIndex == index)
return;
d->currentIndex = index;
emit currentIndexChanged();
emit currentItemChanged();
}
/*!
\qmlmethod void QtQuick.Controls::Container::incrementCurrentIndex()
\since QtQuick.Controls 2.1 (Qt 5.8)
Increments the current index of the container.
This method can be called to alter the current index without breaking
existing \c currentIndex bindings.
\sa currentIndex, {Managing the Current Index}
*/
void QQuickContainer::incrementCurrentIndex()
{
Q_D(QQuickContainer);
if (d->currentIndex < count() - 1)
setCurrentIndex(d->currentIndex + 1);
}
/*!
\qmlmethod void QtQuick.Controls::Container::decrementCurrentIndex()
\since QtQuick.Controls 2.1 (Qt 5.8)
Decrements the current index of the container.
This method can be called to alter the current index without breaking
existing \c currentIndex bindings.
\sa currentIndex, {Managing the Current Index}
*/
void QQuickContainer::decrementCurrentIndex()
{
Q_D(QQuickContainer);
if (d->currentIndex > 0)
setCurrentIndex(d->currentIndex - 1);
}
/*!
\qmlproperty Item QtQuick.Controls::Container::currentItem
\readonly
This property holds the current item.
\sa currentIndex
*/
QQuickItem *QQuickContainer::currentItem() const
{
Q_D(const QQuickContainer);
return itemAt(d->currentIndex);
}
/*!
\since QtQuick.Controls 2.5 (Qt 5.12)
\qmlproperty real QtQuick.Controls::Container::contentWidth
This property holds the content width. It is used for calculating the total
implicit width of the container.
Unless explicitly overridden, the content width is automatically calculated
based on the implicit width of the items in the container.
\sa contentHeight
*/
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();
d->updateImplicitContentWidth();
emit contentWidthChanged();
}
void QQuickContainer::resetContentWidth()
{
Q_D(QQuickContainer);
if (!d->hasContentWidth)
return;
d->hasContentWidth = false;
d->updateImplicitContentWidth();
}
/*!
\since QtQuick.Controls 2.5 (Qt 5.12)
\qmlproperty real QtQuick.Controls::Container::contentHeight
This property holds the content height. It is used for calculating the total
implicit height of the container.
Unless explicitly overridden, the content height is automatically calculated
based on the implicit height of the items in the container.
\sa contentWidth
*/
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();
d->updateImplicitContentHeight();
emit contentHeightChanged();
}
void QQuickContainer::resetContentHeight()
{
Q_D(QQuickContainer);
if (!d->hasContentHeight)
return;
d->hasContentHeight = false;
d->updateImplicitContentHeight();
}
qreal QQuickContainerPrivate::getContentWidth() const
{
if (hasContentWidth)
return contentWidth;
return QQuickControlPrivate::getContentWidth();
}
qreal QQuickContainerPrivate::getContentHeight() const
{
if (hasContentHeight)
return contentHeight;
return QQuickControlPrivate::getContentHeight();
}
void QQuickContainer::componentComplete()
{
Q_D(QQuickContainer);
QQuickControl::componentComplete();
d->reorderItems();
d->maybeCullItems();
}
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"