6#include <QtQml/qqmlinfo.h>
8#include <private/qqmlabstractdelegatecomponent_p.h>
9#include <private/qquickpackage_p.h>
10#include <private/qmetaobjectbuilder_p.h>
11#include <private/qqmladaptormodel_p.h>
12#include <private/qqmlanybinding_p.h>
13#include <private/qqmlchangeset_p.h>
14#include <private/qqmlengine_p.h>
15#include <private/qqmlcomponent_p.h>
16#include <private/qqmlpropertytopropertybinding_p.h>
17#include <private/qjsvalue_p.h>
19#include <private/qv4value_p.h>
20#include <private/qv4functionobject_p.h>
21#include <private/qv4objectiterator_p.h>
41 void init() { Object::init(); }
47 void init(
const QVector<QQmlChangeSet::Change> &changes);
79 return f->d()->code(
o->d()->item,
f->d()->flag,
v);
83void Heap::DelegateModelGroupFunction::init(
105 const QVector<QQmlChangeSet::Change> &changes);
115 prop.setWritable(
false);
169 , m_delegateValidated(
false)
171 , m_transaction(
false)
172 , m_incubatorCleanupScheduled(
false)
173 , m_waitingToFetchMore(
false)
234 d->disconnectFromAbstractItemModel();
235 d->m_adaptorModel.setObject(
nullptr);
238 if (cacheItem->object) {
239 delete cacheItem->object;
241 cacheItem->object =
nullptr;
242 cacheItem->contextData.reset();
243 cacheItem->scriptRef -= 1;
244 }
else if (cacheItem->incubationTask) {
247 cacheItem->scriptRef -= 1;
250 cacheItem->groups &= ~Compositor::UnresolvedFlag;
251 cacheItem->objectRef = 0;
253 if (cacheItem->incubationTask) {
254 d->releaseIncubator(cacheItem->incubationTask);
255 cacheItem->incubationTask->vdm =
nullptr;
256 cacheItem->incubationTask =
nullptr;
259 if (!cacheItem->isReferenced())
275 d->m_complete =
true;
277 int defaultGroups = 0;
282 defaultGroups |= Compositor::DefaultFlag;
284 defaultGroups |= Compositor::PersistedFlag;
285 for (
int i = Compositor::MinimumGroupCount;
i <
d->m_groupCount; ++
i) {
287 if (
name.isEmpty()) {
288 d->m_groups[
i] =
d->m_groups[
d->m_groupCount - 1];
291 }
else if (
name.at(0).isUpper()) {
292 qmlWarning(
d->m_groups[
i]) << QQmlDelegateModelGroup::tr(
"Group names must start with a lower case letter");
293 d->m_groups[
i] =
d->m_groups[
d->m_groupCount - 1];
297 groupNames.append(
name);
300 group->setModel(
this, Compositor::Group(
i));
301 if (
group->defaultInclude)
302 defaultGroups |= (1 <<
i);
307 d->m_context->engine()->handle(),
this, groupNames);
309 d->m_compositor.setGroupCount(
d->m_groupCount);
310 d->m_compositor.setDefaultGroups(defaultGroups);
311 d->updateFilterGroup();
313 while (!
d->m_pendingParts.isEmpty())
314 static_cast<QQmlPartsModel *
>(
d->m_pendingParts.first())->updateFilterGroup();
316 QVector<Compositor::Insert> inserts;
317 d->m_count =
d->adaptorModelCount();
318 d->m_compositor.append(
322 defaultGroups | Compositor::AppendFlag | Compositor::PrependFlag,
324 d->itemsInserted(inserts);
326 d->requestMoreIfNecessary();
347 return d->m_adaptorModel.model();
395 _q_itemsRemoved(0,
d->m_count);
397 d->disconnectFromAbstractItemModel();
398 d->m_adaptorModel.setModel(
model);
399 d->connectToAbstractItemModel();
401 d->m_adaptorModel.replaceWatchedRoles(QList<QByteArray>(),
d->m_watchedRoles);
402 for (
int i = 0;
d->m_parts &&
i <
d->m_parts->models.size(); ++
i) {
403 d->m_adaptorModel.replaceWatchedRoles(
404 QList<QByteArray>(),
d->m_parts->models.at(
i)->watchedRoles());
408 _q_itemsInserted(0,
d->adaptorModelCount());
409 d->requestMoreIfNecessary();
423 return d->m_delegate;
429 if (
d->m_transaction) {
430 qmlWarning(
this) <<
tr(
"The delegate of a DelegateModel cannot be changed within onUpdated.");
436 _q_itemsRemoved(0,
d->m_count);
438 d->m_delegateValidated =
false;
439 if (
d->m_delegateChooser)
442 d->m_delegateChooser =
nullptr;
445 qobject_cast<QQmlAbstractDelegateComponent *>(
delegate);
447 d->m_delegateChooser = adc;
449 [
d](){
d->delegateChanged(); });
453 _q_itemsInserted(0,
d->adaptorModelCount());
454 d->requestMoreIfNecessary();
498 const bool changed =
d->m_adaptorModel.rootIndex !=
modelIndex;
499 if (changed || !
d->m_adaptorModel.isValid()) {
500 const int oldCount =
d->m_count;
502 if (!
d->m_adaptorModel.isValid() &&
d->m_adaptorModel.aim()) {
504 d->disconnectFromAbstractItemModel();
505 d->m_adaptorModel.setModel(
d->m_adaptorModel.list.list());
506 d->connectToAbstractItemModel();
508 if (
d->m_adaptorModel.canFetchMore())
509 d->m_adaptorModel.fetchMore();
511 const int newCount =
d->adaptorModelCount();
513 _q_itemsRemoved(0, oldCount);
515 _q_itemsInserted(0, newCount);
537 return d->m_adaptorModel.modelIndex(idx);
555 return d->m_adaptorModel.parentModelIndex();
567 return d->m_compositor.count(
d->m_compositorGroup);
573 return QQmlDelegateModel::ReleaseFlags{};
577 return QQmlDelegateModel::ReleaseFlags{};
579 if (!cacheItem->releaseObject())
585 emit q_func()->itemPooled(cacheItem->index, cacheItem->object);
596 cacheItem->destroyObject();
597 if (cacheItem->incubationTask) {
599 cacheItem->incubationTask =
nullptr;
601 cacheItem->Dispose();
610 QQmlInstanceModel::ReleaseFlags stat =
d->release(
item, reusableFlag);
618 if (index < 0 || index >=
d->m_compositor.count(
d->m_compositorGroup)) {
619 qWarning() <<
"DelegateModel::cancel: index out range" <<
index <<
d->m_compositor.count(
d->m_compositorGroup);
623 Compositor::iterator
it =
d->m_compositor.find(
d->m_compositorGroup,
index);
626 if (cacheItem->incubationTask && !cacheItem->isObjectReferenced()) {
627 d->releaseIncubator(cacheItem->incubationTask);
628 cacheItem->incubationTask =
nullptr;
630 if (cacheItem->object) {
631 QObject *
object = cacheItem->object;
632 cacheItem->destroyObject();
633 if (
QQuickPackage *package = qmlobject_cast<QQuickPackage *>(
object))
634 d->emitDestroyingPackage(package);
636 d->emitDestroyingItem(
object);
639 cacheItem->scriptRef -= 1;
641 if (!cacheItem->isReferenced()) {
642 d->m_compositor.clearFlags(
643 Compositor::Cache,
it.cacheIndex(), 1, Compositor::CacheFlag);
644 d->m_cache.removeAt(
it.cacheIndex());
646 Q_ASSERT(
d->m_cache.size() ==
d->m_compositor.count(Compositor::Cache));
657 if (
d->m_groupCount == Compositor::MaximumGroupCount) {
658 qmlWarning(
d->q_func()) << QQmlDelegateModel::tr(
"The maximum number of supported DelegateModelGroups is 8");
661 d->m_groups[
d->m_groupCount] =
group;
662 d->m_groupCount += 1;
666 QQmlListProperty<QQmlDelegateModelGroup> *
property)
712 return QQmlListProperty<QQmlDelegateModelGroup>(
718 nullptr,
nullptr,
nullptr);
753 return d->m_persistedItems;
769 return d->m_filterGroup;
776 if (
d->m_transaction) {
777 qmlWarning(
this) <<
tr(
"The group of a DelegateModel cannot be changed within onChanged");
781 if (
d->m_filterGroup !=
group) {
783 d->updateFilterGroup();
810 QVector<QQmlChangeSet::Change> removes;
811 QVector<QQmlChangeSet::Change> inserts;
815 changeSet.
move(removes, inserts);
816 emit q->modelUpdated(changeSet,
false);
819 emit q->countChanged();
868 return d->m_adaptorModel.adaptsAim() ?
d->m_adaptorModel.aim() :
nullptr;
899 if (
auto contextData =
d ?
d->context :
nullptr)
900 contextData->setExtraObject(modelItemToIncubate);
906 if (incubatorPriv->hadTopLevelRequiredProperties()) {
921 const QMetaObject *qmlMetaObject = modelItemToIncubate->metaObject();
923 if (incubatorPriv->requiredProperties()->empty())
932 QVarLengthArray<QPair<const QMetaObject *, QObject *>, 4> mos;
935 mos.push_back(
qMakePair(qmlMetaObject, modelItemToIncubate));
936 auto delegateModelItemSubclassMO = qmlMetaObject->superClass();
937 mos.push_back(
qMakePair(delegateModelItemSubclassMO, modelItemToIncubate));
939 while (strcmp(delegateModelItemSubclassMO->className(),
940 modelItemToIncubate->staticMetaObject.className())) {
941 delegateModelItemSubclassMO = delegateModelItemSubclassMO->superClass();
942 mos.push_back(
qMakePair(delegateModelItemSubclassMO, modelItemToIncubate));
951 for (
const auto &metaObjectAndObject : mos) {
953 QObject *itemOrProxy = metaObjectAndObject.second;
956 for (
int i =
mo->propertyOffset();
i <
mo->propertyCount() +
mo->propertyOffset(); ++
i) {
957 auto prop =
mo->property(
i);
961 bool wasInRequired =
false;
963 object, propName, requiredProperties,
968 engine, itemOrProxy,
i, targetProp.object(), targetProp.index());
984 modelItemToIncubate->metaObject();
1006 if (!incubationTask->
isError())
1007 incubationTask->
clear();
1020 item->groups = newGroups;
1026 const bool alwaysEmit =
true;
1027 item->setModelIndex(newModelIndex, newModelIndex, 0, alwaysEmit);
1031 auto const itemAsList = QList<QQmlDelegateModelItem *>() <<
item;
1032 auto const updateAllRoles = QVector<int>();
1036 qmlAttachedPropertiesObject<QQmlDelegateModel>(
item->object,
false))) {
1039 att->resetCurrentIndex();
1046 emit q_func()->itemReused(newModelIndex,
item->object);
1056 d_func()->drainReusableItemsPool(maxPoolTime);
1061 return d_func()->m_reusableItemsPool.size();
1074 chooser = qobject_cast<QQmlAbstractDelegateComponent *>(delegate);
1102 const QList<QQmlError> incubationTaskErrors = incubationTask->
errors();
1110 cacheItem->referenceObject();
1111 if (
QQuickPackage *package = qmlobject_cast<QQuickPackage *>(cacheItem->object))
1115 cacheItem->releaseObject();
1120 if (!cacheItem->isObjectReferenced()) {
1121 if (
QQuickPackage *package = qmlobject_cast<QQuickPackage *>(cacheItem->object))
1125 delete cacheItem->object;
1126 cacheItem->object =
nullptr;
1127 cacheItem->scriptRef -= 1;
1128 cacheItem->contextData.reset();
1130 if (!cacheItem->isReferenced()) {
1146 cacheItem->object =
o;
1148 if (
QQuickPackage *package = qmlobject_cast<QQuickPackage *>(cacheItem->object))
1157 = qobject_cast<QQmlAdaptorModelProxyInterface *>(cacheItem);
1159 return cacheItem->contextData;
1163 cacheItem->incubationTask->proxiedObject = proxied;
1164 cacheItem->incubationTask->proxyContext = ctxt;
1165 ctxt->setContextObject(cacheItem);
1183 const auto modelIndex =
it.modelIndex();
1187 if (!cacheItem || !cacheItem->delegate) {
1200 cacheItem->referenceObject();
1204 return cacheItem->object;
1216 cacheItem->delegate = delegate;
1221 cacheItem->scriptRef += 1;
1222 cacheItem->referenceObject();
1224 if (cacheItem->incubationTask) {
1228 cacheItem->incubationTask->forceCompletion();
1230 }
else if (!cacheItem->object) {
1231 QQmlContext *creationContext = cacheItem->delegate->creationContext();
1233 cacheItem->scriptRef += 1;
1236 cacheItem->incubationTask->incubating = cacheItem;
1237 cacheItem->incubationTask->clear();
1240 cacheItem->incubationTask->index[
i] =
it.index[
i];
1242 const QQmlRefPointer<QQmlContextData> componentContext
1246 if (cp->isBound()) {
1247 cacheItem->contextData = componentContext;
1255 cacheItem->incubationTask,
1256 cacheItem->delegate,
1261 QQmlRefPointer<QQmlContextData> ctxt
1263 ctxt->setContextObject(cacheItem);
1264 cacheItem->contextData = ctxt;
1270 cacheItem->incubationTask,
1271 cacheItem->delegate,
1282 cacheItem->scriptRef -= 1;
1283 if (cacheItem->object && (!cacheItem->incubationTask ||
isDoneIncubating(cacheItem->incubationTask->status())))
1284 return cacheItem->object;
1286 if (cacheItem->objectRef > 0)
1287 cacheItem->releaseObject();
1289 if (!cacheItem->isReferenced()) {
1308 if (!
d->m_delegate || index < 0 || index >=
d->m_compositor.count(
d->m_compositorGroup)) {
1309 qWarning() <<
"DelegateModel::item: index out range" <<
index <<
d->m_compositor.count(
d->m_compositorGroup);
1313 return d->object(
d->m_compositorGroup,
index, incubationMode);
1319 if (
d->m_compositor.count(
d->m_compositorGroup) <=
index)
1321 Compositor::iterator
it =
d->m_compositor.find(
d->m_compositorGroup,
index);
1325 if (
auto incubationTask =
d->m_cache.at(
it.cacheIndex())->incubationTask)
1326 return incubationTask->status();
1344 const int from =
dot + 1;
1356 return d->variantValue(
d->m_compositorGroup,
index, role);
1363 return cacheItem->groupIndex(
d->m_compositorGroup);
1370 d->m_adaptorModel.replaceWatchedRoles(
d->m_watchedRoles, roles);
1371 d->m_watchedRoles = roles;
1375 Compositor::iterator from,
int count, Compositor::Group
group,
int groupFlags)
1377 QVector<Compositor::Insert> inserts;
1384 Compositor::iterator from,
int count, Compositor::Group
group,
int groupFlags)
1386 QVector<Compositor::Remove> removes;
1393 Compositor::iterator from,
int count, Compositor::Group
group,
int groupFlags)
1395 QVector<Compositor::Remove> removes;
1396 QVector<Compositor::Insert> inserts;
1400 const int removeFlags = ~groupFlags & Compositor::GroupMask;
1412 d->m_waitingToFetchMore =
false;
1413 d->m_adaptorModel.fetchMore();
1415 d->m_incubatorCleanupScheduled =
false;
1417 d->m_finishedIncubating.clear();
1427 QVarLengthArray<QVector<QQmlChangeSet::Change>, Compositor::MaximumGroupCount> translatedChanges(
m_groupCount);
1429 for (
const Compositor::Change &change : changes) {
1431 if (change.inGroup(
i)) {
1441void QQmlDelegateModel::_q_itemsChanged(
int index,
int count,
const QVector<int> &roles)
1444 if (count <= 0 || !d->m_complete)
1447 if (
d->m_adaptorModel.notify(
d->m_cache,
index,
count, roles)) {
1448 QVector<Compositor::Change> changes;
1449 d->m_compositor.listItemsChanged(&
d->m_adaptorModel,
index,
count, &changes);
1450 d->itemsChanged(changes);
1453 const bool needToCheckDelegateChoiceInvalidation =
d->m_delegateChooser && !roles.isEmpty();
1454 if (!needToCheckDelegateChoiceInvalidation)
1459 if (!
d->m_adaptorModel.adaptsAim())
1462 const auto aim =
d->m_adaptorModel.aim();
1463 const auto choiceRole =
d->m_delegateChooser->role().toUtf8();
1464 const auto &roleNames = aim->roleNames();
1465 auto it = std::find_if(roles.begin(), roles.end(), [&](
int role) {
1466 return roleNames[role] == choiceRole;
1468 if (
it == roles.end())
1477 QVector<Compositor::Remove> removes;
1478 QVector<Compositor::Insert> inserts;
1479 d->m_compositor.listItemsRemoved(&
d->m_adaptorModel,
index,
count, &removes);
1480 const QList<QQmlDelegateModelItem *>
cache =
d->m_cache;
1482 item->referenceObject();
1483 for (
const auto& removed: removes) {
1484 if (!
d->m_cache.isSharedWith(
cache))
1487 if (!
d->m_cache.contains(
item))
1489 if (
item->modelIndex() != -1)
1490 item->setModelIndex(-1, -1, -1);
1493 item->releaseObject();
1494 d->m_compositor.listItemsInserted(&
d->m_adaptorModel,
index,
count, &inserts);
1495 d->itemsMoved(removes, inserts);
1503 incubationTask->index[
i] += deltas[
i];
1506 for (
int i = 1; i < qMin<int>(
count, Compositor::MaximumGroupCount); ++
i)
1507 attached->m_currentIndex[
i] += deltas[
i];
1512 const QVector<Compositor::Insert> &inserts,
1513 QVarLengthArray<QVector<QQmlChangeSet::Change>, Compositor::MaximumGroupCount> *translatedInserts,
1514 QHash<
int, QList<QQmlDelegateModelItem *> > *movedItems)
1518 int inserted[Compositor::MaximumGroupCount];
1522 for (
const Compositor::Insert &
insert : inserts) {
1523 for (; cacheIndex <
insert.cacheIndex(); ++cacheIndex)
1528 (*translatedInserts)[
i].append(
1537 if (movedItems &&
insert.isMove()) {
1538 QList<QQmlDelegateModelItem *>
items = movedItems->take(
insert.moveId);
1545 ++cacheIndex, ++
offset) {
1547 cacheItem->
groups |=
insert.flags & Compositor::GroupMask;
1551 incubationTask->index[
i] = cacheItem->groups & (1 <<
i)
1557 attached->m_currentIndex[
i] = cacheItem->groups & (1 <<
i)
1566 for (
const QList<QQmlDelegateModelItem *>
cache =
m_cache; cacheIndex <
cache.size(); ++cacheIndex)
1572 QVarLengthArray<QVector<QQmlChangeSet::Change>, Compositor::MaximumGroupCount> translatedInserts(
m_groupCount);
1582void QQmlDelegateModel::_q_itemsInserted(
int index,
int count)
1586 if (count <= 0 || !d->m_complete)
1591 const QList<QQmlDelegateModelItem *>
cache =
d->m_cache;
1592 for (
int i = 0,
c =
cache.size();
i <
c; ++
i) {
1596 if (!
d->m_cache.isSharedWith(
cache) && !
d->m_cache.contains(
item))
1600 const int newIndex =
item->modelIndex() +
count;
1601 const int row = newIndex;
1607 QVector<Compositor::Insert> inserts;
1608 d->m_compositor.listItemsInserted(&
d->m_adaptorModel,
index,
count, &inserts);
1609 d->itemsInserted(inserts);
1621 const QVector<Compositor::Remove> &removes,
1622 QVarLengthArray<QVector<QQmlChangeSet::Change>, Compositor::MaximumGroupCount> *translatedRemoves,
1623 QHash<
int, QList<QQmlDelegateModelItem *> > *movedItems)
1626 int removedCache = 0;
1628 int removed[Compositor::MaximumGroupCount];
1632 for (
const Compositor::Remove &
remove : removes) {
1633 for (; cacheIndex <
remove.cacheIndex() && cacheIndex <
m_cache.
size(); ++cacheIndex)
1638 (*translatedRemoves)[
i].append(
1647 if (movedItems &&
remove.isMove()) {
1653 for (; cacheIndex <
remove.cacheIndex() +
remove.count - removedCache; ++cacheIndex) {
1655 if (
remove.inGroup(Compositor::Persisted) && cacheItem->objectRef == 0 && cacheItem->object) {
1656 QObject *
object = cacheItem->object;
1657 cacheItem->destroyObject();
1658 if (
QQuickPackage *package = qmlobject_cast<QQuickPackage *>(
object))
1662 cacheItem->scriptRef -= 1;
1664 if (!cacheItem->isReferenced() && !
remove.inGroup(Compositor::Persisted)) {
1671 }
else if (
remove.groups() == cacheItem->groups) {
1672 cacheItem->groups = 0;
1675 incubationTask->index[
i] = -1;
1679 attached->m_currentIndex[
i] = -1;
1683 if (!cacheItem->isObjectReferenced()) {
1685 cacheItem->incubationTask =
nullptr;
1686 if (cacheItem->object) {
1687 QObject *
object = cacheItem->object;
1688 cacheItem->destroyObject();
1689 if (
QQuickPackage *package = qmlobject_cast<QQuickPackage *>(
object))
1694 cacheItem->scriptRef -= 1;
1698 incubationTask->index[
i] =
remove.index[
i];
1705 attached->m_currentIndex[
i] =
remove.index[
i];
1708 cacheItem->groups &= ~remove.flags;
1714 for (
const QList<QQmlDelegateModelItem *>
cache =
m_cache; cacheIndex <
cache.size(); ++cacheIndex)
1720 QVarLengthArray<QVector<QQmlChangeSet::Change>, Compositor::MaximumGroupCount> translatedRemoves(
m_groupCount);
1730void QQmlDelegateModel::_q_itemsRemoved(
int index,
int count)
1733 if (count <= 0|| !d->m_complete)
1738 const QList<QQmlDelegateModelItem *>
cache =
d->m_cache;
1741 item->referenceObject();
1743 for (
int i = 0,
c =
cache.size();
i <
c; ++
i) {
1747 if (!
d->m_cache.isSharedWith(
cache) && !
d->m_cache.contains(
item))
1751 const int newIndex =
item->modelIndex() -
count;
1752 const int row = newIndex;
1755 }
else if (
item->modelIndex() >=
index) {
1756 item->setModelIndex(-1, -1, -1);
1761 item->releaseObject();
1763 QVector<Compositor::Remove> removes;
1764 d->m_compositor.listItemsRemoved(&
d->m_adaptorModel,
index,
count, &removes);
1765 d->itemsRemoved(removes);
1771 const QVector<Compositor::Remove> &removes,
const QVector<Compositor::Insert> &inserts)
1773 QHash<int, QList<QQmlDelegateModelItem *> > movedItems;
1775 QVarLengthArray<QVector<QQmlChangeSet::Change>, Compositor::MaximumGroupCount> translatedRemoves(
m_groupCount);
1776 itemsRemoved(removes, &translatedRemoves, &movedItems);
1778 QVarLengthArray<QVector<QQmlChangeSet::Change>, Compositor::MaximumGroupCount> translatedInserts(
m_groupCount);
1787 translatedRemoves.at(
i),
1788 translatedInserts.at(
i));
1792void QQmlDelegateModel::_q_itemsMoved(
int from,
int to,
int count)
1795 if (count <= 0 || !d->m_complete)
1798 const int minimum =
qMin(from, to);
1799 const int maximum =
qMax(from, to) +
count;
1800 const int difference = from > to ?
count : -
count;
1802 const QList<QQmlDelegateModelItem *>
cache =
d->m_cache;
1803 for (
int i = 0,
c =
cache.size();
i <
c; ++
i) {
1807 if (!
d->m_cache.isSharedWith(
cache) && !
d->m_cache.contains(
item))
1810 if (
item->modelIndex() >= from &&
item->modelIndex() < from +
count) {
1811 const int newIndex =
item->modelIndex() - from + to;
1812 const int row = newIndex;
1816 const int newIndex =
item->modelIndex() + difference;
1817 const int row = newIndex;
1823 QVector<Compositor::Remove> removes;
1824 QVector<Compositor::Insert> inserts;
1825 d->m_compositor.listItemsMoved(&
d->m_adaptorModel, from, to,
count, &removes, &inserts);
1826 d->itemsMoved(removes, inserts);
1835 emit q->countChanged();
1845 qmlWarning(
q) << QQmlDelegateModel::tr(
"The delegates of a DelegateModel cannot be changed within onUpdated.");
1881 QVarLengthArray<QPointer<QQmlDelegateModelAttached>> attachedObjects;
1884 attachedObjects.append(cacheItem->attached);
1886 for (
const QPointer<QQmlDelegateModelAttached> &attached : std::as_const(attachedObjects)) {
1887 if (attached && attached->m_cacheItem)
1888 attached->emitChanges();
1892void QQmlDelegateModel::_q_modelAboutToBeReset()
1900 if (oldRoleNames == aim->roleNames()) {
1914void QQmlDelegateModel::handleModelReset()
1920 int oldCount =
d->m_count;
1923 if (
d->m_complete) {
1924 d->m_count =
d->adaptorModelCount();
1926 const QList<QQmlDelegateModelItem *>
cache =
d->m_cache;
1928 item->referenceObject();
1930 for (
int i = 0,
c =
cache.size();
i <
c; ++
i) {
1934 if (!
d->m_cache.isSharedWith(
cache) && !
d->m_cache.contains(
item))
1937 if (
item->modelIndex() != -1)
1938 item->setModelIndex(-1, -1, -1);
1942 item->releaseObject();
1943 QVector<Compositor::Remove> removes;
1944 QVector<Compositor::Insert> inserts;
1946 d->m_compositor.listItemsRemoved(&
d->m_adaptorModel, 0, oldCount, &removes);
1948 d->m_compositor.listItemsInserted(&
d->m_adaptorModel, 0,
d->m_count, &inserts);
1949 d->itemsMoved(removes, inserts);
1952 if (
d->m_adaptorModel.canFetchMore())
1953 d->m_adaptorModel.fetchMore();
1963 if (
parent ==
d->m_adaptorModel.rootIndex)
1967void QQmlDelegateModel::_q_rowsAboutToBeRemoved(
const QModelIndex &parent,
int begin,
int end)
1970 if (!
d->m_adaptorModel.rootIndex.isValid())
1974 const int oldCount =
d->m_count;
1976 d->disconnectFromAbstractItemModel();
1977 d->m_adaptorModel.invalidateModel();
1979 if (
d->m_complete && oldCount > 0) {
1980 QVector<Compositor::Remove> removes;
1981 d->m_compositor.listItemsRemoved(&
d->m_adaptorModel, 0, oldCount, &removes);
1982 d->itemsRemoved(removes);
1991 if (
parent ==
d->m_adaptorModel.rootIndex)
1995void QQmlDelegateModel::_q_rowsMoved(
1996 const QModelIndex &sourceParent,
int sourceStart,
int sourceEnd,
1997 const QModelIndex &destinationParent,
int destinationRow)
2000 const int count = sourceEnd - sourceStart + 1;
2001 if (destinationParent ==
d->m_adaptorModel.rootIndex && sourceParent ==
d->m_adaptorModel.rootIndex) {
2002 _q_itemsMoved(sourceStart, sourceStart > destinationRow ? destinationRow : destinationRow -
count,
count);
2003 }
else if (sourceParent ==
d->m_adaptorModel.rootIndex) {
2004 _q_itemsRemoved(sourceStart,
count);
2005 }
else if (destinationParent ==
d->m_adaptorModel.rootIndex) {
2006 _q_itemsInserted(destinationRow,
count);
2014 if (
parent ==
d->m_adaptorModel.rootIndex &&
begin == 0) {
2016 _q_itemsChanged(0,
d->m_count, QVector<int>());
2024 if (
parent ==
d->m_adaptorModel.rootIndex &&
begin == 0) {
2026 _q_itemsChanged(0,
d->m_count, QVector<int>());
2035 if ((
parent ==
d->m_adaptorModel.rootIndex &&
start == 0)
2038 _q_itemsChanged(0,
d->m_count, QVector<int>());
2045 if (
begin.parent() ==
d->m_adaptorModel.rootIndex)
2046 _q_itemsChanged(
begin.row(),
end.row() -
begin.row() + 1, roles);
2051 for (
int i = 0,
c = parents.
size();
i <
c; ++
i) {
2068 if (!parents.isEmpty() &&
d->m_adaptorModel.rootIndex.isValid() && !isDescendantOf(
d->m_adaptorModel.rootIndex, parents)) {
2073 _q_itemsChanged(0,
d->m_count, QVector<int>());
2087 return cacheItem->attached;
2101 if (!
object.isObject())
2113 const auto oldCache =
m_cache;
2115 propertyName =
it.nextPropertyNameAsString(
v);
2116 if (propertyName->
isNull())
2118 cacheItem->setValue(
2126 cacheItem->groups =
groups | Compositor::UnresolvedFlag | Compositor::CacheFlag;
2129 itemsInserted(QVector<Compositor::Insert>(1, Compositor::Insert(before, 1, cacheItem->groups & ~Compositor::CacheFlag)));
2142 , groupCount(groupNames.
size() + 1)
2145 , groupNames(groupNames)
2160 builder.
setSuperClass(&QQmlDelegateModelAttached::staticMetaObject);
2165 propertyName.
replace(2, 1, propertyName.
at(2).toUpper());
2168 propertyName.
toUtf8(),
"bool", notifierId);
2175 propertyName.
toUtf8(),
"int", notifierId);
2196 p->setSetter(
nullptr);
2215 p->setSetter(
nullptr);
2220 propertyName.
replace(2, 1, propertyName.
at(2).toUpper());
2230 p->setSetter(
nullptr);
2242 groupFlags |= 2 <<
index;
2254 const QString groupName =
s->toQString();
2257 groupFlags |= 2 <<
index;
2267 const QString groupName =
v->toQString();
2270 groupFlags |= 2 <<
index;
2281 return b->engine()->throwTypeError(
QStringLiteral(
"Not a valid DelegateModel object"));
2282 if (!
o->d()->item->metaType->model)
2285 return o->d()->item->get();
2296 for (
int i = 1;
i <
o->d()->
item->metaType->groupCount; ++
i) {
2297 if (
o->d()->item->groups & (1 <<
i))
2298 groups.append(
o->d()->item->metaType->groupNames.at(
i - 1));
2314 if (!
o->d()->item->metaType->model)
2318 const int groupFlags =
model->m_cacheMetaType->parseGroups(argv[0]);
2319 const int cacheIndex =
model->m_cache.indexOf(
o->d()->item);
2320 Compositor::iterator
it =
model->m_compositor.find(Compositor::Cache, cacheIndex);
2321 model->setGroups(
it, 1, Compositor::Cache, groupFlags);
2327 return QV4::Encode(
bool(thisItem->groups & (1 << flag)));
2332 if (!cacheItem->metaType->model)
2337 bool member =
arg.toBoolean();
2338 uint groupFlag = (1 << flag);
2339 if (member == ((cacheItem->groups & groupFlag) != 0))
2342 const int cacheIndex =
model->m_cache.indexOf(cacheItem);
2343 Compositor::iterator
it =
model->m_compositor.find(Compositor::Cache, cacheIndex);
2345 model->addGroups(
it, 1, Compositor::Cache, groupFlag);
2347 model->removeGroups(
it, 1, Compositor::Cache, groupFlag);
2353 return QV4::Encode((
int)thisItem->groupIndex(Compositor::Group(flag)));
2362 ctxt = ctxt->nextChild()) {
2363 if (ctxt->contextObject() == childContextObject)
2364 ctxt->setContextObject(
nullptr);
2381 const QQmlRefPointer<QQmlDelegateModelItemMetaType> &metaType,
2385 , metaType(metaType)
2433 model->removeCacheItem(
this);
2440 const int prevIndex =
index;
2441 const int prevRow =
row;
2442 const int prevColumn =
column;
2448 if (idx != prevIndex || alwaysEmit)
2450 if (
row != prevRow || alwaysEmit)
2452 if (
column != prevColumn || alwaysEmit)
2453 emit columnChanged();
2463 if (
data->ownContext) {
2464 data->ownContext->clearContext();
2465 if (
data->ownContext->contextObject() ==
object)
2466 data->ownContext->setContextObject(
nullptr);
2467 data->ownContext =
nullptr;
2468 data->context =
nullptr;
2477 if (
object->parent() ==
nullptr)
2479 object->deleteLater();
2496 QQmlRefPointer<QQmlContextData>
context =
d->context;
2501 return qobject_cast<QQmlDelegateModelItem *>(extraObject);
2505 return qobject_cast<QQmlDelegateModelItem *>(extraObject);
2528 : metaType(metaType)
2553 if (_id >= indexPropertyOffset) {
2554 Compositor::Group
group = Compositor::Group(_id - indexPropertyOffset + 1);
2557 }
else if (_id >= memberPropertyOffset) {
2558 Compositor::Group
group = Compositor::Group(_id - memberPropertyOffset + 1);
2563 if (_id >= memberPropertyOffset) {
2564 if (!metaType->
model)
2567 Compositor::Group
group = Compositor::Group(_id - memberPropertyOffset + 1);
2568 const int groupFlag = 1 <<
group;
2570 if (member && !*
static_cast<bool *
>(
arguments[0])) {
2571 Compositor::iterator
it =
model->m_compositor.find(
2574 }
else if (!member && *
static_cast<bool *
>(
arguments[0])) {
2577 Compositor::iterator
it =
model->m_compositor.find(
2579 model->addGroups(
it, 1, Compositor::Group(
i), groupFlag);
2587 return attached->qt_metacall(call, _id,
arguments);
2592 , m_previousGroups(0)
2599 : m_cacheItem(cacheItem)
2600 , m_previousGroups(cacheItem->
groups)
2607 if (!cacheItem->metaType->metaObject)
2608 cacheItem->metaType->initializeMetaObject();
2611 cacheItem->metaType->metaObject->addref();
2621 Compositor::iterator
it =
model->m_compositor.find(
2658 Compositor::iterator
it =
model->m_compositor.find(Compositor::Cache, cacheIndex);
2660 model->addGroups(
it, 1, Compositor::Cache, groupFlag);
2662 model->removeGroups(
it, 1, Compositor::Cache, groupFlag);
2727 const int groupFlags =
model->m_cacheMetaType->parseGroups(
groups);
2729 Compositor::iterator
it =
model->m_compositor.find(Compositor::Cache, cacheIndex);
2730 model->setGroups(
it, 1, Compositor::Cache, groupFlags);
2798 int indexChanges = 0;
2800 for (
int i = 1;
i < groupCount; ++
i) {
2803 indexChanges |= (1 <<
i);
2812 for (
int i = 1;
i < groupCount; ++
i, ++notifierId) {
2813 if (groupChanges & (1 <<
i))
2816 for (
int i = 1;
i < groupCount; ++
i, ++notifierId) {
2817 if (indexChanges & (1 <<
i))
2850 emit q->countChanged();
2865 it->createdPackage(
index, package);
2871 it->initPackage(
index, package);
2877 it->destroyingPackage(package);
2953 if (
d->name !=
name) {
2982 return d->defaultInclude;
2988 if (
d->defaultInclude != include) {
2989 d->defaultInclude = include;
3032 if (!
model->m_context || !
model->m_context->isValid()) {
3034 }
else if (index < 0 || index >=
model->m_compositor.
count(
d->group)) {
3039 Compositor::iterator
it =
model->m_compositor.find(
d->group,
index);
3041 ?
model->m_cache.at(
it.cacheIndex())
3045 cacheItem =
model->m_adaptorModel.createItem(
3046 model->m_cacheMetaType,
it.modelIndex());
3049 cacheItem->groups =
it->flags;
3051 model->m_cache.insert(
it.cacheIndex(), cacheItem);
3052 model->m_compositor.setFlags(
it, 1, Compositor::CacheFlag);
3055 if (
model->m_cacheMetaType->modelItemProto.isUndefined())
3056 model->m_cacheMetaType->initializePrototype();
3059 ++cacheItem->scriptRef;
3062 o->setPrototypeOf(
p);
3069 if (
value.isNumber()) {
3074 if (!
value.isObject())
3087 *
group = Compositor::Cache;
3117 Compositor::Group
group =
d->group;
3139 if (++i < args->
length()) {
3149 :
model->m_compositor.end();
3153 model->emitChanges();
3186 Compositor::Group
group =
d->group;
3194 if (i < args->
length() &&
index >= 0 && index <= model->m_compositor.count(
group)) {
3198 if (++i < args->
length()) {
3207 :
model->m_compositor.end();
3225 QVector<Compositor::Insert> inserts;
3227 model->m_compositor.setFlags(
it, 1,
d->group, Compositor::PersistedFlag, &inserts);
3228 model->itemsInserted(inserts);
3229 model->m_cache.at(
it.cacheIndex())->releaseObject();
3233 model->emitChanges();
3265 Compositor::Group fromGroup =
d->group;
3266 Compositor::Group toGroup =
d->group;
3270 if (
d->parseIndex(
v, &from, &fromGroup)) {
3271 if (from < 0 || from >=
model->m_compositor.
count(fromGroup)) {
3272 qmlWarning(
this) <<
tr(
"resolve: from index out of range");
3281 if (
d->parseIndex(
v, &to, &toGroup)) {
3282 if (to < 0 || to >=
model->m_compositor.
count(toGroup)) {
3283 qmlWarning(
this) <<
tr(
"resolve: to index out of range");
3291 Compositor::iterator fromIt =
model->m_compositor.find(fromGroup, from);
3292 Compositor::iterator toIt =
model->m_compositor.find(toGroup, to);
3294 if (!fromIt->isUnresolved()) {
3295 qmlWarning(
this) <<
tr(
"resolve: from is not an unresolved item");
3299 qmlWarning(
this) <<
tr(
"resolve: to is not a model item");
3303 const int unresolvedFlags = fromIt->flags;
3304 const int resolvedFlags = toIt->flags;
3305 const int resolvedIndex = toIt.modelIndex();
3306 void *
const resolvedList = toIt->list;
3309 cacheItem->groups &= ~Compositor::UnresolvedFlag;
3311 if (toIt.cacheIndex() > fromIt.cacheIndex())
3312 toIt.decrementIndexes(1, unresolvedFlags);
3313 if (!toIt->inGroup(fromGroup) || toIt.index[fromGroup] > from)
3317 QVector<Compositor::Remove>(1, Compositor::Remove(fromIt, 1, unresolvedFlags, 0)),
3318 QVector<Compositor::Insert>(1, Compositor::Insert(toIt, 1, unresolvedFlags, 0)));
3319 model->itemsInserted(
3320 QVector<Compositor::Insert>(1, Compositor::Insert(toIt, 1, (resolvedFlags & ~unresolvedFlags) | Compositor::CacheFlag)));
3321 toIt.incrementIndexes(1, resolvedFlags | unresolvedFlags);
3322 model->itemsRemoved(QVector<Compositor::Remove>(1, Compositor::Remove(toIt, 1, resolvedFlags)));
3324 model->m_compositor.setFlags(toGroup, to, 1, unresolvedFlags & ~Compositor::UnresolvedFlag);
3325 model->m_compositor.clearFlags(fromGroup, from, 1, unresolvedFlags);
3327 if (resolvedFlags & Compositor::CacheFlag)
3328 model->m_compositor.insert(
3329 Compositor::Cache, toIt.cacheIndex(), resolvedList,
3330 resolvedIndex, 1, Compositor::CacheFlag);
3334 if (!cacheItem->isReferenced()) {
3335 Q_ASSERT(toIt.cacheIndex() ==
model->m_cache.indexOf(cacheItem));
3336 model->m_cache.removeAt(toIt.cacheIndex());
3337 model->m_compositor.clearFlags(
3338 Compositor::Cache, toIt.cacheIndex(), 1, Compositor::CacheFlag);
3342 cacheItem->resolveIndex(
model->m_adaptorModel, resolvedIndex);
3343 if (cacheItem->attached)
3344 cacheItem->attached->emitUnresolvedChanged();
3347 model->emitChanges();
3361 Compositor::Group
group =
d->group;
3376 if (++i < args->
length()) {
3385 }
else if (
count != 0) {
3387 if (count < 0 || count >
model->m_compositor.
count(
d->group) -
it.index[
d->group]) {
3411 if (
v->isNumber()) {
3433 Compositor::Group
group =
d->group;
3443 qmlWarning(
this) <<
tr(
"addGroups: index out of range");
3444 }
else if (
count != 0) {
3446 if (count < 0 || count >
model->m_compositor.
count(
d->group) -
it.index[
d->group]) {
3463 Compositor::Group
group =
d->group;
3473 qmlWarning(
this) <<
tr(
"removeGroups: index out of range");
3474 }
else if (
count != 0) {
3476 if (count < 0 || count >
model->m_compositor.
count(
d->group) -
it.index[
d->group]) {
3494 Compositor::Group
group =
d->group;
3504 qmlWarning(
this) <<
tr(
"setGroups: index out of range");
3505 }
else if (
count != 0) {
3507 if (count < 0 || count >
model->m_compositor.
count(
d->group) -
it.index[
d->group]) {
3533 Compositor::Group fromGroup =
d->group;
3534 Compositor::Group toGroup =
d->group;
3541 if (!
d->parseIndex(
v, &from, &fromGroup)) {
3547 if (!
d->parseIndex(
v, &to, &toGroup)) {
3562 }
else if (from < 0 || from + count >
model->m_compositor.
count(fromGroup)) {
3563 qmlWarning(
this) <<
tr(
"move: from index out of range");
3564 }
else if (!
model->m_compositor.verifyMoveTo(fromGroup, from, toGroup, to,
count,
d->group)) {
3566 }
else if (
count > 0) {
3567 QVector<Compositor::Remove> removes;
3568 QVector<Compositor::Insert> inserts;
3570 model->m_compositor.move(fromGroup, from, toGroup, to,
count,
d->group, &removes, &inserts);
3571 model->itemsMoved(removes, inserts);
3572 model->emitChanges();
3596 , m_inheritGroup(true)
3599 if (
d->m_cacheMetaType) {
3601 m_compositorGroup = Compositor::Default;
3603 d->m_pendingParts.insert(
this);
3615 return m_filterGroup;
3621 qmlWarning(
this) <<
tr(
"The group of a DelegateModel cannot be changed within onChanged");
3625 if (m_filterGroup !=
group || m_inheritGroup) {
3626 m_filterGroup =
group;
3627 m_inheritGroup =
false;
3636 if (!m_inheritGroup) {
3637 m_inheritGroup =
true;
3646 if (!
model->m_cacheMetaType)
3649 if (m_inheritGroup) {
3650 if (m_filterGroup ==
model->m_filterGroup)
3652 m_filterGroup =
model->m_filterGroup;
3656 m_compositorGroup = Compositor::Default;
3658 for (
int i = 1;
i <
model->m_groupCount; ++
i) {
3659 if (m_filterGroup ==
model->m_cacheMetaType->groupNames.at(
i - 1)) {
3660 m_compositorGroup = Compositor::Group(
i);
3666 if (m_compositorGroup != previousGroup) {
3667 QVector<QQmlChangeSet::Change> removes;
3668 QVector<QQmlChangeSet::Change> inserts;
3669 model->m_compositor.transition(previousGroup, m_compositorGroup, &removes, &inserts);
3672 changeSet.
move(removes, inserts);
3684 if (!m_inheritGroup)
3687 m_compositorGroup =
group;
3702 return model->m_delegate
3703 ?
model->m_compositor.
count(m_compositorGroup)
3716 if (!
model->m_delegate || index < 0 || index >=
model->m_compositor.
count(m_compositorGroup)) {
3717 qWarning() <<
"DelegateModel::item: index out range" <<
index <<
model->m_compositor.
count(m_compositorGroup);
3723 if (
QQuickPackage *package = qmlobject_cast<QQuickPackage *>(
object)) {
3724 QObject *part = package->part(m_part);
3727 m_packaged.
insert(part, package);
3731 model->release(
object);
3732 if (!
model->m_delegateValidated) {
3734 qmlWarning(
model->m_delegate) <<
tr(
"Delegate component must be Package type.");
3735 model->m_delegateValidated =
true;
3743 QQmlInstanceModel::ReleaseFlags
flags;
3746 if (
it != m_packaged.
end()) {
3750 m_packaged.erase(
it);
3751 if (!m_packaged.contains(
item))
3752 flags &= ~Referenced;
3753 if (
flags & Destroyed)
3767 model->m_adaptorModel.replaceWatchedRoles(m_watchedRoles, roles);
3768 m_watchedRoles = roles;
3774 Compositor::iterator
it =
model->m_compositor.find(
model->m_compositorGroup,
index);
3778 if (
auto incubationTask =
model->m_cache.at(
it.cacheIndex())->incubationTask)
3779 return incubationTask->status();
3787 if (
it != m_packaged.
end()) {
3789 return cacheItem->groupIndex(m_compositorGroup);
3801 if (m_modelUpdatePending)
3802 m_pendingPackageInitializations <<
index;
3816 m_modelUpdatePending =
false;
3822 QVector<int> pendingPackageInitializations;
3823 qSwap(pendingPackageInitializations, m_pendingPackageInitializations);
3824 for (
int index : pendingPackageInitializations) {
3825 if (!
model->m_delegate || index < 0 || index >=
model->m_compositor.
count(m_compositorGroup))
3828 if (
QQuickPackage *package = qmlobject_cast<QQuickPackage *>(
object))
3830 model->release(
object);
3878 Q_ASSERT(!modelItem->incubationTask);
3879 Q_ASSERT(!modelItem->isObjectReferenced());
3883 modelItem->poolTime = 0;
3884 m_reusableItemsPool.append(modelItem);
3886 qCDebug(lcItemViewDelegateRecycling)
3887 <<
"item:" << modelItem
3888 <<
"delegate:" << modelItem->delegate
3889 <<
"index:" << modelItem->modelIndex()
3890 <<
"row:" << modelItem->modelRow()
3891 <<
"column:" << modelItem->modelColumn()
3892 <<
"pool size:" << m_reusableItemsPool.size();
3899 for (
auto it = m_reusableItemsPool.
begin();
it != m_reusableItemsPool.
end(); ++
it) {
3900 if ((*it)->delegate != delegate)
3902 auto modelItem = *
it;
3903 m_reusableItemsPool.
erase(
it);
3905 qCDebug(lcItemViewDelegateRecycling)
3906 <<
"item:" << modelItem
3907 <<
"delegate:" << delegate
3908 <<
"old index:" << modelItem->modelIndex()
3909 <<
"old row:" << modelItem->modelRow()
3910 <<
"old column:" << modelItem->modelColumn()
3911 <<
"new index:" << newIndexHint
3912 <<
"pool size:" << m_reusableItemsPool.size();
3917 qCDebug(lcItemViewDelegateRecycling)
3918 <<
"no available item for delegate:" << delegate
3919 <<
"new index:" << newIndexHint
3920 <<
"pool size:" << m_reusableItemsPool.size();
3933 qCDebug(lcItemViewDelegateRecycling) <<
"pool size before drain:" << m_reusableItemsPool.size();
3935 for (
auto it = m_reusableItemsPool.
begin();
it != m_reusableItemsPool.
end();) {
3936 auto modelItem = *
it;
3937 modelItem->poolTime++;
3938 if (modelItem->poolTime <= maxPoolTime) {
3942 releaseItem(modelItem);
3946 qCDebug(lcItemViewDelegateRecycling) <<
"pool size after drain:" << m_reusableItemsPool.size();
3978 if (that->d()->change.moveId < 0)
4001 if (
id.isArrayIndex()) {
4010 *hasProperty =
false;
4018 object->setPrototypeOf(changeProto);
4019 object->d()->change = change;
4022 *hasProperty =
true;
4023 return object.asReturnedValue();
4029 if (
id ==
array->engine()->id_length()->propertyKey()) {
4031 *hasProperty =
true;
4035 return Object::virtualGet(
m,
id, receiver, hasProperty);
4042 this->changes =
new QVector<QQmlChangeSet::Change>(changes);
4045 o->setArrayType(QV4::Heap::ArrayData::Custom);
4058 changeProto.set(v4, proto);
4066 const QVector<QQmlChangeSet::Change> &changes)
4070 return o.asReturnedValue();
4075#include "moc_qqmldelegatemodel_p_p.cpp"
4077#include "moc_qqmldelegatemodel_p.cpp"
void rowsMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationRow, QPrivateSignal)
void modelAboutToBeReset(QPrivateSignal)
void columnsRemoved(const QModelIndex &parent, int first, int last, QPrivateSignal)
This signal is emitted after columns have been removed from the model.
LayoutChangeHint
This enum describes the way the model changes layout.
void modelReset(QPrivateSignal)
void dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QList< int > &roles=QList< int >())
This signal is emitted whenever the data in an existing item changes.
void layoutChanged(const QList< QPersistentModelIndex > &parents=QList< QPersistentModelIndex >(), QAbstractItemModel::LayoutChangeHint hint=QAbstractItemModel::NoLayoutChangeHint)
void rowsAboutToBeRemoved(const QModelIndex &parent, int first, int last, QPrivateSignal)
This signal is emitted just before rows are removed from the model.
virtual QHash< int, QByteArray > roleNames() const
void rowsInserted(const QModelIndex &parent, int first, int last, QPrivateSignal)
This signal is emitted after rows have been inserted into the model.
void columnsMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationColumn, QPrivateSignal)
void columnsInserted(const QModelIndex &parent, int first, int last, QPrivateSignal)
This signal is emitted after columns have been inserted into the model.
void rowsRemoved(const QModelIndex &parent, int first, int last, QPrivateSignal)
This signal is emitted after rows have been removed from the model.
QModelIndex index(int row, int column, const QModelIndex &parent=QModelIndex()) const override
Returns the index of the data in row and column with parent.
static QCoreApplication * instance() noexcept
Returns a pointer to the application's QCoreApplication (or QGuiApplication/QApplication) instance.
static void postEvent(QObject *receiver, QEvent *event, int priority=Qt::NormalEventPriority)
Type type() const
Returns the event type.
iterator end()
Returns an STL-style iterator pointing to the imaginary item after the last item in the list.
iterator begin()
Returns an STL-style interator pointing to the first item in the list.
QV4::ExecutionEngine * handle() const
static QJSValue fromReturnedValue(QV4::ReturnedValue d)
The QJSValue class acts as a container for Qt/JavaScript data types.
qsizetype size() const noexcept
void removeAt(qsizetype i)
bool isSharedWith(const QList< T > &other) const
iterator erase(const_iterator begin, const_iterator end)
iterator insert(qsizetype i, parameter_type t)
qsizetype length() const noexcept
const_reference at(qsizetype i) const noexcept
const_iterator constBegin() const noexcept
QList< T > mid(qsizetype pos, qsizetype len=-1) const
void append(parameter_type t)
iterator find(const Key &key)
bool contains(const Key &key) const noexcept
iterator insert(const Key &key, const T &value)
Inserts a new item with the key and a value of value.
iterator end() noexcept
Returns an \l{STL-style iterators}{STL-style iterator} pointing to the imaginary item after the last ...
static QObjectPrivate * get(QObject *o)
QObject * parent() const
Returns a pointer to the parent object.
static QMetaObject::Connection connect(const QObject *sender, const char *signal, const QObject *receiver, const char *member, Qt::ConnectionType=Qt::AutoConnection)
\threadsafe
QObject * sender() const
Returns a pointer to the object that sent the signal, if called in a slot activated by a signal; othe...
virtual bool event(QEvent *event)
This virtual function receives events to an object and should return true if the event e was recogniz...
static bool disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *member)
\threadsafe
void destroyed(QObject *=nullptr)
This signal is emitted immediately before the object obj is destroyed, after any instances of QPointe...
void deleteLater()
\threadsafe
T * data() const noexcept
QPointer< QObject > proxiedObject
QQmlRefPointer< QQmlContextData > proxyContext
void statusChanged(Status) override
Called when the status of the incubator changes.
void setInitialState(QObject *) override
Called after the object is first created, but before complex property bindings are evaluated and,...
int index[QQmlListCompositor::MaximumGroupCount]
QQmlDelegateModelItem * incubating
QQmlDelegateModelPrivate * vdm
void initializeRequiredProperties(QQmlDelegateModelItem *modelItemToIncubate, QObject *object)
QQmlPropertyCache::ConstPtr propertyCache
bool notify(const QList< QQmlDelegateModelItem * > &items, int index, int count, const QVector< int > &roles) const
QAbstractItemModel * aim()
bool canFetchMore() const
QQmlDelegateModelItem * createItem(const QQmlRefPointer< QQmlDelegateModelItemMetaType > &metaType, int index)
bool hasProxyObject() const
QQmlAnyBinding is an abstraction over the various bindings in QML.
void installOn(const QQmlProperty &target, InterceptorMode mode=IgnoreInterceptors)
The QQmlChangeSet class stores an ordered list of notifications about changes to a linear data set.
const QVector< Change > & removes() const
void move(int from, int to, int count, int moveId)
Appends a notification that count items were moved from one index to another.
const QVector< Change > & inserts() const
static QQmlComponentPrivate * get(QQmlComponent *c)
static QQmlProperty removePropertyFromRequired(QObject *createdComponent, const QString &name, RequiredProperties *requiredProperties, QQmlEngine *engine, bool *wasInRequiredProperties=nullptr)
The QQmlComponent class encapsulates a QML component definition.
QList< QQmlError > errors() const
Returns the list of errors that occurred during the last compile or create operation.
void setContextObject(QObject *contextObject)
static QQmlRefPointer< QQmlContextData > get(QQmlContext *context)
static QQmlRefPointer< QQmlContextData > createChild(const QQmlRefPointer< QQmlContextData > &parent)
QQmlRefPointer< QQmlContextData > childContexts() const
static QQmlRefPointer< QQmlContextData > createRefCounted(const QQmlRefPointer< QQmlContextData > &parent)
The QQmlContext class defines a context within a QML engine.
bool isValid() const
Returns whether the context is valid.
QQmlEngine * engine() const
Return the context's QQmlEngine, or \nullptr if the context has no QQmlEngine or the QQmlEngine was d...
static QQmlData * get(QObjectPrivate *priv, bool create)
void setInItems(bool inItems)
void setGroups(const QStringList &groups)
void emitChanges()
\qmlattachedproperty bool QtQml.Models::DelegateModel::inItems
int m_previousIndex[QQmlListCompositor::MaximumGroupCount]
int m_currentIndex[QQmlListCompositor::MaximumGroupCount]
QQmlDelegateModel * model
void setInPersistedItems(bool inPersisted)
QQmlDelegateModelAttached(QObject *parent)
QQmlDelegateModelItem * m_cacheItem
~QQmlDelegateModelEngineData()
QV4::PersistentValue changeProto
QV4::ReturnedValue array(QV4::ExecutionEngine *engine, const QVector< QQmlChangeSet::Change > &changes)
QQmlDelegateModelEngineData(QV4::ExecutionEngine *v4)
bool parseIndex(const QV4::Value &value, int *index, Compositor::Group *group) const
void createdPackage(int index, QQuickPackage *package)
QPointer< QQmlDelegateModel > model
static QQmlDelegateModelGroupPrivate * get(QQmlDelegateModelGroup *group)
bool parseGroupArgs(QQmlV4FunctionPtr args, Compositor::Group *group, int *index, int *count, int *groups) const
bool isChangedConnected()
void initPackage(int index, QQuickPackage *package)
void emitModelUpdated(bool reset)
QQmlDelegateModelGroupEmitterList emitters
void destroyingPackage(QQuickPackage *package)
void setModel(QQmlDelegateModel *model, Compositor::Group group)
void emitChanges(QV4::ExecutionEngine *engine)
void setName(const QString &name)
bool defaultInclude() const
\qmlproperty bool QtQml.Models::DelegateModelGroup::includeByDefault
void resolve(QQmlV4FunctionPtr)
\qmlmethod QtQml.Models::DelegateModelGroup::resolve(int from, int to)
~QQmlDelegateModelGroup()
void addGroups(QQmlV4FunctionPtr)
\qmlmethod QtQml.Models::DelegateModelGroup::addGroups(int index, int count, stringlist groups)
void setGroups(QQmlV4FunctionPtr)
\qmlmethod QtQml.Models::DelegateModelGroup::setGroups(int index, int count, stringlist groups)
Q_INVOKABLE QJSValue get(int index)
\qmlmethod object QtQml.Models::DelegateModelGroup::get(int index)
void create(QQmlV4FunctionPtr)
\qmlmethod QtQml.Models::DelegateModelGroup::create(int index) \qmlmethod QtQml.Models::DelegateModel...
void insert(QQmlV4FunctionPtr)
\qmlmethod QtQml.Models::DelegateModelGroup::insert(int index, jsdict data, array groups = undefined)...
void move(QQmlV4FunctionPtr)
\qmlmethod QtQml.Models::DelegateModelGroup::move(var from, var to, int count)
void remove(QQmlV4FunctionPtr)
\qmlmethod QtQml.Models::DelegateModelGroup::remove(int index, int count)
void setDefaultInclude(bool include)
void defaultIncludeChanged()
void removeGroups(QQmlV4FunctionPtr)
\qmlmethod QtQml.Models::DelegateModelGroup::removeGroups(int index, int count, stringlist groups)
QQmlDelegateModelGroup(QObject *parent=nullptr)
\qmltype DelegateModelGroup \instantiates QQmlDelegateModelGroup \inqmlmodule QtQml....
QQDMIncubationTask * incubationTask
static QV4::ReturnedValue set_member(QQmlDelegateModelItem *thisItem, uint flag, const QV4::Value &arg)
void childContextObjectDestroyed(QObject *childContextObject)
QPointer< QQmlDelegateModelAttached > attached
static QV4::ReturnedValue get_member(QQmlDelegateModelItem *thisItem, uint flag, const QV4::Value &)
static QV4::ReturnedValue get_index(QQmlDelegateModelItem *thisItem, uint flag, const QV4::Value &arg)
static QV4::ReturnedValue get_groups(const QV4::FunctionObject *, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
int groupIndex(Compositor::Group group)
static QQmlDelegateModelItem * dataForObject(QObject *object)
static QV4::ReturnedValue get_model(const QV4::FunctionObject *, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
bool isReferenced() const
virtual void setModelIndex(int idx, int newRow, int newColumn, bool alwaysEmit=false)
QQmlDelegateModelItem(const QQmlRefPointer< QQmlDelegateModelItemMetaType > &metaType, QQmlAdaptorModel::Accessors *accessor, int modelIndex, int row, int column)
QQmlRefPointer< QQmlContextData > contextData
static QV4::ReturnedValue set_groups(const QV4::FunctionObject *, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
QPointer< QObject > object
QQmlRefPointer< QQmlDelegateModelItemMetaType > const metaType
QQmlDelegateModelParts(QQmlDelegateModel *parent)
QList< QQmlPartsModel * > models
QQmlDelegateModel * model
void setInitialState(QQDMIncubationTask *incubationTask, QObject *o)
void removeCacheItem(QQmlDelegateModelItem *cacheItem)
QVariant variantValue(Compositor::Group group, int index, const QString &name)
bool m_incubatorCleanupScheduled
void emitCreatedPackage(QQDMIncubationTask *incubationTask, QQuickPackage *package)
QList< QQDMIncubationTask * > m_finishedIncubating
QQmlDelegateModelItemMetaType * m_cacheMetaType
QList< QQmlDelegateModelItem * > m_cache
QQmlDelegateModel::ReleaseFlags release(QObject *object, QQmlInstanceModel::ReusableFlag reusable=QQmlInstanceModel::NotReusable)
QQmlDelegateModelParts * m_parts
static qsizetype group_count(QQmlListProperty< QQmlDelegateModelGroup > *property)
QQmlAbstractDelegateComponent * m_delegateChooser
QPointer< QQmlContext > m_context
void emitCreatedItem(QQDMIncubationTask *incubationTask, QObject *item)
void emitInitItem(QQDMIncubationTask *incubationTask, QObject *item)
static void group_append(QQmlListProperty< QQmlDelegateModelGroup > *property, QQmlDelegateModelGroup *group)
QQmlStrongJSQObjectReference< QQmlComponent > m_delegate
void emitDestroyingItem(QObject *item)
void addCacheItem(QQmlDelegateModelItem *item, Compositor::iterator it)
void reuseItem(QQmlDelegateModelItem *item, int newModelIndex, int newGroups)
void drainReusableItemsPool(int maxPoolTime)
QQmlDelegateModelGroup * m_persistedItems
static QQmlDelegateModelGroup * group_at(QQmlListProperty< QQmlDelegateModelGroup > *property, qsizetype index)
void emitModelUpdated(const QQmlChangeSet &changeSet, bool reset) override
QObject * object(Compositor::Group group, int index, QQmlIncubator::IncubationMode incubationMode)
void destroyCacheItem(QQmlDelegateModelItem *cacheItem)
void connectToAbstractItemModel()
int adaptorModelCount() const
InsertionResult insert(Compositor::insert_iterator &before, const QV4::Value &object, int groups)
void itemsRemoved(const QVector< Compositor::Remove > &removes, QVarLengthArray< QVector< QQmlChangeSet::Change >, Compositor::MaximumGroupCount > *translatedRemoves, QHash< int, QList< QQmlDelegateModelItem * > > *movedItems=nullptr)
void setGroups(Compositor::iterator from, int count, Compositor::Group group, int groupFlags)
void itemsInserted(const QVector< Compositor::Insert > &inserts, QVarLengthArray< QVector< QQmlChangeSet::Change >, Compositor::MaximumGroupCount > *translatedInserts, QHash< int, QList< QQmlDelegateModelItem * > > *movedItems=nullptr)
QQmlDelegateModelPrivate(QQmlContext *)
Encapsulates a model and delegate.
void delegateChanged(bool add=true, bool remove=true)
QQmlListCompositor m_compositor
QQmlDelegateModelGroup * m_items
void releaseIncubator(QQDMIncubationTask *incubationTask)
bool m_waitingToFetchMore
void incubatorStatusChanged(QQDMIncubationTask *incubationTask, QQmlIncubator::Status status)
void emitInitPackage(QQDMIncubationTask *incubationTask, QQuickPackage *package)
void addGroups(Compositor::iterator from, int count, Compositor::Group group, int groupFlags)
void emitDestroyingPackage(QQuickPackage *package)
void requestMoreIfNecessary()
QQmlComponent * resolveDelegate(int index)
QQmlDelegateModelGroup * m_groups[Compositor::MaximumGroupCount]
void itemsChanged(const QVector< Compositor::Change > &changes)
void removeGroups(Compositor::iterator from, int count, Compositor::Group group, int groupFlags)
void disconnectFromAbstractItemModel()
QQmlReusableDelegateModelItemsPool m_reusableItemsPool
void itemsMoved(const QVector< Compositor::Remove > &removes, const QVector< Compositor::Insert > &inserts)
QQmlAdaptorModel m_adaptorModel
~QQmlDelegateModelPrivate()
QQmlListCompositor::Group m_compositorGroup
static QQmlDelegateModelPrivate * get(QQmlDelegateModel *m)
void setModel(const QVariant &)
void componentComplete() override
Invoked after the root component that caused this instantiation has completed construction.
void filterGroupChanged()
Q_INVOKABLE QVariant modelIndex(int idx) const
\qmlmethod QModelIndex QtQml.Models::DelegateModel::modelIndex(int index)
QQmlDelegateModelGroup * items
\qmlproperty DelegateModelGroup QtQml.Models::DelegateModel::items
void setDelegate(QQmlComponent *)
int count() const override
\qmlproperty int QtQml.Models::DelegateModel::count
void classBegin() override
Invoked after class creation, but before any properties have been set.
void drainReusableItemsPool(int maxPoolTime) override
QVariant variantValue(int index, const QString &role) override
bool event(QEvent *) override
This virtual function receives events to an object and should return true if the event e was recogniz...
QString filterGroup() const
\qmlproperty string QtQml.Models::DelegateModel::filterOnGroup
int indexOf(QObject *object, QObject *objectContext) const override
void setRootIndex(const QVariant &root)
void setFilterGroup(const QString &group)
const QAbstractItemModel * abstractItemModel() const override
Q_INVOKABLE QVariant parentModelIndex() const
\qmlmethod QModelIndex QtQml.Models::DelegateModel::parentModelIndex()
QObject * parts
\qmlproperty object QtQml.Models::DelegateModel::parts
static QQmlDelegateModelAttached * qmlAttachedProperties(QObject *obj)
bool isValid() const override
QQmlListProperty< QQmlDelegateModelGroup > groups
\qmlproperty list<DelegateModelGroup> QtQml.Models::DelegateModel::groups
void setWatchedRoles(const QList< QByteArray > &roles) override
QQmlDelegateModelGroup * persistedItems
\qmlproperty DelegateModelGroup QtQml.Models::DelegateModel::persistedItems
QQmlIncubator::Status incubationStatus(int index) override
ReleaseFlags release(QObject *object, ReusableFlag reusableFlag=NotReusable) override
void cancel(int index) override
static QQmlEnginePrivate * get(QQmlEngine *e)
The QQmlEngine class provides an environment for instantiating QML components.
static QQmlIncubatorPrivate * get(QQmlIncubator *incubator)
QList< QQmlError > errors() const
Return the list of errors encountered while incubating the object.
void clear()
Clears the incubator.
QObject * object() const
Return the incubated object if the status is Ready, otherwise 0.
bool isError() const
Returns true if the incubator's status() is Error.
IncubationMode
Specifies the mode the incubator operates in.
Status status() const
Return the current status of the incubator.
Status
Specifies the status of the QQmlIncubator.
void createdItem(int index, QObject *object)
void modelUpdated(const QQmlChangeSet &changeSet, bool reset)
void destroyingItem(QObject *object)
void initItem(int index, QObject *object)
void setRemoveGroups(int groups)
iterator find(Group group, int index)
Returns an iterator representing the item at index in a group.
void transition(Group from, Group to, QVector< QQmlChangeSet::Change > *removes, QVector< QQmlChangeSet::Change > *inserts)
int count(Group group) const
Returns the number of items that belong to a group.
void clearFlags(Group fromGroup, int from, int count, Group group, uint flags, QVector< Remove > *removals=nullptr)
Clears the given flags flags on count items belonging to group starting at the position from.
void setFlags(Group fromGroup, int from, int count, Group group, int flags, QVector< Insert > *inserts=nullptr)
Sets the given flags flags on count items belonging to group starting at the position identified by f...
void insert(Group group, int before, void *list, int index, int count, uint flags, QVector< Insert > *inserts=nullptr)
Inserts a range of count indexes starting at index from a list with the given flags into a group at i...
void emitModelUpdated(const QQmlChangeSet &changeSet, bool reset) override
QVariant variantValue(int index, const QString &role) override
int count() const override
void filterGroupChanged()
void setFilterGroup(const QString &group)
QQmlIncubator::Status incubationStatus(int index) override
int indexOf(QObject *item, QObject *objectContext) const override
void destroyingPackage(QQuickPackage *package) override
void setWatchedRoles(const QList< QByteArray > &roles) override
QQmlPartsModel(QQmlDelegateModel *model, const QString &part, QObject *parent=nullptr)
\qmlsignal QtQml.Models::DelegateModelGroup::changed(array removed, array inserted)
ReleaseFlags release(QObject *item, ReusableFlag reusable=NotReusable) override
void createdPackage(int index, QQuickPackage *package) override
void initPackage(int index, QQuickPackage *package) override
QString filterGroup() const
bool isValid() const override
The QQmlProperty class abstracts accessing properties on objects created from QML.
void drain(int maxPoolTime, std::function< void(QQmlDelegateModelItem *cacheItem)> releaseItem)
void insertItem(QQmlDelegateModelItem *modelItem)
QQmlDelegateModelItem * takeItem(const QQmlComponent *delegate, int newIndexHint)
QObject * part(const QString &=QString())
iterator erase(const_iterator i)
constexpr QStringView mid(qsizetype pos, qsizetype n=-1) const noexcept
Returns the substring of length length starting at position start in this object.
\macro QT_RESTRICTED_CAST_FROM_ASCII
QString left(qsizetype n) const &
QString & replace(qsizetype i, qsizetype len, QChar after)
static QString fromUtf8(QByteArrayView utf8)
This is an overloaded member function, provided for convenience. It differs from the above function o...
const QChar at(qsizetype i) const
Returns the character at the given index position in the string.
QByteArray toUtf8() const &
ObjectType::Data * allocate(Args &&... args)
void set(ExecutionEngine *engine, const Value &value)
static auto fromValue(T &&value) noexcept(std::is_nothrow_copy_constructible_v< T > &&Private::CanUseInternalSpace< T >) -> std::enable_if_t< std::conjunction_v< std::is_copy_constructible< T >, std::is_destructible< T > >, QVariant >
qDeleteAll(list.begin(), list.end())
QCache< int, Employee > cache
[0]
QSet< QString >::iterator it
QList< QVariant > arguments
QVector3D minimum(const QVector3D &v1, const QVector3D &v2) Q_DECL_NOTHROW
QVector3D maximum(const QVector3D &v1, const QVector3D &v2) Q_DECL_NOTHROW
Combined button and popup list for selecting options.
Scoped< FunctionObject > ScopedFunctionObject
Scoped< String > ScopedString
static int arrayLength(const QString &rawType)
DBusConnection const char DBusError DBusBusType DBusError return DBusConnection DBusHandleMessageFunction void DBusFreeFunction return DBusConnection return DBusConnection return const char DBusError return DBusConnection DBusMessage dbus_uint32_t return DBusConnection dbus_bool_t DBusConnection DBusAddWatchFunction DBusRemoveWatchFunction DBusWatchToggledFunction void DBusFreeFunction return DBusConnection DBusDispatchStatusFunction void DBusFreeFunction DBusTimeout return DBusTimeout return DBusWatch return DBusWatch unsigned int return DBusError const DBusError return const DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessageIter int const void return DBusMessageIter DBusMessageIter return DBusMessageIter void DBusMessageIter void int return DBusMessage DBusMessageIter return DBusMessageIter return DBusMessageIter DBusMessageIter const char const char const char const char return DBusMessage return DBusMessage const char return DBusMessage dbus_bool_t return DBusMessage dbus_uint32_t return DBusMessage void
DBusConnection const char DBusError DBusBusType DBusError return DBusConnection DBusHandleMessageFunction void DBusFreeFunction return DBusConnection return DBusConnection return const char DBusError return DBusConnection DBusMessage dbus_uint32_t return DBusConnection dbus_bool_t DBusConnection DBusAddWatchFunction DBusRemoveWatchFunction DBusWatchToggledFunction void DBusFreeFunction return DBusConnection DBusDispatchStatusFunction void DBusFreeFunction DBusTimeout return DBusTimeout return DBusWatch return DBusWatch unsigned int return DBusError const DBusError return const DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessageIter int const void return DBusMessageIter DBusMessageIter return DBusMessageIter void DBusMessageIter void int return DBusMessage DBusMessageIter return DBusMessageIter return DBusMessageIter DBusMessageIter const char const char const char const char return DBusMessage return DBusMessage const char * destination
EGLOutputLayerEXT EGLint EGLAttrib value
[5]
static QV4::ExecutionEngine * v4Engine(QV4::Value *d)
#define Q_LOGGING_CATEGORY(name,...)
#define qCDebug(category,...)
constexpr const T & qMin(const T &a, const T &b)
constexpr const T & qMax(const T &a, const T &b)
GLboolean GLboolean GLboolean b
GLsizei const GLfloat * v
[13]
GLenum GLuint GLintptr GLsizeiptr size
[1]
GLenum GLuint GLenum GLsizei length
GLenum GLenum GLsizei count
GLint GLsizei GLsizei GLenum GLenum GLsizei void * data
GLenum GLuint GLintptr offset
GLenum GLenum GLsizei void GLsizei void * column
GLdouble GLdouble GLdouble GLdouble q
GLenum GLenum GLsizei void * row
QT_BEGIN_NAMESPACE constexpr decltype(auto) qMakePair(T1 &&value1, T2 &&value2) noexcept(noexcept(std::make_pair(std::forward< T1 >(value1), std::forward< T2 >(value2))))
static qreal dot(const QPointF &a, const QPointF &b)
static void add(QPainterPath &path, const QWingedEdge &list, int edge, QPathEdge::Traversal traversal)
QQmlContext * qmlContext(const QObject *obj)
static QQmlRefPointer< QQmlContextData > initProxy(QQmlDelegateModelItem *cacheItem)
static bool isDoneIncubating(QQmlIncubator::Status status)
static void incrementIndexes(QQmlDelegateModelItem *cacheItem, int count, const int *deltas)
QQmlDelegateModelGroupEmitterList::iterator GroupEmitterListIt
QT_BEGIN_NAMESPACE typedef QQmlListCompositor Compositor
void QQml_setParent_noEvent(QObject *object, QObject *parent)
Makes the object a child of parent.
#define IS_SIGNAL_CONNECTED(Sender, SenderType, Name, Arguments)
Q_QML_EXPORT QQmlInfo qmlInfo(const QObject *me)
Q_QML_EXPORT QQmlInfo qmlWarning(const QObject *me)
QtPrivate::QRegularExpressionMatchIteratorRangeBasedForIterator begin(const QRegularExpressionMatchIterator &iterator)
QLatin1StringView QLatin1String
#define QStringLiteral(str)
static QT_BEGIN_NAMESPACE QVariant hint(QPlatformIntegration::StyleHint h)
QT_BEGIN_NAMESPACE constexpr void qSwap(T &value1, T &value2) noexcept(std::is_nothrow_swappable_v< T >)
static QT_BEGIN_NAMESPACE void init(QTextBoundaryFinder::BoundaryType type, QStringView str, QCharAttributes *attributes)
#define V4_DEFINE_EXTENSION(dataclass, datafunction)
#define THROW_TYPE_ERROR()
#define RETURN_UNDEFINED()
#define DEFINE_OBJECT_VTABLE(classname)
#define V4_OBJECT2(DataClass, superClass)
const char className[16]
[1]
QSqlQueryModel * model
[16]
settings remove("monkey")
obj metaObject() -> className()
\inmodule QtCore \reentrant
qsizetype lastIndexOf(const AT &t, qsizetype from=-1) const noexcept
const QQmlChangeSet::Change & at(int index) const
static QV4::Heap::QQmlDelegateModelGroupChangeArray * create(QV4::ExecutionEngine *engine, const QVector< QQmlChangeSet::Change > &changes)
static QV4::ReturnedValue virtualGet(const QV4::Managed *m, QV4::PropertyKey id, const QV4::Value *receiver, bool *hasProperty)
static QV4::ReturnedValue method_get_index(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
static QV4::ReturnedValue method_get_moveId(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
static QV4::Heap::QQmlDelegateModelGroupChange * create(QV4::ExecutionEngine *e)
static QV4::ReturnedValue method_get_count(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
static ReturnedValue virtualCall(const QV4::FunctionObject *that, const Value *thisObject, const Value *argv, int argc)
static Heap::DelegateModelGroupFunction * create(QV4::ExecutionEngine *engine, uint flag, QV4::ReturnedValue(*code)(QQmlDelegateModelItem *, uint, const QV4::Value &))
static constexpr ReturnedValue undefined()
MemoryManager * memoryManager
QV4::ReturnedValue fromVariant(const QVariant &)
Heap::Object * newObject()
Heap::String * newString(char16_t c)
static QVariant toVariant(const QV4::Value &value, QMetaType typeHint, bool createJSValueForObjectsAndSymbols=true)
ReturnedValue throwTypeError()
void init(const QVector< QQmlChangeSet::Change > &changes)
QVector< QQmlChangeSet::Change > * changes
QQmlChangeSet::ChangeData change
QQmlDelegateModelItem * item
void defineAccessorProperty(const QString &name, VTable::Call getter, VTable::Call setter)
void insertMember(StringOrSymbol *s, const Value &v, PropertyAttributes attributes=Attr_Data)
static ReturnedValue wrap(ExecutionEngine *engine, QObject *object)
static constexpr Value undefinedValue()
QString toQStringNoThrow() const