Revision control
Copy as Markdown
// Copyright (C) 2018 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
#include "qqmltableinstancemodel_p.h"
#include "qqmlabstractdelegatecomponent_p.h"
#include <QtCore/QTimer>
#include <QtQml/private/qqmlincubator_p.h>
#include <QtQmlModels/private/qqmlchangeset_p.h>
#include <QtQml/private/qqmlcomponent_p.h>
#include <QtCore/qtyperevision.h>
QT_BEGIN_NAMESPACE
const char* kModelItemTag = "_tableinstancemodel_modelItem";
bool QQmlTableInstanceModel::isDoneIncubating(QQmlDelegateModelItem *modelItem)
{
QQDMIncubationTask *incubationTask = modelItem->incubationTask();
if (!incubationTask)
return true;
switch (incubationTask->status()) {
case QQmlIncubator::Ready:
case QQmlIncubator::Error:
return true;
default:
break;
}
return false;
}
void QQmlTableInstanceModel::deleteModelItemLater(QQmlDelegateModelItem *modelItem)
{
Q_ASSERT(modelItem);
modelItem->destroyObject();
modelItem->deleteLater();
}
QQmlTableInstanceModel::QQmlTableInstanceModel(QQmlContext *qmlContext, QObject *parent)
: QQmlInstanceModel(*(new QObjectPrivate()), parent)
, m_qmlContext(qmlContext)
, m_metaType(QQml::makeRefPointer<QQmlDelegateModelItemMetaType>(
m_qmlContext->engine()->handle(), this))
{
}
void QQmlTableInstanceModel::useImportVersion(QTypeRevision version)
{
m_adaptorModel.useImportVersion(version);
}
QQmlTableInstanceModel::~QQmlTableInstanceModel()
{
for (const auto modelItem : m_modelItems) {
// No item in m_modelItems should be referenced at this point. The view
// should release all its items before it deletes this model. Only model items
// that are still being incubated should be left for us to delete.
// We can't rely on that, though. So we only check the strong ref.
Q_ASSERT(modelItem->objectStrongRef() == 0);
Q_ASSERT(modelItem->incubationTask());
// Check that we are not being deleted while we're
// in the process of e.g emitting a created signal.
Q_ASSERT(modelItem->scriptRef() == 0);
modelItem->destroyObject();
}
deleteAllFinishedIncubationTasks();
qDeleteAll(m_modelItems);
drainReusableItemsPool(0);
// We don't expect there to be any released items at this point.
// The view must explicitly call commitReleasedItems() after each
// rebuild of the viewport, and long before the model is destructed.
Q_ASSERT(m_releasedItems.isEmpty());
}
QQmlComponent *QQmlTableInstanceModel::resolveDelegate(int index)
{
if (m_delegateChooser) {
const int row = m_adaptorModel.rowAt(index);
const int column = m_adaptorModel.columnAt(index);
QQmlComponent *delegate = nullptr;
QQmlAbstractDelegateComponent *chooser = m_delegateChooser;
do {
delegate = chooser->delegate(&m_adaptorModel, row, column);
chooser = qobject_cast<QQmlAbstractDelegateComponent *>(delegate);
} while (chooser);
return delegate;
}
return m_delegate;
}
QQmlDelegateModelItem *QQmlTableInstanceModel::resolveModelItem(int flatIndex, const QModelIndex &modelIndex)
{
Q_ASSERT(flatIndex >= 0 && flatIndex < m_adaptorModel.count());
// Check if an item for the given index is already loaded and ready
if (QQmlDelegateModelItem *modelItem = m_modelItems.value(flatIndex, nullptr))
return modelItem;
QQmlComponent *delegate = resolveDelegate(flatIndex);
if (!delegate)
return nullptr;
// Check if the temporary release cache contains the requested item
if (modelIndex.isValid()) {
const auto it = std::find_if(m_releasedItems.cbegin(), m_releasedItems.cend(),
[&modelIndex](const QQmlDelegateModelItem *item) {
return item->persistentModelIndex() == modelIndex;
});
if (it != m_releasedItems.cend()) {
QQmlDelegateModelItem *modelItem = *it;
// Note: a rebuild can change which delegate a DelegateChooser assigns to a cell, so the
// released item may no longer use the right delegate, even if it has the correct index.
if (modelItem->delegate() == delegate) {
m_releasedItems.erase(it);
restoreFromReleasedItemsCache(modelItem, flatIndex);
return modelItem;
}
}
}
// Check if the pool contains an item with the same delegate that can be reused
if (QQmlDelegateModelItem *modelItem = m_reusableItemsPool.takeItem(delegate, flatIndex)) {
m_modelItems.insert(flatIndex, modelItem);
reuseItem(modelItem, flatIndex);
return modelItem;
}
// Create a new item from scratch
if (QQmlDelegateModelItem *modelItem = m_adaptorModel.createItem(m_metaType.data(), flatIndex)) {
modelItem->setDelegate(delegate);
m_modelItems.insert(flatIndex, modelItem);
return modelItem;
}
qWarning() << Q_FUNC_INFO << "failed creating a model item for index: " << flatIndex << modelIndex;
return nullptr;
}
void QQmlTableInstanceModel::commitReleasedItems()
{
// Transfer all released items from the temporary cache to the reuse pool. From
// now on, they can only be reused based on delegate type and not model index.
for (auto *item : std::as_const(m_releasedItems)) {
item->setPersistentModelIndex(QModelIndex());
if (m_reusableItemsPool.insertItem(item))
emit itemPooled(item->modelIndex(), item->object());
else
destroyModelItem(item, Deferred);
}
m_releasedItems.clear();
}
QObject *QQmlTableInstanceModel::object(int index, QQmlIncubator::IncubationMode incubationMode)
{
Q_ASSERT(m_delegate);
QModelIndex modelIndex;
if (const QAbstractItemModel *aim = abstractItemModel()) {
// A valid QModelIndex is needed for resolveModelItem() to match
// items in the release cache rather than just delegate type alone.
const int row = m_adaptorModel.rowAt(index);
const int column = m_adaptorModel.columnAt(index);
modelIndex = aim->index(row, column);
}
if (QQmlDelegateModelItem *modelItem = resolveModelItem(index, modelIndex)) {
// Return the incubated object, or start an async incubation task and return nullptr for now
return incubateModelItemIfNeeded(modelItem, incubationMode);
}
return nullptr;
}
QObject *QQmlTableInstanceModel::incubateModelItemIfNeeded(QQmlDelegateModelItem *modelItem, QQmlIncubator::IncubationMode incubationMode)
{
if (modelItem->object()) {
// The model item has already been incubated. So
// just bump the ref-count and return it.
return modelItem->referenceObjectWeak();
}
// The object is not ready, and needs to be incubated
incubateModelItem(modelItem, incubationMode);
if (!isDoneIncubating(modelItem))
return nullptr;
// Incubation is done, so the task should be removed
Q_ASSERT(!modelItem->incubationTask());
// Incubation was completed sync and successful
if (modelItem->object())
return modelItem->referenceObjectWeak();
// The object was incubated synchronously (otherwise we would return above). But since
// we have no object, the incubation must have failed. And when we have no object, there
// should be no object references either. And there should also not be any internal script
// refs at this point. So we delete the model item.
Q_ASSERT(!modelItem->isObjectReferenced());
Q_ASSERT(!modelItem->isScriptReferenced());
m_modelItems.remove(modelItem->modelIndex());
delete modelItem;
return nullptr;
}
QQmlInstanceModel::ReleaseFlags QQmlTableInstanceModel::release(QObject *object, ReusableFlag reusable)
{
Q_ASSERT(object);
auto modelItem = qvariant_cast<QQmlDelegateModelItem *>(object->property(kModelItemTag));
Q_ASSERT(modelItem);
// Ensure that the object was incubated by this QQmlTableInstanceModel
Q_ASSERT(m_modelItems.contains(modelItem->modelIndex()));
Q_ASSERT(m_modelItems[modelItem->modelIndex()]->object() == object);
if (!modelItem->releaseObjectWeak())
return QQmlDelegateModel::Referenced;
if (modelItem->isScriptReferenced()) {
// We still have an internal reference to this object, which means that we are told to release an
// object while the createdItem signal for it is still on the stack. This can happen when objects
// are e.g delivered async, and the user flicks back and forth quicker than the loading can catch
// up with. The view might then find that the object is no longer visible and should be released.
// We detect this case in incubatorStatusChanged(), and delete it there instead. But from the callers
// point of view, it should consider it destroyed.
return QQmlDelegateModel::Destroyed;
}
// The item is not referenced by anyone
m_modelItems.remove(modelItem->modelIndex());
if (reusable == Reusable) {
// Stage the item in a temporary cache rather than moving it directly to the reuse pool.
// The view calls commitReleasedItems() once the rebuild is done, which transfers the cache
// to the pool. Keeping a temporary cache lets resolveModelItem() match a staged item by
// persistent model index first, during viewport builds, and hand back the exact same
// delegate item that was showing that cell. That way we can avoid the otherwise full
// reuse of an item, which includes emitting pooled signals etc. This also preserves
// ongoing visual state such as animations.
m_releasedItems.append(modelItem);
return QQmlInstanceModel::Pooled;
}
// The item is not reused or referenced by anyone, so just delete it
destroyModelItem(modelItem, Deferred);
return QQmlInstanceModel::Destroyed;
}
void QQmlTableInstanceModel::destroyModelItem(QQmlDelegateModelItem *modelItem, DestructionMode mode)
{
emit destroyingItem(modelItem->object());
if (mode == Deferred)
modelItem->destroyObjectLater();
else
modelItem->destroyObject();
delete modelItem;
}
void QQmlTableInstanceModel::dispose(QObject *object)
{
Q_ASSERT(object);
auto modelItem = qvariant_cast<QQmlDelegateModelItem *>(object->property(kModelItemTag));
Q_ASSERT(modelItem);
modelItem->releaseObjectWeak();
// The item is not referenced by anyone
Q_ASSERT(!modelItem->isObjectReferenced());
Q_ASSERT(!modelItem->isScriptReferenced());
// Ensure that the object was incubated by this QQmlTableInstanceModel
Q_ASSERT(m_modelItems.contains(modelItem->modelIndex()));
Q_ASSERT(m_modelItems[modelItem->modelIndex()]->object() == object);
m_modelItems.remove(modelItem->modelIndex());
emit destroyingItem(object);
modelItem->destroyObject();
delete modelItem;
}
void QQmlTableInstanceModel::cancel(int index)
{
auto modelItem = m_modelItems.value(index);
Q_ASSERT(modelItem);
// Since the view expects the item to be incubating, there should be
// an incubation task. And since the incubation is not done, no-one
// should yet have received, and therfore hold a reference to, the object.
Q_ASSERT(modelItem->incubationTask());
Q_ASSERT(!modelItem->isObjectReferenced());
m_modelItems.remove(index);
modelItem->destroyObject();
// modelItem->incubationTask will be deleted from the modelItems destructor
delete modelItem;
}
void QQmlTableInstanceModel::drainReusableItemsPool(int maxPoolTime)
{
m_reusableItemsPool.drain(maxPoolTime, [this](QQmlDelegateModelItem *modelItem) {
destroyModelItem(modelItem, Immediate);
});
}
void QQmlTableInstanceModel::restoreFromReleasedItemsCache(QQmlDelegateModelItem *item, int newFlatIndex)
{
// Row/column shifts elsewhere in the table may have changed this item's
// position, so update its index before handing it back from the released
// items cache. Also notify the view so it can refresh any index-dependent
// required properties (such as 'expanded' and 'hasChildren').
m_modelItems.insert(newFlatIndex, item);
const bool alwaysEmit = true;
const bool init = false;
const int row = m_adaptorModel.rowAt(newFlatIndex);
const int column = m_adaptorModel.columnAt(newFlatIndex);
item->setModelIndex(newFlatIndex, row, column, alwaysEmit);
emit updateItemProperties(newFlatIndex, item->object(), init);
}
void QQmlTableInstanceModel::reuseItem(QQmlDelegateModelItem *item, int newModelIndex)
{
// Update the context properties index, row and column on
// the delegate item, and inform the application about it.
// Note that we set alwaysEmit to true, to force all bindings
// to be reevaluated, even if the index didn't change (since
// the model can have changed size since last usage).
const bool alwaysEmit = true;
const int newRow = m_adaptorModel.rowAt(newModelIndex);
const int newColumn = m_adaptorModel.columnAt(newModelIndex);
item->setModelIndex(newModelIndex, newRow, newColumn, alwaysEmit);
if (auto *qaim = abstractItemModel())
item->setPersistentModelIndex(qaim->index(newRow, newColumn));
// Notify the application that all 'dynamic'/role-based context data has
// changed as well (their getter function will use the updated index).
auto const itemAsList = QList<QQmlDelegateModelItem *>() << item;
auto const updateAllRoles = QList<int>();
m_adaptorModel.notify(itemAsList, newModelIndex, 1, updateAllRoles);
// Inform the view that the item is recycled. This will typically result
// in the view updating its own attached delegate item properties.
const bool init = false;
emit updateItemProperties(newModelIndex, item->object(), init);
emit itemReused(newModelIndex, item->object());
}
void QQmlTableInstanceModel::incubateModelItem(QQmlDelegateModelItem *modelItem, QQmlIncubator::IncubationMode incubationMode)
{
// Guard the model item temporarily so that it's not deleted from
// incubatorStatusChanged(), in case the incubation is done synchronously.
QQmlDelegateModelItem::ScriptReference scriptRef(modelItem);
if (QQDMIncubationTask *incubationTask = modelItem->incubationTask()) {
// We're already incubating the model item from a previous request. If the previous call requested
// the item async, but the current request needs it sync, we need to force-complete the incubation.
const bool sync = (incubationMode == QQmlIncubator::Synchronous || incubationMode == QQmlIncubator::AsynchronousIfNested);
if (sync && incubationTask->incubationMode() == QQmlIncubator::Asynchronous)
incubationTask->forceCompletion();
} else if (m_qmlContext && m_qmlContext->isValid()) {
modelItem->setIncubationTask(
new QQmlTableInstanceModelIncubationTask(this, modelItem, incubationMode));
// TODO: In order to retain compatibility, we cannot allow the incubation task to clear the
// context object in the presence of required properties. This results in the context
// properties still being available in the delegate even though they shouldn't.
// modelItem->incubationTask->incubating = modelItem;
QQmlComponent *delegate = modelItem->delegate();
QQmlContext *creationContext = delegate->creationContext();
const QQmlRefPointer<QQmlContextData> componentContext
= QQmlContextData::get(creationContext ? creationContext : m_qmlContext.data());
QQmlComponentPrivate *cp = QQmlComponentPrivate::get(delegate);
if (cp->isBound()) {
modelItem->setContextData(componentContext);
// Ignore return value of initProxy. We want to know the proxy when assigning required
// properties, but we don't want it to pollute our context. The context is bound.
if (m_adaptorModel.hasProxyObject())
modelItem->initProxy();
cp->incubateObject(
modelItem->incubationTask(), delegate, m_qmlContext->engine(), componentContext,
QQmlContextData::get(m_qmlContext));
} else {
QQmlRefPointer<QQmlContextData> ctxt = QQmlContextData::createRefCounted(
QQmlContextData::get(creationContext ? creationContext : m_qmlContext.data()));
ctxt->setContextObject(modelItem);
modelItem->setContextData(ctxt);
// If the model is read-only we cannot just expose the object as context
// We actually need a separate model object to moderate access.
if (m_adaptorModel.hasProxyObject()) {
if (m_adaptorModel.delegateModelAccess == QQmlDelegateModel::ReadOnly)
modelItem->initProxy();
else
ctxt = modelItem->initProxy();
}
cp->incubateObject(
modelItem->incubationTask(), modelItem->delegate(), m_qmlContext->engine(),
ctxt, QQmlContextData::get(m_qmlContext));
}
}
}
void QQmlTableInstanceModel::incubatorStatusChanged(QQmlTableInstanceModelIncubationTask *incubationTask, QQmlIncubator::Status status)
{
QQmlDelegateModelItem *modelItem = incubationTask->modelItemToIncubate;
Q_ASSERT(modelItem->incubationTask());
modelItem->clearIncubationTask();
incubationTask->modelItemToIncubate = nullptr;
if (status == QQmlIncubator::Ready) {
QObject *object = modelItem->object();
Q_ASSERT(object);
if (auto *qaim = abstractItemModel()) {
// Optimization: store a persistent model index so that resolveModelItem(QModelIndex)
// can match this item by index after a rebuild, even if its flat index has shifted
// due to row or column insertions/removals.
modelItem->setPersistentModelIndex(qaim->index(modelItem->modelRow(), modelItem->modelColumn()));
}
// Tag the incubated object with the model item for easy retrieval upon release etc.
object->setProperty(kModelItemTag, QVariant::fromValue(modelItem));
// Emit that the item has been created. What normally happens next is that the view
// upon receiving the signal asks for the model item once more. And since the item is
// now in the map, it will be returned directly.
QQmlDelegateModelItem::ScriptReference scriptRef(modelItem);
emit createdItem(modelItem->modelIndex(), object);
} else if (status == QQmlIncubator::Error) {
qWarning() << "Error incubating delegate:" << incubationTask->errors();
}
if (!modelItem->isScriptReferenced() && !modelItem->isObjectReferenced()) {
// We have no internal reference to the model item, and the view has no
// reference to the incubated object. So just delete the model item.
// Note that being here means that the object was incubated _async_
// (otherwise modelItem->isReferenced() would be true).
m_modelItems.remove(modelItem->modelIndex());
if (QObject *object = modelItem->object()) {
QQmlDelegateModelItem::ScriptReference scriptRef(modelItem);
emit destroyingItem(object);
}
Q_ASSERT(!modelItem->isScriptReferenced());
deleteModelItemLater(modelItem);
}
deleteIncubationTaskLater(incubationTask);
}
QQmlIncubator::Status QQmlTableInstanceModel::incubationStatus(int index) {
const auto modelItem = m_modelItems.value(index, nullptr);
if (!modelItem)
return QQmlIncubator::Null;
if (QQDMIncubationTask *incubationTask = modelItem->incubationTask())
return incubationTask->status();
// Since we clear the incubation task when we're done
// incubating, it means that the status is Ready.
return QQmlIncubator::Ready;
}
bool QQmlTableInstanceModel::setRequiredProperty(int index, const QString &name, const QVariant &value)
{
// This function can be called from the view upon
// receiving the initItem signal. It can be used to
// give all required delegate properties used by the
// view an initial value.
const auto modelItem = m_modelItems.value(index, nullptr);
if (!modelItem)
return false;
if (!modelItem->object())
return false;
if (!modelItem->incubationTask())
return false;
bool wasInRequired = false;
const auto task = QQmlIncubatorPrivate::get(modelItem->incubationTask());
RequiredProperties *props = task->requiredProperties();
if (props->empty())
return false;
QQmlProperty componentProp = QQmlComponentPrivate::removePropertyFromRequired(
modelItem->object(), name, props, QQmlEnginePrivate::get(task->enginePriv),
&wasInRequired);
if (wasInRequired)
componentProp.write(value);
return wasInRequired;
}
QQmlDelegateModelItem *QQmlTableInstanceModel::getModelItem(int index)
{
return m_modelItems.value(index, nullptr);
}
void QQmlTableInstanceModel::deleteIncubationTaskLater(QQmlIncubator *incubationTask)
{
// We often need to post-delete incubation tasks, since we cannot
// delete them while we're in the middle of an incubation change callback.
Q_ASSERT(!m_finishedIncubationTasks.contains(incubationTask));
m_finishedIncubationTasks.append(incubationTask);
if (m_finishedIncubationTasks.size() == 1)
QTimer::singleShot(1, this, &QQmlTableInstanceModel::deleteAllFinishedIncubationTasks);
}
void QQmlTableInstanceModel::deleteAllFinishedIncubationTasks()
{
qDeleteAll(m_finishedIncubationTasks);
m_finishedIncubationTasks.clear();
}
QVariant QQmlTableInstanceModel::model() const
{
return m_adaptorModel.model();
}
void QQmlTableInstanceModel::forceSetModel(const QVariant &model)
{
// Pooled items are still accessible/alive for the application, and
// needs to stay in sync with the model. So we need to drain the pool
// completely when the model changes.
drainReusableItemsPool(0);
if (auto const aim = abstractItemModel()) {
disconnect(aim, &QAbstractItemModel::dataChanged, this, &QQmlTableInstanceModel::dataChangedCallback);
disconnect(aim, &QAbstractItemModel::modelAboutToBeReset, this, &QQmlTableInstanceModel::modelAboutToBeResetCallback);
}
m_adaptorModel.setModel(model);
if (auto const aim = abstractItemModel()) {
connect(aim, &QAbstractItemModel::dataChanged, this, &QQmlTableInstanceModel::dataChangedCallback);
connect(aim, &QAbstractItemModel::modelAboutToBeReset, this, &QQmlTableInstanceModel::modelAboutToBeResetCallback);
}
}
void QQmlTableInstanceModel::setModel(const QVariant &model)
{
if (m_adaptorModel.model() == model)
return;
forceSetModel(model);
emit modelChanged();
}
void QQmlTableInstanceModel::dataChangedCallback(const QModelIndex &begin, const QModelIndex &end, const QList<int> &roles)
{
// This function is called when model data has changed. We iterate over the affected cells,
// find the delegate item (if any) currently showing each cell via its persistent model index,
// and notify the adaptor model so it can update role-based QML bindings in that item.
// NOTE: A model may sometimes emit layoutChanged first (e.g. after sorting), and then
// emit dataChanged for some of the affected items (e.g. because a data change triggered
// the sort in the first place). This causes a problem here, because TableView hasn't
// processed the layout change yet (it will do so on the next updatePolish()), so the
// items in this QQmlTableInstanceModel are index-wise out-of-sync with QAbstractItemModel.
// When we detect this, we temporarily correct an item's flat index before notifying, so
// that the right QModelIndex is read from QAbstractItemModel. Afterwards we restore the
// old flat index to stay in sync with what TableView expects. When TableView later
// rebuilds in response to the layout change, all flat indices will be corrected.
for (int row = begin.row(); row <= end.row(); ++row) {
for (int column = begin.column(); column <= end.column(); ++column) {
const QModelIndex modelIndex = abstractItemModel()->index(row, column);
const auto it = std::find_if(m_modelItems.cbegin(), m_modelItems.cend(),
[&modelIndex](const QQmlDelegateModelItem *item) {
return item->persistentModelIndex() == modelIndex;
});
if (it == m_modelItems.cend())
continue;
QQmlDelegateModelItem *modelItem = *it;
const int oldFlatIndex = modelItem->modelIndex();
const int newFlatIndex = row + column * rows();
if (oldFlatIndex != newFlatIndex)
modelItem->setModelIndex(newFlatIndex, row, column, false);
m_adaptorModel.notify({modelItem}, newFlatIndex, 1, roles);
if (oldFlatIndex != newFlatIndex)
modelItem->setModelIndex(oldFlatIndex, row, column, false);
}
}
}
void QQmlTableInstanceModel::modelAboutToBeResetCallback()
{
// When the model is reset, we can no longer rely on any of the data it has
// provided us so far. Normally it's enough for the view to recreate all the
// delegate items in that case, except if the model roles has changed as well
// (since those are cached by QQmlAdaptorModel / Accessors). For the latter case, we
// simply set the model once more in the delegate model to rebuild everything.
auto const aim = abstractItemModel();
auto oldRoleNames = aim->roleNames();
QObject::connect(aim, &QAbstractItemModel::modelReset, this, [this, aim, oldRoleNames](){
if (oldRoleNames != aim->roleNames()) {
// We refresh the model, but without sending any signals. The actual model object
// stays the same after all.
forceSetModel(model());
}
}, Qt::SingleShotConnection);
}
QQmlComponent *QQmlTableInstanceModel::delegate() const
{
return m_delegate;
}
void QQmlTableInstanceModel::setDelegate(QQmlComponent *delegate)
{
if (m_delegate == delegate)
return;
m_delegateChooser = nullptr;
if (delegate) {
QQmlAbstractDelegateComponent *adc =
qobject_cast<QQmlAbstractDelegateComponent *>(delegate);
if (adc)
m_delegateChooser = adc;
}
m_delegate = delegate;
}
const QAbstractItemModel *QQmlTableInstanceModel::abstractItemModel() const
{
return m_adaptorModel.adaptsAim() ? m_adaptorModel.aim() : nullptr;
}
// --------------------------------------------------------
void QQmlTableInstanceModelIncubationTask::setInitialState(QObject *object)
{
initializeRequiredProperties(
modelItemToIncubate, object, tableInstanceModel->delegateModelAccess());
modelItemToIncubate->setObject(object);
const bool init = true;
const int flatIndex = modelItemToIncubate->modelIndex();
emit tableInstanceModel->initItem(flatIndex, object);
emit tableInstanceModel->updateItemProperties(flatIndex, object, init);
if (!QQmlIncubatorPrivate::get(this)->requiredProperties()->empty())
modelItemToIncubate->destroyObjectLater();
}
void QQmlTableInstanceModelIncubationTask::statusChanged(QQmlIncubator::Status status)
{
if (!QQmlTableInstanceModel::isDoneIncubating(modelItemToIncubate))
return;
// We require the view to cancel any ongoing load
// requests before the tableInstanceModel is destructed.
Q_ASSERT(tableInstanceModel);
tableInstanceModel->incubatorStatusChanged(this, status);
}
QT_END_NAMESPACE
#include "moc_qqmltableinstancemodel_p.cpp"