qiurui
/
qtdeclarative
mirror of https://github.com/qt/qtdeclarative.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Move the model classes from QtQuick to QtQml 

This is needed for proper support of non-GUI instantiators in QtQml.
Only private C++ classes are affected. Aside from name changes, model
classes now operate on QObjects instead of QQuickItems, leading to minor
changes in the implementation of QtQuick classes using them.

The old QML type names will still be registered in the QtQuick import
for the forseeable future, but pointing to the new classes. The new QML
types will be added in a second commit.

Classes Affected:
QQuickVisualDataGroup -> QQmlDataGroup
QQuickVisualDataModel -> QQmlDelegateModel
QQuickVisualItemModel -> QQmlObjectModel
QQuickVisualModel -> QQmlInstanceModel
QQuickChangeSet -> QQmlChangeSet
QQuickListAccessor -> QQmlListAccessor
QQuickListCompositor -> QQmlListCompositor
QQuickPackage -> QQuickPackage (just moved for now)

Change-Id: Ia19e630e53bfa9e5d459e289596cd11df1ea3930
Reviewed-by: Andrew den Exter <andrew.den.exter@qinetic.com.au>
This commit is contained in:
Alan Alpert 2013-01-15 14:26:59 -08:00 committed by The Qt Project
parent bbb3d5b403
commit 7cad0e52c5
46 changed files with 1520 additions and 1477 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/particles/qquickitemparticle.cpp
View File

@ -40,7 +40,6 @@
****************************************************************************/
#include "qquickitemparticle_p.h"
#include <private/qquickvisualitemmodel_p.h>
#include <QtQuick/qsgnode.h>
#include <QTimer>
#include <QQmlComponent>

10
src/qml/items/items.pri Normal file
View File

@ -0,0 +1,10 @@
SOURCES += \
$$PWD/qquickpackage.cpp \
$$PWD/qqmldelegatemodel.cpp \
$$PWD/qqmlobjectmodel.cpp
HEADERS += \
$$PWD/qquickpackage_p.h \
$$PWD/qqmldelegatemodel_p.h \
$$PWD/qqmldelegatemodel_p_p.h \
$$PWD/qqmlobjectmodel_p.h

901
src/quick/items/qquickvisualdatamodel.cpp → src/qml/items/qqmldelegatemodel.cpp
View File

File diff suppressed because it is too large Load Diff

96
src/quick/items/qquickvisualdatamodel_p.h → src/qml/items/qqmldelegatemodel_p.h
View File

@ -39,12 +39,12 @@
**
****************************************************************************/
#ifndef QQUICKVISUALDATAMODEL_P_H
#define QQUICKVISUALDATAMODEL_P_H
#ifndef QQMLDATAMODEL_P_H
#define QQMLDATAMODEL_P_H
#include <private/qtquickglobal_p.h>
#include <private/qquicklistcompositor_p.h>
#include <private/qquickvisualitemmodel_p.h>
#include <private/qtqmlglobal_p.h>
#include <private/qqmllistcompositor_p.h>
#include <private/qqmlobjectmodel_p.h>
#include <QtCore/qabstractitemmodel.h>
#include <QtCore/qstringlist.h>
@ -58,34 +58,34 @@ Q_DECLARE_METATYPE(QModelIndex)
QT_BEGIN_NAMESPACE
class QQuickChangeSet;
class QQmlChangeSet;
class QQmlComponent;
class QQuickPackage;
class QQmlV8Function;
class QQuickVisualDataGroup;
class QQuickVisualDataModelAttached;
class QQuickVisualDataModelPrivate;
class QQmlDataGroup;
class QQmlDelegateModelAttached;
class QQmlDelegateModelPrivate;
class Q_QUICK_PRIVATE_EXPORT QQuickVisualDataModel : public QQuickVisualModel, public QQmlParserStatus
class Q_QML_PRIVATE_EXPORT QQmlDelegateModel : public QQmlInstanceModel, public QQmlParserStatus
{
Q_OBJECT
Q_DECLARE_PRIVATE(QQuickVisualDataModel)
Q_DECLARE_PRIVATE(QQmlDelegateModel)
Q_PROPERTY(QVariant model READ model WRITE setModel)
Q_PROPERTY(QQmlComponent *delegate READ delegate WRITE setDelegate)
Q_PROPERTY(QString filterOnGroup READ filterGroup WRITE setFilterGroup NOTIFY filterGroupChanged RESET resetFilterGroup)
Q_PROPERTY(QQuickVisualDataGroup *items READ items CONSTANT)
Q_PROPERTY(QQuickVisualDataGroup *persistedItems READ persistedItems CONSTANT)
Q_PROPERTY(QQmlListProperty<QQuickVisualDataGroup> groups READ groups CONSTANT)
Q_PROPERTY(QQmlDataGroup *items READ items CONSTANT) //TODO : worth renaming?
Q_PROPERTY(QQmlDataGroup *persistedItems READ persistedItems CONSTANT)
Q_PROPERTY(QQmlListProperty<QQmlDataGroup> groups READ groups CONSTANT)
Q_PROPERTY(QObject *parts READ parts CONSTANT)
Q_PROPERTY(QVariant rootIndex READ rootIndex WRITE setRootIndex NOTIFY rootIndexChanged)
Q_CLASSINFO("DefaultProperty", "delegate")
Q_INTERFACES(QQmlParserStatus)
public:
QQuickVisualDataModel();
QQuickVisualDataModel(QQmlContext *, QObject *parent=0);
virtual ~QQuickVisualDataModel();
QQmlDelegateModel();
QQmlDelegateModel(QQmlContext *, QObject *parent=0);
virtual ~QQmlDelegateModel();
void classBegin();
void componentComplete();
@ -104,26 +104,26 @@ public:
int count() const;
bool isValid() const { return delegate() != 0; }
QQuickItem *item(int index, bool asynchronous=false);
ReleaseFlags release(QQuickItem *item);
QObject *object(int index, bool asynchronous=false);
ReleaseFlags release(QObject *object);
void cancel(int index);
virtual QString stringValue(int index, const QString &role);
virtual void setWatchedRoles(QList<QByteArray> roles);
int indexOf(QQuickItem *item, QObject *objectContext) const;
int indexOf(QObject *object, QObject *objectContext) const;
QString filterGroup() const;
void setFilterGroup(const QString &group);
void resetFilterGroup();
QQuickVisualDataGroup *items();
QQuickVisualDataGroup *persistedItems();
QQmlListProperty<QQuickVisualDataGroup> groups();
QQmlDataGroup *items();
QQmlDataGroup *persistedItems();
QQmlListProperty<QQmlDataGroup> groups();
QObject *parts();
bool event(QEvent *);
static QQuickVisualDataModelAttached *qmlAttachedProperties(QObject *obj);
static QQmlDelegateModelAttached *qmlAttachedProperties(QObject *obj);
Q_SIGNALS:
void filterGroupChanged();
@ -144,20 +144,20 @@ private Q_SLOTS:
void _q_layoutChanged();
private:
Q_DISABLE_COPY(QQuickVisualDataModel)
Q_DISABLE_COPY(QQmlDelegateModel)
};
class QQuickVisualDataGroupPrivate;
class Q_AUTOTEST_EXPORT QQuickVisualDataGroup : public QObject
class QQmlDataGroupPrivate;
class Q_QML_PRIVATE_EXPORT QQmlDataGroup : public QObject
{
Q_OBJECT
Q_PROPERTY(int count READ count NOTIFY countChanged)
Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
Q_PROPERTY(bool includeByDefault READ defaultInclude WRITE setDefaultInclude NOTIFY defaultIncludeChanged)
public:
QQuickVisualDataGroup(QObject *parent = 0);
QQuickVisualDataGroup(const QString &name, QQuickVisualDataModel *model, int compositorType, QObject *parent = 0);
~QQuickVisualDataGroup();
QQmlDataGroup(QObject *parent = 0);
QQmlDataGroup(const QString &name, QQmlDelegateModel *model, int compositorType, QObject *parent = 0);
~QQmlDataGroup();
QString name() const;
void setName(const QString &name);
@ -185,25 +185,25 @@ Q_SIGNALS:
void defaultIncludeChanged();
void changed(const QQmlV8Handle &removed, const QQmlV8Handle &inserted);
private:
Q_DECLARE_PRIVATE(QQuickVisualDataGroup)
Q_DECLARE_PRIVATE(QQmlDataGroup)
};
class QQuickVisualDataModelItem;
class QQuickVisualDataModelAttachedMetaObject;
class QQuickVisualDataModelAttached : public QObject
class QQmlDelegateModelItem;
class QQmlDelegateModelAttachedMetaObject;
class QQmlDelegateModelAttached : public QObject
{
Q_OBJECT
Q_PROPERTY(QQuickVisualDataModel *model READ model CONSTANT)
Q_PROPERTY(QQmlDelegateModel *model READ model CONSTANT)
Q_PROPERTY(QStringList groups READ groups WRITE setGroups NOTIFY groupsChanged)
Q_PROPERTY(bool isUnresolved READ isUnresolved NOTIFY unresolvedChanged)
public:
QQuickVisualDataModelAttached(QObject *parent);
QQuickVisualDataModelAttached(QQuickVisualDataModelItem *cacheItem, QObject *parent);
~QQuickVisualDataModelAttached() {}
QQmlDelegateModelAttached(QObject *parent);
QQmlDelegateModelAttached(QQmlDelegateModelItem *cacheItem, QObject *parent);
~QQmlDelegateModelAttached() {}
void setCacheItem(QQuickVisualDataModelItem *item);
void setCacheItem(QQmlDelegateModelItem *item);
QQuickVisualDataModel *model() const;
QQmlDelegateModel *model() const;
QStringList groups() const;
void setGroups(const QStringList &groups);
@ -219,20 +219,20 @@ Q_SIGNALS:
void unresolvedChanged();
public:
QQuickVisualDataModelItem *m_cacheItem;
QQmlDelegateModelItem *m_cacheItem;
int m_previousGroups;
int m_currentIndex[QQuickListCompositor::MaximumGroupCount];
int m_previousIndex[QQuickListCompositor::MaximumGroupCount];
int m_currentIndex[QQmlListCompositor::MaximumGroupCount];
int m_previousIndex[QQmlListCompositor::MaximumGroupCount];
friend class QQuickVisualDataModelAttachedMetaObject;
friend class QQmlDelegateModelAttachedMetaObject;
};
QT_END_NAMESPACE
QML_DECLARE_TYPE(QQuickVisualDataModel)
QML_DECLARE_TYPEINFO(QQuickVisualDataModel, QML_HAS_ATTACHED_PROPERTIES)
QML_DECLARE_TYPE(QQuickVisualDataGroup)
QML_DECLARE_TYPE(QQmlDelegateModel)
QML_DECLARE_TYPEINFO(QQmlDelegateModel, QML_HAS_ATTACHED_PROPERTIES)
QML_DECLARE_TYPE(QQmlDataGroup)
QT_END_HEADER
#endif // QQUICKVISUALDATAMODEL_P_H
#endif // QQMLDATAMODEL_P_H

196
src/quick/items/qquickvisualdatamodel_p_p.h → src/qml/items/qqmldelegatemodel_p_p.h
View File

@ -39,16 +39,16 @@
**
****************************************************************************/
#ifndef QQUICKVISUALDATAMODEL_P_P_H
#define QQUICKVISUALDATAMODEL_P_P_H
#ifndef QQMLDATAMODEL_P_P_H
#define QQMLDATAMODEL_P_P_H
#include "qquickvisualdatamodel_p.h"
#include "qqmldelegatemodel_p.h"
#include "qquickvisualadaptormodel_p.h"
#include <QtQml/qqmlcontext.h>
#include <QtQml/qqmlincubator.h>
#include <private/qqmladaptormodel_p.h>
#include <private/qqmlopenmetaobject_p.h>
//
@ -64,15 +64,15 @@
QT_BEGIN_NAMESPACE
typedef QQuickListCompositor Compositor;
typedef QQmlListCompositor Compositor;
class QQuickVisualDataModelAttachedMetaObject;
class QQmlDelegateModelAttachedMetaObject;
class QQuickVisualDataModelItemMetaType : public QQmlRefCount
class QQmlDelegateModelItemMetaType : public QQmlRefCount
{
public:
QQuickVisualDataModelItemMetaType(QV8Engine *engine, QQuickVisualDataModel *model, const QStringList &groupNames);
~QQuickVisualDataModelItemMetaType();
QQmlDelegateModelItemMetaType(QV8Engine *engine, QQmlDelegateModel *model, const QStringList &groupNames);
~QQmlDelegateModelItemMetaType();
void initializeMetaObject();
void initializeConstructor();
@ -92,26 +92,26 @@ public:
v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info);
static v8::Handle<v8::Value> get_index(v8::Local<v8::String>, const v8::AccessorInfo &info);
QQmlGuard<QQuickVisualDataModel> model;
QQmlGuard<QQmlDelegateModel> model;
const int groupCount;
QV8Engine * const v8Engine;
QQuickVisualDataModelAttachedMetaObject *metaObject;
QQmlDelegateModelAttachedMetaObject *metaObject;
const QStringList groupNames;
v8::Persistent<v8::ObjectTemplate> constructor;
};
class QQuickVisualAdaptorModel;
class QVDMIncubationTask;
class QQmlAdaptorModel;
class QQDMIncubationTask;
class QQuickVisualDataModelItem : public QObject, public QV8ObjectResource
class QQmlDelegateModelItem : public QObject, public QV8ObjectResource
{
Q_OBJECT
Q_PROPERTY(int index READ modelIndex NOTIFY modelIndexChanged)
Q_PROPERTY(QObject *model READ modelObject CONSTANT)
V8_RESOURCE_TYPE(VisualDataItemType)
public:
QQuickVisualDataModelItem(QQuickVisualDataModelItemMetaType *metaType, int modelIndex);
~QQuickVisualDataModelItem();
QQmlDelegateModelItem(QQmlDelegateModelItemMetaType *metaType, int modelIndex);
~QQmlDelegateModelItem();
void referenceObject() { ++objectRef; }
bool releaseObject() { return --objectRef == 0 && !(groups & Compositor::PersistedFlag); }
@ -134,7 +134,7 @@ public:
QQmlContextData *forContext);
void destroyObject();
static QQuickVisualDataModelItem *dataForObject(QObject *object);
static QQmlDelegateModelItem *dataForObject(QObject *object);
int groupIndex(Compositor::Group group);
@ -144,13 +144,13 @@ public:
virtual v8::Handle<v8::Value> get() { return engine->newQObject(this); }
virtual void setValue(const QString &role, const QVariant &value) { Q_UNUSED(role); Q_UNUSED(value); }
virtual bool resolveIndex(const QQuickVisualAdaptorModel &, int) { return false; }
virtual bool resolveIndex(const QQmlAdaptorModel &, int) { return false; }
QQuickVisualDataModelItemMetaType * const metaType;
QQmlDelegateModelItemMetaType * const metaType;
QQmlContextData *contextData;
QObject *object;
QQuickVisualDataModelAttached *attached;
QVDMIncubationTask *incubationTask;
QQmlDelegateModelAttached *attached;
QQDMIncubationTask *incubationTask;
int objectRef;
int scriptRef;
int groups;
@ -165,11 +165,11 @@ protected:
};
class QQuickVisualDataModelPrivate;
class QVDMIncubationTask : public QQmlIncubator
class QQmlDelegateModelPrivate;
class QQDMIncubationTask : public QQmlIncubator
{
public:
QVDMIncubationTask(QQuickVisualDataModelPrivate *l, IncubationMode mode)
QQDMIncubationTask(QQmlDelegateModelPrivate *l, IncubationMode mode)
: QQmlIncubator(mode)
, incubating(0)
, vdm(l) {}
@ -177,17 +177,17 @@ public:
virtual void statusChanged(Status);
virtual void setInitialState(QObject *);
QQuickVisualDataModelItem *incubating;
QQuickVisualDataModelPrivate *vdm;
int index[QQuickListCompositor::MaximumGroupCount];
QQmlDelegateModelItem *incubating;
QQmlDelegateModelPrivate *vdm;
int index[QQmlListCompositor::MaximumGroupCount];
};
class QQuickVisualDataGroupEmitter
class QQmlDataGroupEmitter
{
public:
virtual ~QQuickVisualDataGroupEmitter() {}
virtual void emitModelUpdated(const QQuickChangeSet &changeSet, bool reset) = 0;
virtual ~QQmlDataGroupEmitter() {}
virtual void emitModelUpdated(const QQmlChangeSet &changeSet, bool reset) = 0;
virtual void createdPackage(int, QQuickPackage *) {}
virtual void initPackage(int, QQuickPackage *) {}
virtual void destroyingPackage(QQuickPackage *) {}
@ -195,19 +195,19 @@ public:
QIntrusiveListNode emitterNode;
};
typedef QIntrusiveList<QQuickVisualDataGroupEmitter, &QQuickVisualDataGroupEmitter::emitterNode> QQuickVisualDataGroupEmitterList;
typedef QIntrusiveList<QQmlDataGroupEmitter, &QQmlDataGroupEmitter::emitterNode> QQmlDataGroupEmitterList;
class QQuickVisualDataGroupPrivate : public QObjectPrivate
class QQmlDataGroupPrivate : public QObjectPrivate
{
public:
Q_DECLARE_PUBLIC(QQuickVisualDataGroup)
Q_DECLARE_PUBLIC(QQmlDataGroup)
QQuickVisualDataGroupPrivate() : group(Compositor::Cache), defaultInclude(false) {}
QQmlDataGroupPrivate() : group(Compositor::Cache), defaultInclude(false) {}
static QQuickVisualDataGroupPrivate *get(QQuickVisualDataGroup *group) {
return static_cast<QQuickVisualDataGroupPrivate *>(QObjectPrivate::get(group)); }
static QQmlDataGroupPrivate *get(QQmlDataGroup *group) {
return static_cast<QQmlDataGroupPrivate *>(QObjectPrivate::get(group)); }
void setModel(QQuickVisualDataModel *model, Compositor::Group group);
void setModel(QQmlDelegateModel *model, Compositor::Group group);
bool isChangedConnected();
void emitChanges(QV8Engine *engine);
void emitModelUpdated(bool reset);
@ -221,41 +221,41 @@ public:
QQmlV8Function *args, Compositor::Group *group, int *index, int *count, int *groups) const;
Compositor::Group group;
QQmlGuard<QQuickVisualDataModel> model;
QQuickVisualDataGroupEmitterList emitters;
QQuickChangeSet changeSet;
QQmlGuard<QQmlDelegateModel> model;
QQmlDataGroupEmitterList emitters;
QQmlChangeSet changeSet;
QString name;
bool defaultInclude;
};
class QQuickVisualDataModelParts;
class QQmlDelegateModelParts;
class QQuickVisualDataModelPrivate : public QObjectPrivate, public QQuickVisualDataGroupEmitter
class QQmlDelegateModelPrivate : public QObjectPrivate, public QQmlDataGroupEmitter
{
Q_DECLARE_PUBLIC(QQuickVisualDataModel)
Q_DECLARE_PUBLIC(QQmlDelegateModel)
public:
QQuickVisualDataModelPrivate(QQmlContext *);
~QQuickVisualDataModelPrivate();
QQmlDelegateModelPrivate(QQmlContext *);
~QQmlDelegateModelPrivate();
static QQuickVisualDataModelPrivate *get(QQuickVisualDataModel *m) {
return static_cast<QQuickVisualDataModelPrivate *>(QObjectPrivate::get(m));
static QQmlDelegateModelPrivate *get(QQmlDelegateModel *m) {
return static_cast<QQmlDelegateModelPrivate *>(QObjectPrivate::get(m));
}
void init();
void connectModel(QQuickVisualAdaptorModel *model);
void connectModel(QQmlAdaptorModel *model);
QObject *object(Compositor::Group group, int index, bool asynchronous);
QQuickVisualDataModel::ReleaseFlags release(QObject *object);
QQmlDelegateModel::ReleaseFlags release(QObject *object);
QString stringValue(Compositor::Group group, int index, const QString &name);
void emitCreatedPackage(QVDMIncubationTask *incubationTask, QQuickPackage *package);
void emitInitPackage(QVDMIncubationTask *incubationTask, QQuickPackage *package);
void emitCreatedItem(QVDMIncubationTask *incubationTask, QQuickItem *item) {
void emitCreatedPackage(QQDMIncubationTask *incubationTask, QQuickPackage *package);
void emitInitPackage(QQDMIncubationTask *incubationTask, QQuickPackage *package);
void emitCreatedItem(QQDMIncubationTask *incubationTask, QObject *item) {
emit q_func()->createdItem(incubationTask->index[m_compositorGroup], item); }
void emitInitItem(QVDMIncubationTask *incubationTask, QQuickItem *item) {
void emitInitItem(QQDMIncubationTask *incubationTask, QObject *item) {
emit q_func()->initItem(incubationTask->index[m_compositorGroup], item); }
void emitDestroyingPackage(QQuickPackage *package);
void emitDestroyingItem(QQuickItem *item) { emit q_func()->destroyingItem(item); }
void removeCacheItem(QQuickVisualDataModelItem *cacheItem);
void emitDestroyingItem(QObject *item) { emit q_func()->destroyingItem(item); }
void removeCacheItem(QQmlDelegateModelItem *cacheItem);
void updateFilterGroup();
@ -265,41 +265,41 @@ public:
void itemsInserted(
const QVector<Compositor::Insert> &inserts,
QVarLengthArray<QVector<QQuickChangeSet::Insert>, Compositor::MaximumGroupCount> *translatedInserts,
QHash<int, QList<QQuickVisualDataModelItem *> > *movedItems = 0);
QVarLengthArray<QVector<QQmlChangeSet::Insert>, Compositor::MaximumGroupCount> *translatedInserts,
QHash<int, QList<QQmlDelegateModelItem *> > *movedItems = 0);
void itemsInserted(const QVector<Compositor::Insert> &inserts);
void itemsRemoved(
const QVector<Compositor::Remove> &removes,
QVarLengthArray<QVector<QQuickChangeSet::Remove>, Compositor::MaximumGroupCount> *translatedRemoves,
QHash<int, QList<QQuickVisualDataModelItem *> > *movedItems = 0);
QVarLengthArray<QVector<QQmlChangeSet::Remove>, Compositor::MaximumGroupCount> *translatedRemoves,
QHash<int, QList<QQmlDelegateModelItem *> > *movedItems = 0);
void itemsRemoved(const QVector<Compositor::Remove> &removes);
void itemsMoved(
const QVector<Compositor::Remove> &removes, const QVector<Compositor::Insert> &inserts);
void itemsChanged(const QVector<Compositor::Change> &changes);
template <typename T> static v8::Local<v8::Array> buildChangeList(const QVector<T> &changes);
void emitChanges();
void emitModelUpdated(const QQuickChangeSet &changeSet, bool reset);
void emitModelUpdated(const QQmlChangeSet &changeSet, bool reset);
bool insert(Compositor::insert_iterator &before, const v8::Local<v8::Object> &object, int groups);
static void group_append(QQmlListProperty<QQuickVisualDataGroup> *property, QQuickVisualDataGroup *group);
static int group_count(QQmlListProperty<QQuickVisualDataGroup> *property);
static QQuickVisualDataGroup *group_at(QQmlListProperty<QQuickVisualDataGroup> *property, int index);
static void group_append(QQmlListProperty<QQmlDataGroup> *property, QQmlDataGroup *group);
static int group_count(QQmlListProperty<QQmlDataGroup> *property);
static QQmlDataGroup *group_at(QQmlListProperty<QQmlDataGroup> *property, int index);
void releaseIncubator(QVDMIncubationTask *incubationTask);
void incubatorStatusChanged(QVDMIncubationTask *incubationTask, QQmlIncubator::Status status);
void setInitialState(QVDMIncubationTask *incubationTask, QObject *o);
void releaseIncubator(QQDMIncubationTask *incubationTask);
void incubatorStatusChanged(QQDMIncubationTask *incubationTask, QQmlIncubator::Status status);
void setInitialState(QQDMIncubationTask *incubationTask, QObject *o);
QQuickVisualAdaptorModel m_adaptorModel;
QQuickListCompositor m_compositor;
QQmlAdaptorModel m_adaptorModel;
QQmlListCompositor m_compositor;
QQmlComponent *m_delegate;
QQuickVisualDataModelItemMetaType *m_cacheMetaType;
QQmlDelegateModelItemMetaType *m_cacheMetaType;
QQmlContext *m_context;
QQuickVisualDataModelParts *m_parts;
QQuickVisualDataGroupEmitterList m_pendingParts;
QQmlDelegateModelParts *m_parts;
QQmlDataGroupEmitterList m_pendingParts;
QList<QQuickVisualDataModelItem *> m_cache;
QList<QVDMIncubationTask *> m_finishedIncubating;
QList<QQmlDelegateModelItem *> m_cache;
QList<QQDMIncubationTask *> m_finishedIncubating;
QList<QByteArray> m_watchedRoles;
QString m_filterGroup;
@ -307,7 +307,7 @@ public:
int m_count;
int m_groupCount;
QQuickListCompositor::Group m_compositorGroup;
QQmlListCompositor::Group m_compositorGroup;
bool m_complete : 1;
bool m_delegateValidated : 1;
bool m_reset : 1;
@ -316,39 +316,39 @@ public:
union {
struct {
QQuickVisualDataGroup *m_cacheItems;
QQuickVisualDataGroup *m_items;
QQuickVisualDataGroup *m_persistedItems;
QQmlDataGroup *m_cacheItems;
QQmlDataGroup *m_items;
QQmlDataGroup *m_persistedItems;
};
QQuickVisualDataGroup *m_groups[Compositor::MaximumGroupCount];
QQmlDataGroup *m_groups[Compositor::MaximumGroupCount];
};
};
class QQuickVisualPartsModel : public QQuickVisualModel, public QQuickVisualDataGroupEmitter
class QQmlPartsModel : public QQmlInstanceModel, public QQmlDataGroupEmitter
{
Q_OBJECT
Q_PROPERTY(QString filterOnGroup READ filterGroup WRITE setFilterGroup NOTIFY filterGroupChanged RESET resetFilterGroup)
public:
QQuickVisualPartsModel(QQuickVisualDataModel *model, const QString &part, QObject *parent = 0);
~QQuickVisualPartsModel();
QQmlPartsModel(QQmlDelegateModel *model, const QString &part, QObject *parent = 0);
~QQmlPartsModel();
QString filterGroup() const;
void setFilterGroup(const QString &group);
void resetFilterGroup();
void updateFilterGroup();
void updateFilterGroup(Compositor::Group group, const QQuickChangeSet &changeSet);
void updateFilterGroup(Compositor::Group group, const QQmlChangeSet &changeSet);
int count() const;
bool isValid() const;
QQuickItem *item(int index, bool asynchronous=false);
ReleaseFlags release(QQuickItem *item);
QObject *object(int index, bool asynchronous=false);
ReleaseFlags release(QObject *item);
QString stringValue(int index, const QString &role);
QList<QByteArray> watchedRoles() const { return m_watchedRoles; }
void setWatchedRoles(QList<QByteArray> roles);
int indexOf(QQuickItem *item, QObject *objectContext) const;
int indexOf(QObject *item, QObject *objectContext) const;
void emitModelUpdated(const QQuickChangeSet &changeSet, bool reset);
void emitModelUpdated(const QQmlChangeSet &changeSet, bool reset);
void createdPackage(int index, QQuickPackage *package);
void initPackage(int index, QQuickPackage *package);
@ -358,7 +358,7 @@ Q_SIGNALS:
void filterGroupChanged();
private:
QQuickVisualDataModel *m_model;
QQmlDelegateModel *m_model;
QHash<QObject *, QQuickPackage *> m_packaged;
QString m_part;
QString m_filterGroup;
@ -369,38 +369,38 @@ private:
class QMetaPropertyBuilder;
class QQuickVisualDataModelPartsMetaObject : public QQmlOpenMetaObject
class QQmlDelegateModelPartsMetaObject : public QQmlOpenMetaObject
{
public:
QQuickVisualDataModelPartsMetaObject(QObject *parent)
QQmlDelegateModelPartsMetaObject(QObject *parent)
: QQmlOpenMetaObject(parent) {}
virtual void propertyCreated(int, QMetaPropertyBuilder &);
virtual QVariant initialValue(int);
};
class QQuickVisualDataModelParts : public QObject
class QQmlDelegateModelParts : public QObject
{
Q_OBJECT
public:
QQuickVisualDataModelParts(QQuickVisualDataModel *parent);
QQmlDelegateModelParts(QQmlDelegateModel *parent);
QQuickVisualDataModel *model;
QList<QQuickVisualPartsModel *> models;
QQmlDelegateModel *model;
QList<QQmlPartsModel *> models;
};
class QQuickVisualDataModelAttachedMetaObject : public QAbstractDynamicMetaObject, public QQmlRefCount
class QQmlDelegateModelAttachedMetaObject : public QAbstractDynamicMetaObject, public QQmlRefCount
{
public:
QQuickVisualDataModelAttachedMetaObject(
QQuickVisualDataModelItemMetaType *metaType, QMetaObject *metaObject);
~QQuickVisualDataModelAttachedMetaObject();
QQmlDelegateModelAttachedMetaObject(
QQmlDelegateModelItemMetaType *metaType, QMetaObject *metaObject);
~QQmlDelegateModelAttachedMetaObject();
void objectDestroyed(QObject *);
int metaCall(QObject *, QMetaObject::Call, int _id, void **);
private:
QQuickVisualDataModelItemMetaType * const metaType;
QQmlDelegateModelItemMetaType * const metaType;
QMetaObject * const metaObject;
const int memberPropertyOffset;
const int indexPropertyOffset;

101
src/quick/items/qquickvisualitemmodel.cpp → src/qml/items/qqmlobjectmodel.cpp
View File

@ -39,14 +39,13 @@
**
****************************************************************************/
#include "qquickvisualitemmodel_p.h"
#include "qquickitem.h"
#include "qqmlobjectmodel_p.h"
#include <QtCore/qcoreapplication.h>
#include <QtQml/qqmlcontext.h>
#include <QtQml/qqmlengine.h>
#include <private/qquickchangeset_p.h>
#include <private/qqmlchangeset_p.h>
#include <private/qqmlglobal_p.h>
#include <private/qobject_p.h>
@ -55,69 +54,69 @@
QT_BEGIN_NAMESPACE
QHash<QObject*, QQuickVisualItemModelAttached*> QQuickVisualItemModelAttached::attachedProperties;
QHash<QObject*, QQmlObjectModelAttached*> QQmlObjectModelAttached::attachedProperties;
class QQuickVisualItemModelPrivate : public QObjectPrivate
class QQmlObjectModelPrivate : public QObjectPrivate
{
Q_DECLARE_PUBLIC(QQuickVisualItemModel)
Q_DECLARE_PUBLIC(QQmlObjectModel)
public:
class Item {
public:
Item(QQuickItem *i) : item(i), ref(0) {}
Item(QObject *i) : item(i), ref(0) {}
void addRef() { ++ref; }
bool deref() { return --ref == 0; }
QQuickItem *item;
QObject *item;
int ref;
};
QQuickVisualItemModelPrivate() : QObjectPrivate() {}
QQmlObjectModelPrivate() : QObjectPrivate() {}
static void children_append(QQmlListProperty<QQuickItem> *prop, QQuickItem *item) {
static_cast<QQuickVisualItemModelPrivate *>(prop->data)->children.append(Item(item));
static_cast<QQuickVisualItemModelPrivate *>(prop->data)->itemAppended();
static_cast<QQuickVisualItemModelPrivate *>(prop->data)->emitChildrenChanged();
static void children_append(QQmlListProperty<QObject> *prop, QObject *item) {
static_cast<QQmlObjectModelPrivate *>(prop->data)->children.append(Item(item));
static_cast<QQmlObjectModelPrivate *>(prop->data)->itemAppended();
static_cast<QQmlObjectModelPrivate *>(prop->data)->emitChildrenChanged();
}
static int children_count(QQmlListProperty<QQuickItem> *prop) {
return static_cast<QQuickVisualItemModelPrivate *>(prop->data)->children.count();
static int children_count(QQmlListProperty<QObject> *prop) {
return static_cast<QQmlObjectModelPrivate *>(prop->data)->children.count();
}
static QQuickItem *children_at(QQmlListProperty<QQuickItem> *prop, int index) {
return static_cast<QQuickVisualItemModelPrivate *>(prop->data)->children.at(index).item;
static QObject *children_at(QQmlListProperty<QObject> *prop, int index) {
return static_cast<QQmlObjectModelPrivate *>(prop->data)->children.at(index).item;
}
static void children_clear(QQmlListProperty<QQuickItem> *prop) {
static_cast<QQuickVisualItemModelPrivate *>(prop->data)->itemCleared(static_cast<QQuickVisualItemModelPrivate *>(prop->data)->children);
static_cast<QQuickVisualItemModelPrivate *>(prop->data)->children.clear();
static_cast<QQuickVisualItemModelPrivate *>(prop->data)->emitChildrenChanged();
static void children_clear(QQmlListProperty<QObject> *prop) {
static_cast<QQmlObjectModelPrivate *>(prop->data)->itemCleared(static_cast<QQmlObjectModelPrivate *>(prop->data)->children);
static_cast<QQmlObjectModelPrivate *>(prop->data)->children.clear();
static_cast<QQmlObjectModelPrivate *>(prop->data)->emitChildrenChanged();
}
void itemAppended() {
Q_Q(QQuickVisualItemModel);
QQuickVisualItemModelAttached *attached = QQuickVisualItemModelAttached::properties(children.last().item);
Q_Q(QQmlObjectModel);
QQmlObjectModelAttached *attached = QQmlObjectModelAttached::properties(children.last().item);
attached->setIndex(children.count()-1);
QQuickChangeSet changeSet;
QQmlChangeSet changeSet;
changeSet.insert(children.count() - 1, 1);
emit q->modelUpdated(changeSet, false);
emit q->countChanged();
}
void itemCleared(const QList<Item> &children) {
Q_Q(QQuickVisualItemModel);
Q_Q(QQmlObjectModel);
foreach (const Item &child, children)
emit q->destroyingItem(child.item);
emit q->countChanged();
}
void emitChildrenChanged() {
Q_Q(QQuickVisualItemModel);
Q_Q(QQmlObjectModel);
emit q->childrenChanged();
}
int indexOf(QQuickItem *item) const {
int indexOf(QObject *item) const {
for (int i = 0; i < children.count(); ++i)
if (children.at(i).item == item)
return i;
@ -131,7 +130,7 @@ public:
/*!
\qmltype VisualItemModel
\instantiates QQuickVisualItemModel
\instantiates QQmlObjectModel
\inqmlmodule QtQuick 2
\ingroup qtquick-models
\brief Defines items to be used added to a view
@ -167,8 +166,8 @@ public:
\sa {quick/modelviews/visualitemmodel}{VisualItemModel example}
*/
QQuickVisualItemModel::QQuickVisualItemModel(QObject *parent)
: QQuickVisualModel(*(new QQuickVisualItemModelPrivate), parent)
QQmlObjectModel::QQmlObjectModel(QObject *parent)
: QQmlInstanceModel(*(new QQmlObjectModelPrivate), parent)
{
}
@ -179,10 +178,10 @@ QQuickVisualItemModel::QQuickVisualItemModel(QObject *parent)
It is attached to each instance of the delegate.
*/
QQmlListProperty<QQuickItem> QQuickVisualItemModel::children()
QQmlListProperty<QObject> QQmlObjectModel::children()
{
Q_D(QQuickVisualItemModel);
return QQmlListProperty<QQuickItem>(this,
Q_D(QQmlObjectModel);
return QQmlListProperty<QObject>(this,
d,
d->children_append,
d->children_count,
@ -195,21 +194,21 @@ QQmlListProperty<QQuickItem> QQuickVisualItemModel::children()
The number of items in the model. This property is readonly.
*/
int QQuickVisualItemModel::count() const
int QQmlObjectModel::count() const
{
Q_D(const QQuickVisualItemModel);
Q_D(const QQmlObjectModel);
return d->children.count();
}
bool QQuickVisualItemModel::isValid() const
bool QQmlObjectModel::isValid() const
{
return true;
}
QQuickItem *QQuickVisualItemModel::item(int index, bool)
QObject *QQmlObjectModel::object(int index, bool)
{
Q_D(QQuickVisualItemModel);
QQuickVisualItemModelPrivate::Item &item = d->children[index];
Q_D(QQmlObjectModel);
QQmlObjectModelPrivate::Item &item = d->children[index];
item.addRef();
if (item.ref == 1) {
emit initItem(index, item.item);
@ -218,38 +217,34 @@ QQuickItem *QQuickVisualItemModel::item(int index, bool)
return item.item;
}
QQuickVisualModel::ReleaseFlags QQuickVisualItemModel::release(QQuickItem *item)
QQmlInstanceModel::ReleaseFlags QQmlObjectModel::release(QObject *item)
{
Q_D(QQuickVisualItemModel);
Q_D(QQmlObjectModel);
int idx = d->indexOf(item);
if (idx >= 0) {
if (d->children[idx].deref()) {
// XXX todo - the original did item->scene()->removeItem(). Why?
item->setParentItem(0);
} else {
return QQuickVisualModel::Referenced;
}
if (!d->children[idx].deref())
return QQmlInstanceModel::Referenced;
}
return 0;
}
QString QQuickVisualItemModel::stringValue(int index, const QString &name)
QString QQmlObjectModel::stringValue(int index, const QString &name)
{
Q_D(QQuickVisualItemModel);
Q_D(QQmlObjectModel);
if (index < 0 || index >= d->children.count())
return QString();
return QQmlEngine::contextForObject(d->children.at(index).item)->contextProperty(name).toString();
}
int QQuickVisualItemModel::indexOf(QQuickItem *item, QObject *) const
int QQmlObjectModel::indexOf(QObject *item, QObject *) const
{
Q_D(const QQuickVisualItemModel);
Q_D(const QQmlObjectModel);
return d->indexOf(item);
}
QQuickVisualItemModelAttached *QQuickVisualItemModel::qmlAttachedProperties(QObject *obj)
QQmlObjectModelAttached *QQmlObjectModel::qmlAttachedProperties(QObject *obj)
{
return QQuickVisualItemModelAttached::properties(obj);
return QQmlObjectModelAttached::properties(obj);
}
QT_END_NAMESPACE

80
src/quick/items/qquickvisualitemmodel_p.h → src/qml/items/qqmlobjectmodel_p.h
View File

@ -39,10 +39,10 @@
**
****************************************************************************/
#ifndef QQUICKVISUALITEMMODEL_P_H
#define QQUICKVISUALITEMMODEL_P_H
#ifndef QQMLINSTANCEMODEL_P_H
#define QQMLINSTANCEMODEL_P_H
#include <private/qtquickglobal_p.h>
#include <private/qtqmlglobal_p.h>
#include <QtQml/qqml.h>
#include <QtCore/qobject.h>
@ -50,88 +50,88 @@ QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
class QQuickItem;
class QQuickChangeSet;
class QObject;
class QQmlChangeSet;
class Q_QUICK_PRIVATE_EXPORT QQuickVisualModel : public QObject
class Q_QML_PRIVATE_EXPORT QQmlInstanceModel : public QObject
{
Q_OBJECT
Q_PROPERTY(int count READ count NOTIFY countChanged)
public:
virtual ~QQuickVisualModel() {}
virtual ~QQmlInstanceModel() {}
enum ReleaseFlag { Referenced = 0x01, Destroyed = 0x02 };
Q_DECLARE_FLAGS(ReleaseFlags, ReleaseFlag)
virtual int count() const = 0;
virtual bool isValid() const = 0;
virtual QQuickItem *item(int index, bool asynchronous=false) = 0;
virtual ReleaseFlags release(QQuickItem *item) = 0;
virtual QObject *object(int index, bool asynchronous=false) = 0;
virtual ReleaseFlags release(QObject *object) = 0;
virtual void cancel(int) {}
virtual QString stringValue(int, const QString &) = 0;
virtual void setWatchedRoles(QList<QByteArray> roles) = 0;
virtual int indexOf(QQuickItem *item, QObject *objectContext) const = 0;
virtual int indexOf(QObject *object, QObject *objectContext) const = 0;
Q_SIGNALS:
void countChanged();
void modelUpdated(const QQuickChangeSet &changeSet, bool reset);
void createdItem(int index, QQuickItem *item);
void initItem(int index, QQuickItem *item);
void destroyingItem(QQuickItem *item);
void modelUpdated(const QQmlChangeSet &changeSet, bool reset);
void createdItem(int index, QObject *object);
void initItem(int index, QObject *object);
void destroyingItem(QObject *object);
protected:
QQuickVisualModel(QObjectPrivate &dd, QObject *parent = 0)
QQmlInstanceModel(QObjectPrivate &dd, QObject *parent = 0)
: QObject(dd, parent) {}
private:
Q_DISABLE_COPY(QQuickVisualModel)
Q_DISABLE_COPY(QQmlInstanceModel)
};
class QQuickVisualItemModelAttached;
class QQuickVisualItemModelPrivate;
class Q_QUICK_PRIVATE_EXPORT QQuickVisualItemModel : public QQuickVisualModel
class QQmlObjectModelAttached;
class QQmlObjectModelPrivate;
class Q_QML_PRIVATE_EXPORT QQmlObjectModel : public QQmlInstanceModel
{
Q_OBJECT
Q_DECLARE_PRIVATE(QQuickVisualItemModel)
Q_DECLARE_PRIVATE(QQmlObjectModel)
Q_PROPERTY(QQmlListProperty<QQuickItem> children READ children NOTIFY childrenChanged DESIGNABLE false)
Q_PROPERTY(QQmlListProperty<QObject> children READ children NOTIFY childrenChanged DESIGNABLE false)
Q_CLASSINFO("DefaultProperty", "children")
public:
QQuickVisualItemModel(QObject *parent=0);
virtual ~QQuickVisualItemModel() {}
QQmlObjectModel(QObject *parent=0);
virtual ~QQmlObjectModel() {}
virtual int count() const;
virtual bool isValid() const;
virtual QQuickItem *item(int index, bool asynchronous=false);
virtual ReleaseFlags release(QQuickItem *item);
virtual QObject *object(int index, bool asynchronous=false);
virtual ReleaseFlags release(QObject *object);
virtual QString stringValue(int index, const QString &role);
virtual void setWatchedRoles(QList<QByteArray>) {}
virtual int indexOf(QQuickItem *item, QObject *objectContext) const;
virtual int indexOf(QObject *object, QObject *objectContext) const;
QQmlListProperty<QQuickItem> children();
QQmlListProperty<QObject> children();
static QQuickVisualItemModelAttached *qmlAttachedProperties(QObject *obj);
static QQmlObjectModelAttached *qmlAttachedProperties(QObject *obj);
Q_SIGNALS:
void childrenChanged();
private:
Q_DISABLE_COPY(QQuickVisualItemModel)
Q_DISABLE_COPY(QQmlObjectModel)
};
class QQuickVisualItemModelAttached : public QObject
class QQmlObjectModelAttached : public QObject
{
Q_OBJECT
public:
QQuickVisualItemModelAttached(QObject *parent)
QQmlObjectModelAttached(QObject *parent)
: QObject(parent), m_index(0) {}
~QQuickVisualItemModelAttached() {
~QQmlObjectModelAttached() {
attachedProperties.remove(parent());
}
@ -144,10 +144,10 @@ public:
}
}
static QQuickVisualItemModelAttached *properties(QObject *obj) {
QQuickVisualItemModelAttached *rv = attachedProperties.value(obj);
static QQmlObjectModelAttached *properties(QObject *obj) {
QQmlObjectModelAttached *rv = attachedProperties.value(obj);
if (!rv) {
rv = new QQuickVisualItemModelAttached(obj);
rv = new QQmlObjectModelAttached(obj);
attachedProperties.insert(obj, rv);
}
return rv;
@ -159,16 +159,16 @@ Q_SIGNALS:
public:
int m_index;
static QHash<QObject*, QQuickVisualItemModelAttached*> attachedProperties;
static QHash<QObject*, QQmlObjectModelAttached*> attachedProperties;
};
QT_END_NAMESPACE
QML_DECLARE_TYPE(QQuickVisualModel)
QML_DECLARE_TYPE(QQuickVisualItemModel)
QML_DECLARE_TYPEINFO(QQuickVisualItemModel, QML_HAS_ATTACHED_PROPERTIES)
QML_DECLARE_TYPE(QQmlInstanceModel)
QML_DECLARE_TYPE(QQmlObjectModel)
QML_DECLARE_TYPEINFO(QQmlObjectModel, QML_HAS_ATTACHED_PROPERTIES)
QT_END_HEADER
#endif // QQUICKVISUALITEMMODEL_P_H
#endif // QQMLINSTANCEMODEL_P_H

0
src/quick/util/qquickpackage.cpp → src/qml/items/qquickpackage.cpp
View File

0
src/quick/util/qquickpackage_p.h → src/qml/items/qquickpackage_p.h
View File

1
src/qml/qml.pro
View File

@ -25,3 +25,4 @@ include(util/util.pri)
include(qml/qml.pri)
include(debugger/debugger.pri)
include(animations/animations.pri)
include(items/items.pri)

8
src/qml/qml/qqmlengine.cpp
View File

@ -92,6 +92,9 @@
#include "qqmlbind_p.h"
#include "qqmlconnections_p.h"
#include "qqmltimer_p.h"
#include <private/qquickpackage_p.h>
#include <private/qqmldelegatemodel_p.h>
#include <private/qqmlobjectmodel_p.h>
#ifdef Q_OS_WIN // for %APPDATA%
#include <qt_windows.h>
@ -189,6 +192,11 @@ void QQmlEnginePrivate::registerBaseTypes(const char *uri, int versionMajor, int
void QQmlEnginePrivate::registerQtQuick2Types(const char *uri, int versionMajor, int versionMinor)
{
qmlRegisterType<QQuickWorkerScript>(uri, versionMajor, versionMinor, "WorkerScript");
qmlRegisterType<QQuickPackage>(uri, versionMajor, versionMinor, "Package");
qmlRegisterType<QQmlDelegateModel>(uri, versionMajor, versionMinor, "VisualDataModel");
qmlRegisterType<QQmlDataGroup>(uri, versionMajor, versionMinor, "VisualDataGroup");
qmlRegisterType<QQmlObjectModel>(uri, versionMajor, versionMinor, "VisualItemModel");
qmlRegisterType<QQmlInstanceModel>();
}
void QQmlEnginePrivate::defineQtQuick2Module()

236
src/quick/items/qquickvisualadaptormodel.cpp → src/qml/util/qqmladaptormodel.cpp
View File

@ -39,16 +39,16 @@
**
****************************************************************************/
#include "qquickvisualadaptormodel_p.h"
#include "qquickvisualdatamodel_p_p.h"
#include "qqmladaptormodel_p.h"
#include <private/qqmldelegatemodel_p_p.h>
#include <private/qmetaobjectbuilder_p.h>
#include <private/qqmlproperty_p.h>
#include <private/qv8engine_p.h>
QT_BEGIN_NAMESPACE
class QQuickVisualAdaptorModelEngineData : public QV8Engine::Deletable
class QQmlAdaptorModelEngineData : public QV8Engine::Deletable
{
public:
enum
@ -59,8 +59,8 @@ public:
StringCount
};
QQuickVisualAdaptorModelEngineData(QV8Engine *engine);
~QQuickVisualAdaptorModelEngineData();
QQmlAdaptorModelEngineData(QV8Engine *engine);
~QQmlAdaptorModelEngineData();
v8::Local<v8::String> index() { return strings->Get(Index)->ToString(); }
v8::Local<v8::String> modelData() { return strings->Get(ModelData)->ToString(); }
@ -70,11 +70,11 @@ public:
v8::Persistent<v8::Array> strings;
};
V8_DEFINE_EXTENSION(QQuickVisualAdaptorModelEngineData, engineData)
V8_DEFINE_EXTENSION(QQmlAdaptorModelEngineData, engineData)
static v8::Handle<v8::Value> get_index(v8::Local<v8::String>, const v8::AccessorInfo &info)
{
QQuickVisualDataModelItem *data = v8_resource_cast<QQuickVisualDataModelItem>(info.This());
QQmlDelegateModelItem *data = v8_resource_cast<QQmlDelegateModelItem>(info.This());
V8ASSERT_TYPE(data, "Not a valid VisualData object");
return v8::Int32::New(data->index);
@ -99,11 +99,11 @@ static void addProperty(QMetaObjectBuilder *builder, int propertyId, const QByte
class VDMModelDelegateDataType;
class QQuickVDMCachedModelData : public QQuickVisualDataModelItem
class QQmlDMCachedModelData : public QQmlDelegateModelItem
{
public:
QQuickVDMCachedModelData(
QQuickVisualDataModelItemMetaType *metaType,
QQmlDMCachedModelData(
QQmlDelegateModelItemMetaType *metaType,
VDMModelDelegateDataType *dataType,
int index);
@ -113,7 +113,7 @@ public:
virtual void setValue(int role, const QVariant &value) = 0;
void setValue(const QString &role, const QVariant &value);
bool resolveIndex(const QQuickVisualAdaptorModel &model, int idx);
bool resolveIndex(const QQmlAdaptorModel &model, int idx);
static v8::Handle<v8::Value> get_property(v8::Local<v8::String>, const v8::AccessorInfo &info);
static void set_property(
@ -125,11 +125,11 @@ public:
class VDMModelDelegateDataType
: public QQmlRefCount
, public QQuickVisualAdaptorModel::Accessors
, public QQmlAdaptorModel::Accessors
, public QAbstractDynamicMetaObject
{
public:
VDMModelDelegateDataType(QQuickVisualAdaptorModel *model)
VDMModelDelegateDataType(QQmlAdaptorModel *model)
: model(model)
, metaObject(0)
, propertyCache(0)
@ -149,8 +149,8 @@ public:
}
bool notify(
const QQuickVisualAdaptorModel &,
const QList<QQuickVisualDataModelItem *> &items,
const QQmlAdaptorModel &,
const QList<QQmlDelegateModelItem *> &items,
int index,
int count,
const QVector<int> &roles) const
@ -182,7 +182,7 @@ public:
}
for (int i = 0, c = items.count(); i < c; ++i) {
QQuickVisualDataModelItem *item = items.at(i);
QQmlDelegateModelItem *item = items.at(i);
const int idx = item->modelIndex();
if (idx >= index && idx < index + count) {
for (int i = 0; i < signalIndexes.count(); ++i)
@ -193,7 +193,7 @@ public:
}
void replaceWatchedRoles(
QQuickVisualAdaptorModel &,
QQmlAdaptorModel &,
const QList<QByteArray> &oldRoles,
const QList<QByteArray> &newRoles) const
{
@ -205,7 +205,7 @@ public:
dataType->watchedRoles += newRoles;
}
void initializeConstructor(QQuickVisualAdaptorModelEngineData *const data)
void initializeConstructor(QQmlAdaptorModelEngineData *const data)
{
constructor = qPersistentNew(v8::ObjectTemplate::New());
constructor->SetHasExternalResource(true);
@ -218,8 +218,8 @@ public:
constructor->SetAccessor(
v8::String::New(propertyName.constData(), propertyName.length()),
QQuickVDMCachedModelData::get_property,
QQuickVDMCachedModelData::set_property,
QQmlDMCachedModelData::get_property,
QQmlDMCachedModelData::set_property,
v8::Int32::New(propertyId));
}
}
@ -233,7 +233,7 @@ public:
int metaCall(QObject *object, QMetaObject::Call call, int id, void **arguments)
{
return static_cast<QQuickVDMCachedModelData *>(object)->metaCall(call, id, arguments);
return static_cast<QQmlDMCachedModelData *>(object)->metaCall(call, id, arguments);
}
v8::Persistent<v8::ObjectTemplate> constructor;
@ -241,7 +241,7 @@ public:
QList<int> watchedRoleIds;
QList<QByteArray> watchedRoles;
QHash<QByteArray, int> roleNames;
QQuickVisualAdaptorModel *model;
QQmlAdaptorModel *model;
QMetaObject *metaObject;
QQmlPropertyCache *propertyCache;
int propertyOffset;
@ -249,9 +249,9 @@ public:
bool hasModelData;
};
QQuickVDMCachedModelData::QQuickVDMCachedModelData(
QQuickVisualDataModelItemMetaType *metaType, VDMModelDelegateDataType *dataType, int index)
: QQuickVisualDataModelItem(metaType, index)
QQmlDMCachedModelData::QQmlDMCachedModelData(
QQmlDelegateModelItemMetaType *metaType, VDMModelDelegateDataType *dataType, int index)
: QQmlDelegateModelItem(metaType, index)
, type(dataType)
{
if (index == -1)
@ -266,7 +266,7 @@ QQuickVDMCachedModelData::QQuickVDMCachedModelData(
qmldata->propertyCache->addref();
}
int QQuickVDMCachedModelData::metaCall(QMetaObject::Call call, int id, void **arguments)
int QQmlDMCachedModelData::metaCall(QMetaObject::Call call, int id, void **arguments)
{
if (call == QMetaObject::ReadProperty && id >= type->propertyOffset) {
const int propertyIndex = id - type->propertyOffset;
@ -300,7 +300,7 @@ int QQuickVDMCachedModelData::metaCall(QMetaObject::Call call, int id, void **ar
}
}
void QQuickVDMCachedModelData::setValue(const QString &role, const QVariant &value)
void QQmlDMCachedModelData::setValue(const QString &role, const QVariant &value)
{
QHash<QByteArray, int>::iterator it = type->roleNames.find(role.toUtf8());
if (it != type->roleNames.end()) {
@ -313,7 +313,7 @@ void QQuickVDMCachedModelData::setValue(const QString &role, const QVariant &val
}
}
bool QQuickVDMCachedModelData::resolveIndex(const QQuickVisualAdaptorModel &, int idx)
bool QQmlDMCachedModelData::resolveIndex(const QQmlAdaptorModel &, int idx)
{
if (index == -1) {
Q_ASSERT(idx >= 0);
@ -330,13 +330,13 @@ bool QQuickVDMCachedModelData::resolveIndex(const QQuickVisualAdaptorModel &, in
}
}
v8::Handle<v8::Value> QQuickVDMCachedModelData::get_property(
v8::Handle<v8::Value> QQmlDMCachedModelData::get_property(
v8::Local<v8::String>, const v8::AccessorInfo &info)
{
QQuickVisualDataModelItem *data = v8_resource_cast<QQuickVisualDataModelItem>(info.This());
QQmlDelegateModelItem *data = v8_resource_cast<QQmlDelegateModelItem>(info.This());
V8ASSERT_TYPE(data, "Not a valid VisualData object");
QQuickVDMCachedModelData *modelData = static_cast<QQuickVDMCachedModelData *>(data);
QQmlDMCachedModelData *modelData = static_cast<QQmlDMCachedModelData *>(data);
const int propertyId = info.Data()->Int32Value();
if (data->index == -1) {
if (!modelData->cachedData.isEmpty()) {
@ -350,15 +350,15 @@ v8::Handle<v8::Value> QQuickVDMCachedModelData::get_property(
return v8::Undefined();
}
void QQuickVDMCachedModelData::set_property(
void QQmlDMCachedModelData::set_property(
v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
{
QQuickVisualDataModelItem *data = v8_resource_cast<QQuickVisualDataModelItem>(info.This());
QQmlDelegateModelItem *data = v8_resource_cast<QQmlDelegateModelItem>(info.This());
V8ASSERT_TYPE_SETTER(data, "Not a valid VisualData object");
const int propertyId = info.Data()->Int32Value();
if (data->index == -1) {
QQuickVDMCachedModelData *modelData = static_cast<QQuickVDMCachedModelData *>(data);
QQmlDMCachedModelData *modelData = static_cast<QQmlDMCachedModelData *>(data);
if (!modelData->cachedData.isEmpty()) {
if (modelData->cachedData.count() > 1) {
modelData->cachedData[propertyId] = data->engine->toVariant(value, QVariant::Invalid);
@ -376,16 +376,16 @@ void QQuickVDMCachedModelData::set_property(
// QAbstractItemModel
//-----------------------------------------------------------------
class QQuickVDMAbstractItemModelData : public QQuickVDMCachedModelData
class QQmlDMAbstractItemModelData : public QQmlDMCachedModelData
{
Q_OBJECT
Q_PROPERTY(bool hasModelChildren READ hasModelChildren CONSTANT)
public:
QQuickVDMAbstractItemModelData(
QQuickVisualDataModelItemMetaType *metaType,
QQmlDMAbstractItemModelData(
QQmlDelegateModelItemMetaType *metaType,
VDMModelDelegateDataType *dataType,
int index)
: QQuickVDMCachedModelData(metaType, dataType, index)
: QQmlDMCachedModelData(metaType, dataType, index)
{
}
@ -413,7 +413,7 @@ public:
v8::Handle<v8::Value> get()
{
if (type->constructor.IsEmpty()) {
QQuickVisualAdaptorModelEngineData * const data = engineData(engine);
QQmlAdaptorModelEngineData * const data = engineData(engine);
v8::HandleScope handleScope;
v8::Context::Scope contextScope(engine->context());
type->initializeConstructor(data);
@ -427,10 +427,10 @@ public:
static v8::Handle<v8::Value> get_hasModelChildren(v8::Local<v8::String>, const v8::AccessorInfo &info)
{
QQuickVisualDataModelItem *data = v8_resource_cast<QQuickVisualDataModelItem>(info.This());
QQmlDelegateModelItem *data = v8_resource_cast<QQmlDelegateModelItem>(info.This());
V8ASSERT_TYPE(data, "Not a valid VisualData object");
const QQuickVisualAdaptorModel *const model = static_cast<QQuickVDMCachedModelData *>(data)->type->model;
const QQmlAdaptorModel *const model = static_cast<QQmlDMCachedModelData *>(data)->type->model;
if (data->index >= 0 && *model) {
const QAbstractItemModel * const aim = model->aim();
return v8::Boolean::New(aim->hasChildren(aim->index(data->index, 0, model->rootIndex)));
@ -443,17 +443,17 @@ public:
class VDMAbstractItemModelDataType : public VDMModelDelegateDataType
{
public:
VDMAbstractItemModelDataType(QQuickVisualAdaptorModel *model)
VDMAbstractItemModelDataType(QQmlAdaptorModel *model)
: VDMModelDelegateDataType(model)
{
}
int count(const QQuickVisualAdaptorModel &model) const
int count(const QQmlAdaptorModel &model) const
{
return model.aim()->rowCount(model.rootIndex);
}
void cleanup(QQuickVisualAdaptorModel &model, QQuickVisualDataModel *vdm) const
void cleanup(QQmlAdaptorModel &model, QQmlDelegateModel *vdm) const
{
QAbstractItemModel * const aim = model.aim();
if (aim && vdm) {
@ -476,7 +476,7 @@ public:
const_cast<VDMAbstractItemModelDataType *>(this)->release();
}
QVariant value(const QQuickVisualAdaptorModel &model, int index, const QString &role) const
QVariant value(const QQmlAdaptorModel &model, int index, const QString &role) const
{
QHash<QByteArray, int>::const_iterator it = roleNames.find(role.toUtf8());
if (it != roleNames.end()) {
@ -488,47 +488,47 @@ public:
}
}
QVariant parentModelIndex(const QQuickVisualAdaptorModel &model) const
QVariant parentModelIndex(const QQmlAdaptorModel &model) const
{
return model
? QVariant::fromValue(model.aim()->parent(model.rootIndex))
: QVariant();
}
QVariant modelIndex(const QQuickVisualAdaptorModel &model, int index) const
QVariant modelIndex(const QQmlAdaptorModel &model, int index) const
{
return model
? QVariant::fromValue(model.aim()->index(index, 0, model.rootIndex))
: QVariant();
}
bool canFetchMore(const QQuickVisualAdaptorModel &model) const
bool canFetchMore(const QQmlAdaptorModel &model) const
{
return model && model.aim()->canFetchMore(model.rootIndex);
}
void fetchMore(QQuickVisualAdaptorModel &model) const
void fetchMore(QQmlAdaptorModel &model) const
{
if (model)
model.aim()->fetchMore(model.rootIndex);
}
QQuickVisualDataModelItem *createItem(
QQuickVisualAdaptorModel &model,
QQuickVisualDataModelItemMetaType *metaType,
QQmlDelegateModelItem *createItem(
QQmlAdaptorModel &model,
QQmlDelegateModelItemMetaType *metaType,
QQmlEngine *engine,
int index) const
{
VDMAbstractItemModelDataType *dataType = const_cast<VDMAbstractItemModelDataType *>(this);
if (!metaObject)
dataType->initializeMetaType(model, engine);
return new QQuickVDMAbstractItemModelData(metaType, dataType, index);
return new QQmlDMAbstractItemModelData(metaType, dataType, index);
}
void initializeMetaType(QQuickVisualAdaptorModel &model, QQmlEngine *engine)
void initializeMetaType(QQmlAdaptorModel &model, QQmlEngine *engine)
{
QMetaObjectBuilder builder;
setModelDataType<QQuickVDMAbstractItemModelData>(&builder, this);
setModelDataType<QQmlDMAbstractItemModelData>(&builder, this);
const QByteArray propertyType = QByteArrayLiteral("QVariant");
const QHash<int, QByteArray> names = model.aim()->roleNames();
@ -555,16 +555,16 @@ public:
};
//-----------------------------------------------------------------
// QQuickListAccessor
// QQmlListAccessor
//-----------------------------------------------------------------
class QQuickVDMListAccessorData : public QQuickVisualDataModelItem
class QQmlDMListAccessorData : public QQmlDelegateModelItem
{
Q_OBJECT
Q_PROPERTY(QVariant modelData READ modelData WRITE setModelData NOTIFY modelDataChanged)
public:
QQuickVDMListAccessorData(QQuickVisualDataModelItemMetaType *metaType, int index, const QVariant &value)
: QQuickVisualDataModelItem(metaType, index)
QQmlDMListAccessorData(QQmlDelegateModelItemMetaType *metaType, int index, const QVariant &value)
: QQmlDelegateModelItem(metaType, index)
, cachedData(value)
{
}
@ -584,18 +584,18 @@ public:
static v8::Handle<v8::Value> get_modelData(v8::Local<v8::String>, const v8::AccessorInfo &info)
{
QQuickVisualDataModelItem *data = v8_resource_cast<QQuickVisualDataModelItem>(info.This());
QQmlDelegateModelItem *data = v8_resource_cast<QQmlDelegateModelItem>(info.This());
V8ASSERT_TYPE(data, "Not a valid VisualData object");
return data->engine->fromVariant(static_cast<QQuickVDMListAccessorData *>(data)->cachedData);
return data->engine->fromVariant(static_cast<QQmlDMListAccessorData *>(data)->cachedData);
}
static void set_modelData(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
{
QQuickVisualDataModelItem *data = v8_resource_cast<QQuickVisualDataModelItem>(info.This());
QQmlDelegateModelItem *data = v8_resource_cast<QQmlDelegateModelItem>(info.This());
V8ASSERT_TYPE_SETTER(data, "Not a valid VisualData object");
static_cast<QQuickVDMListAccessorData *>(data)->setModelData(
static_cast<QQmlDMListAccessorData *>(data)->setModelData(
data->engine->toVariant(value, QVariant::Invalid));
}
@ -613,7 +613,7 @@ public:
cachedData = value;
}
bool resolveIndex(const QQuickVisualAdaptorModel &model, int idx)
bool resolveIndex(const QQmlAdaptorModel &model, int idx)
{
if (index == -1) {
index = idx;
@ -635,30 +635,30 @@ private:
};
class VDMListDelegateDataType : public QQuickVisualAdaptorModel::Accessors
class VDMListDelegateDataType : public QQmlAdaptorModel::Accessors
{
public:
inline VDMListDelegateDataType() {}
int count(const QQuickVisualAdaptorModel &model) const
int count(const QQmlAdaptorModel &model) const
{
return model.list.count();
}
QVariant value(const QQuickVisualAdaptorModel &model, int index, const QString &role) const
QVariant value(const QQmlAdaptorModel &model, int index, const QString &role) const
{
return role == QLatin1String("modelData")
? model.list.at(index)
: QVariant();
}
QQuickVisualDataModelItem *createItem(
QQuickVisualAdaptorModel &model,
QQuickVisualDataModelItemMetaType *metaType,
QQmlDelegateModelItem *createItem(
QQmlAdaptorModel &model,
QQmlDelegateModelItemMetaType *metaType,
QQmlEngine *,
int index) const
{
return new QQuickVDMListAccessorData(
return new QQmlDMListAccessorData(
metaType,
index,
index >= 0 && index < model.list.count() ? model.list.at(index) : QVariant());
@ -670,14 +670,14 @@ public:
//-----------------------------------------------------------------
class VDMObjectDelegateDataType;
class QQuickVDMObjectData : public QQuickVisualDataModelItem, public QQuickVisualAdaptorModelProxyInterface
class QQmlDMObjectData : public QQmlDelegateModelItem, public QQmlAdaptorModelProxyInterface
{
Q_OBJECT
Q_PROPERTY(QObject *modelData READ modelData CONSTANT)
Q_INTERFACES(QQuickVisualAdaptorModelProxyInterface)
Q_INTERFACES(QQmlAdaptorModelProxyInterface)
public:
QQuickVDMObjectData(
QQuickVisualDataModelItemMetaType *metaType,
QQmlDMObjectData(
QQmlDelegateModelItemMetaType *metaType,
VDMObjectDelegateDataType *dataType,
int index,
QObject *object);
@ -688,7 +688,7 @@ public:
QQmlGuard<QObject> object;
};
class VDMObjectDelegateDataType : public QQmlRefCount, public QQuickVisualAdaptorModel::Accessors
class VDMObjectDelegateDataType : public QQmlRefCount, public QQmlAdaptorModel::Accessors
{
public:
QMetaObject *metaObject;
@ -707,7 +707,7 @@ public:
VDMObjectDelegateDataType(const VDMObjectDelegateDataType &type)
: QQmlRefCount()
, QQuickVisualAdaptorModel::Accessors()
, QQmlAdaptorModel::Accessors()
, metaObject(0)
, propertyOffset(type.propertyOffset)
, signalOffset(type.signalOffset)
@ -725,21 +725,21 @@ public:
free(metaObject);
}
int count(const QQuickVisualAdaptorModel &model) const
int count(const QQmlAdaptorModel &model) const
{
return model.list.count();
}
QVariant value(const QQuickVisualAdaptorModel &model, int index, const QString &role) const
QVariant value(const QQmlAdaptorModel &model, int index, const QString &role) const
{
if (QObject *object = model.list.at(index).value<QObject *>())
return object->property(role.toUtf8());
return QVariant();
}
QQuickVisualDataModelItem *createItem(
QQuickVisualAdaptorModel &model,
QQuickVisualDataModelItemMetaType *metaType,
QQmlDelegateModelItem *createItem(
QQmlAdaptorModel &model,
QQmlDelegateModelItemMetaType *metaType,
QQmlEngine *,
int index) const
{
@ -747,27 +747,27 @@ public:
if (!metaObject)
dataType->initializeMetaType(model);
return index >= 0 && index < model.list.count()
? new QQuickVDMObjectData(metaType, dataType, index, qvariant_cast<QObject *>(model.list.at(index)))
? new QQmlDMObjectData(metaType, dataType, index, qvariant_cast<QObject *>(model.list.at(index)))
: 0;
}
void initializeMetaType(QQuickVisualAdaptorModel &)
void initializeMetaType(QQmlAdaptorModel &)
{
setModelDataType<QQuickVDMObjectData>(&builder, this);
setModelDataType<QQmlDMObjectData>(&builder, this);
metaObject = builder.toMetaObject();
}
void cleanup(QQuickVisualAdaptorModel &, QQuickVisualDataModel *) const
void cleanup(QQmlAdaptorModel &, QQmlDelegateModel *) const
{
const_cast<VDMObjectDelegateDataType *>(this)->release();
}
};
class QQuickVDMObjectDataMetaObject : public QAbstractDynamicMetaObject
class QQmlDMObjectDataMetaObject : public QAbstractDynamicMetaObject
{
public:
QQuickVDMObjectDataMetaObject(QQuickVDMObjectData *data, VDMObjectDelegateDataType *type)
QQmlDMObjectDataMetaObject(QQmlDMObjectData *data, VDMObjectDelegateDataType *type)
: m_data(data)
, m_type(type)
{
@ -777,7 +777,7 @@ public:
m_type->addref();
}
~QQuickVDMObjectDataMetaObject()
~QQmlDMObjectDataMetaObject()
{
m_type->release();
}
@ -854,43 +854,43 @@ public:
return propertyIndex + m_type->propertyOffset - objectPropertyOffset;
}
QQuickVDMObjectData *m_data;
QQmlDMObjectData *m_data;
VDMObjectDelegateDataType *m_type;
};
QQuickVDMObjectData::QQuickVDMObjectData(
QQuickVisualDataModelItemMetaType *metaType,
QQmlDMObjectData::QQmlDMObjectData(
QQmlDelegateModelItemMetaType *metaType,
VDMObjectDelegateDataType *dataType,
int index,
QObject *object)
: QQuickVisualDataModelItem(metaType, index)
: QQmlDelegateModelItem(metaType, index)
, object(object)
{
new QQuickVDMObjectDataMetaObject(this, dataType);
new QQmlDMObjectDataMetaObject(this, dataType);
}
//-----------------------------------------------------------------
// QQuickVisualAdaptorModel
// QQmlAdaptorModel
//-----------------------------------------------------------------
static const QQuickVisualAdaptorModel::Accessors qt_vdm_null_accessors;
static const QQmlAdaptorModel::Accessors qt_vdm_null_accessors;
static const VDMListDelegateDataType qt_vdm_list_accessors;
QQuickVisualAdaptorModel::Accessors::~Accessors()
QQmlAdaptorModel::Accessors::~Accessors()
{
}
QQuickVisualAdaptorModel::QQuickVisualAdaptorModel()
QQmlAdaptorModel::QQmlAdaptorModel()
: accessors(&qt_vdm_null_accessors)
{
}
QQuickVisualAdaptorModel::~QQuickVisualAdaptorModel()
QQmlAdaptorModel::~QQmlAdaptorModel()
{
accessors->cleanup(*this);
}
void QQuickVisualAdaptorModel::setModel(const QVariant &variant, QQuickVisualDataModel *vdm, QQmlEngine *engine)
void QQmlAdaptorModel::setModel(const QVariant &variant, QQmlDelegateModel *vdm, QQmlEngine *engine)
{
accessors->cleanup(*this, vdm);
@ -902,27 +902,27 @@ void QQuickVisualAdaptorModel::setModel(const QVariant &variant, QQuickVisualDat
accessors = new VDMAbstractItemModelDataType(this);
qmlobject_connect(model, QAbstractItemModel, SIGNAL(rowsInserted(QModelIndex,int,int)),
vdm, QQuickVisualDataModel, SLOT(_q_rowsInserted(QModelIndex,int,int)));
vdm, QQmlDelegateModel, SLOT(_q_rowsInserted(QModelIndex,int,int)));
qmlobject_connect(model, QAbstractItemModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
vdm, QQuickVisualDataModel, SLOT(_q_rowsRemoved(QModelIndex,int,int)));
vdm, QQmlDelegateModel, SLOT(_q_rowsRemoved(QModelIndex,int,int)));
qmlobject_connect(model, QAbstractItemModel, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
vdm, QQuickVisualDataModel, SLOT(_q_rowsAboutToBeRemoved(QModelIndex,int,int)));
vdm, QQmlDelegateModel, SLOT(_q_rowsAboutToBeRemoved(QModelIndex,int,int)));
qmlobject_connect(model, QAbstractItemModel, SIGNAL(dataChanged(QModelIndex,QModelIndex,QVector<int>)),
vdm, QQuickVisualDataModel, SLOT(_q_dataChanged(QModelIndex,QModelIndex,QVector<int>)));
vdm, QQmlDelegateModel, SLOT(_q_dataChanged(QModelIndex,QModelIndex,QVector<int>)));
qmlobject_connect(model, QAbstractItemModel, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)),
vdm, QQuickVisualDataModel, SLOT(_q_rowsMoved(QModelIndex,int,int,QModelIndex,int)));
vdm, QQmlDelegateModel, SLOT(_q_rowsMoved(QModelIndex,int,int,QModelIndex,int)));
qmlobject_connect(model, QAbstractItemModel, SIGNAL(modelReset()),
vdm, QQuickVisualDataModel, SLOT(_q_modelReset()));
vdm, QQmlDelegateModel, SLOT(_q_modelReset()));
qmlobject_connect(model, QAbstractItemModel, SIGNAL(layoutChanged()),
vdm, QQuickVisualDataModel, SLOT(_q_layoutChanged()));
vdm, QQmlDelegateModel, SLOT(_q_layoutChanged()));
} else {
accessors = new VDMObjectDelegateDataType;
}
} else if (list.type() == QQuickListAccessor::ListProperty) {
} else if (list.type() == QQmlListAccessor::ListProperty) {
setObject(static_cast<const QQmlListReference *>(variant.constData())->object());
accessors = new VDMObjectDelegateDataType;
} else if (list.type() != QQuickListAccessor::Invalid) {
Q_ASSERT(list.type() != QQuickListAccessor::Instance); // Should have cast to QObject.
} else if (list.type() != QQmlListAccessor::Invalid) {
Q_ASSERT(list.type() != QQmlListAccessor::Instance); // Should have cast to QObject.
setObject(0);
accessors = &qt_vdm_list_accessors;
} else {
@ -931,7 +931,7 @@ void QQuickVisualAdaptorModel::setModel(const QVariant &variant, QQuickVisualDat
}
}
void QQuickVisualAdaptorModel::invalidateModel(QQuickVisualDataModel *vdm)
void QQmlAdaptorModel::invalidateModel(QQmlDelegateModel *vdm)
{
accessors->cleanup(*this, vdm);
accessors = &qt_vdm_null_accessors;
@ -939,17 +939,17 @@ void QQuickVisualAdaptorModel::invalidateModel(QQuickVisualDataModel *vdm)
// object is destroyed.
}
bool QQuickVisualAdaptorModel::isValid() const
bool QQmlAdaptorModel::isValid() const
{
return accessors != &qt_vdm_null_accessors;
}
void QQuickVisualAdaptorModel::objectDestroyed(QObject *)
void QQmlAdaptorModel::objectDestroyed(QObject *)
{
setModel(QVariant(), 0, 0);
}
QQuickVisualAdaptorModelEngineData::QQuickVisualAdaptorModelEngineData(QV8Engine *)
QQmlAdaptorModelEngineData::QQmlAdaptorModelEngineData(QV8Engine *)
{
strings = qPersistentNew(v8::Array::New(StringCount));
strings->Set(Index, v8::String::New("index"));
@ -961,12 +961,12 @@ QQuickVisualAdaptorModelEngineData::QQuickVisualAdaptorModelEngineData(QV8Engine
listItem->InstanceTemplate()->SetAccessor(index(), get_index);
listItem->InstanceTemplate()->SetAccessor(
modelData(),
QQuickVDMListAccessorData::get_modelData,
QQuickVDMListAccessorData::set_modelData);
QQmlDMListAccessorData::get_modelData,
QQmlDMListAccessorData::set_modelData);
constructorListItem = qPersistentNew(listItem->GetFunction());
}
QQuickVisualAdaptorModelEngineData::~QQuickVisualAdaptorModelEngineData()
QQmlAdaptorModelEngineData::~QQmlAdaptorModelEngineData()
{
qPersistentDispose(constructorListItem);
qPersistentDispose(strings);
@ -974,4 +974,4 @@ QQuickVisualAdaptorModelEngineData::~QQuickVisualAdaptorModelEngineData()
QT_END_NAMESPACE
#include <qquickvisualadaptormodel.moc>
#include <qqmladaptormodel.moc>

64
src/quick/items/qquickvisualadaptormodel_p.h → src/qml/util/qqmladaptormodel_p.h
View File

@ -39,12 +39,12 @@
**
****************************************************************************/
#ifndef QQUICKVISUALADAPTORMODEL_P_H
#define QQUICKVISUALADAPTORMODEL_P_H
#ifndef QQMLADAPTORMODEL_P_H
#define QQMLADAPTORMODEL_P_H
#include <QtCore/qabstractitemmodel.h>
#include "private/qquicklistaccessor_p.h"
#include "private/qqmllistaccessor_p.h"
#include <private/qqmlguard_p.h>
@ -54,11 +54,11 @@ QT_BEGIN_NAMESPACE
class QQmlEngine;
class QQuickVisualDataModel;
class QQuickVisualDataModelItem;
class QQuickVisualDataModelItemMetaType;
class QQmlDelegateModel;
class QQmlDelegateModelItem;
class QQmlDelegateModelItemMetaType;
class QQuickVisualAdaptorModel : public QQmlGuard<QObject>
class QQmlAdaptorModel : public QQmlGuard<QObject>
{
public:
class Accessors
@ -66,46 +66,46 @@ public:
public:
inline Accessors() {}
virtual ~Accessors();
virtual int count(const QQuickVisualAdaptorModel &) const { return 0; }
virtual void cleanup(QQuickVisualAdaptorModel &, QQuickVisualDataModel * = 0) const {}
virtual int count(const QQmlAdaptorModel &) const { return 0; }
virtual void cleanup(QQmlAdaptorModel &, QQmlDelegateModel * = 0) const {}
virtual QVariant value(const QQuickVisualAdaptorModel &, int, const QString &) const {
virtual QVariant value(const QQmlAdaptorModel &, int, const QString &) const {
return QVariant(); }
virtual QQuickVisualDataModelItem *createItem(
QQuickVisualAdaptorModel &,
QQuickVisualDataModelItemMetaType *,
virtual QQmlDelegateModelItem *createItem(
QQmlAdaptorModel &,
QQmlDelegateModelItemMetaType *,
QQmlEngine *,
int) const { return 0; }
virtual bool notify(
const QQuickVisualAdaptorModel &,
const QList<QQuickVisualDataModelItem *> &,
const QQmlAdaptorModel &,
const QList<QQmlDelegateModelItem *> &,
int,
int,
const QVector<int> &) const { return false; }
virtual void replaceWatchedRoles(
QQuickVisualAdaptorModel &,
QQmlAdaptorModel &,
const QList<QByteArray> &,
const QList<QByteArray> &) const {}
virtual QVariant parentModelIndex(const QQuickVisualAdaptorModel &) const {
virtual QVariant parentModelIndex(const QQmlAdaptorModel &) const {
return QVariant(); }
virtual QVariant modelIndex(const QQuickVisualAdaptorModel &, int) const {
virtual QVariant modelIndex(const QQmlAdaptorModel &, int) const {
return QVariant(); }
virtual bool canFetchMore(const QQuickVisualAdaptorModel &) const { return false; }
virtual void fetchMore(QQuickVisualAdaptorModel &) const {}
virtual bool canFetchMore(const QQmlAdaptorModel &) const { return false; }
virtual void fetchMore(QQmlAdaptorModel &) const {}
};
const Accessors *accessors;
QPersistentModelIndex rootIndex;
QQuickListAccessor list;
QQmlListAccessor list;
QQuickVisualAdaptorModel();
~QQuickVisualAdaptorModel();
QQmlAdaptorModel();
~QQmlAdaptorModel();
inline QVariant model() const { return list.list(); }
void setModel(const QVariant &variant, QQuickVisualDataModel *vdm, QQmlEngine *engine);
void invalidateModel(QQuickVisualDataModel *vdm);
void setModel(const QVariant &variant, QQmlDelegateModel *vdm, QQmlEngine *engine);
void invalidateModel(QQmlDelegateModel *vdm);
bool isValid() const;
@ -115,13 +115,13 @@ public:
inline int count() const { return qMax(0, accessors->count(*this)); }
inline QVariant value(int index, const QString &role) const {
return accessors->value(*this, index, role); }
inline QQuickVisualDataModelItem *createItem(QQuickVisualDataModelItemMetaType *metaType, QQmlEngine *engine, int index) {
inline QQmlDelegateModelItem *createItem(QQmlDelegateModelItemMetaType *metaType, QQmlEngine *engine, int index) {
return accessors->createItem(*this, metaType, engine, index); }
inline bool hasProxyObject() const {
return list.type() == QQuickListAccessor::Instance || list.type() == QQuickListAccessor::ListProperty; }
return list.type() == QQmlListAccessor::Instance || list.type() == QQmlListAccessor::ListProperty; }
inline bool notify(
const QList<QQuickVisualDataModelItem *> &items,
const QList<QQmlDelegateModelItem *> &items,
int index,
int count,
const QVector<int> &roles) const {
@ -139,17 +139,17 @@ protected:
void objectDestroyed(QObject *);
};
class QQuickVisualAdaptorModelProxyInterface
class QQmlAdaptorModelProxyInterface
{
public:
virtual ~QQuickVisualAdaptorModelProxyInterface() {}
virtual ~QQmlAdaptorModelProxyInterface() {}
virtual QObject *proxiedObject() = 0;
};
#define QQuickVisualAdaptorModelProxyInterface_iid "org.qt-project.Qt.QQuickVisualAdaptorModelProxyInterface"
#define QQmlAdaptorModelProxyInterface_iid "org.qt-project.Qt.QQmlAdaptorModelProxyInterface"
Q_DECLARE_INTERFACE(QQuickVisualAdaptorModelProxyInterface, QQuickVisualAdaptorModelProxyInterface_iid)
Q_DECLARE_INTERFACE(QQmlAdaptorModelProxyInterface, QQmlAdaptorModelProxyInterface_iid)
QT_END_NAMESPACE

54
src/quick/util/qquickchangeset.cpp → src/qml/util/qqmlchangeset.cpp
View File

@ -39,18 +39,18 @@
**
****************************************************************************/
#include "qquickchangeset_p.h"
#include "qqmlchangeset_p.h"
QT_BEGIN_NAMESPACE
/*!
\class QQuickChangeSet
\brief The QQuickChangeSet class stores an ordered list of notifications about
\class QQmlChangeSet
\brief The QQmlChangeSet class stores an ordered list of notifications about
changes to a linear data set.
\internal
QQuickChangeSet can be used to record a series of notications about items in an indexed list
QQmlChangeSet can be used to record a series of notifications about items in an indexed list
being inserted, removed, moved, and changed. Notifications in the set are re-ordered so that
all notifications of a single type are grouped together and sorted in order of ascending index,
with remove notifications preceding all others, followed by insert notification, and then
@ -67,7 +67,7 @@ QT_BEGIN_NAMESPACE
Constructs an empty change set.
*/
QQuickChangeSet::QQuickChangeSet()
QQmlChangeSet::QQmlChangeSet()
: m_difference(0)
{
}
@ -76,7 +76,7 @@ QQuickChangeSet::QQuickChangeSet()
Constructs a copy of a \a changeSet.
*/
QQuickChangeSet::QQuickChangeSet(const QQuickChangeSet &changeSet)
QQmlChangeSet::QQmlChangeSet(const QQmlChangeSet &changeSet)
: m_removes(changeSet.m_removes)
, m_inserts(changeSet.m_inserts)
, m_changes(changeSet.m_changes)
@ -88,7 +88,7 @@ QQuickChangeSet::QQuickChangeSet(const QQuickChangeSet &changeSet)
Destroys a change set.
*/
QQuickChangeSet::~QQuickChangeSet()
QQmlChangeSet::~QQmlChangeSet()
{
}
@ -96,7 +96,7 @@ QQuickChangeSet::~QQuickChangeSet()
Assigns the value of a \a changeSet to another.
*/
QQuickChangeSet &QQuickChangeSet::operator =(const QQuickChangeSet &changeSet)
QQmlChangeSet &QQmlChangeSet::operator =(const QQmlChangeSet &changeSet)
{
m_removes = changeSet.m_removes;
m_inserts = changeSet.m_inserts;
@ -109,7 +109,7 @@ QQuickChangeSet &QQuickChangeSet::operator =(const QQuickChangeSet &changeSet)
Appends a notification that \a count items were inserted at \a index.
*/
void QQuickChangeSet::insert(int index, int count)
void QQmlChangeSet::insert(int index, int count)
{
insert(QVector<Insert>() << Insert(index, count));
}
@ -118,7 +118,7 @@ void QQuickChangeSet::insert(int index, int count)
Appends a notification that \a count items were removed at \a index.
*/
void QQuickChangeSet::remove(int index, int count)
void QQmlChangeSet::remove(int index, int count)
{
QVector<Remove> removes;
removes.append(Remove(index, count));
@ -132,7 +132,7 @@ void QQuickChangeSet::remove(int index, int count)
change sets.
*/
void QQuickChangeSet::move(int from, int to, int count, int moveId)
void QQmlChangeSet::move(int from, int to, int count, int moveId)
{
QVector<Remove> removes;
removes.append(Remove(from, count, moveId));
@ -146,7 +146,7 @@ void QQuickChangeSet::move(int from, int to, int count, int moveId)
Appends a notification that \a count items were changed at \a index.
*/
void QQuickChangeSet::change(int index, int count)
void QQmlChangeSet::change(int index, int count)
{
QVector<Change> changes;
changes.append(Change(index, count));
@ -157,7 +157,7 @@ void QQuickChangeSet::change(int index, int count)
Applies the changes in a \a changeSet to another.
*/
void QQuickChangeSet::apply(const QQuickChangeSet &changeSet)
void QQmlChangeSet::apply(const QQmlChangeSet &changeSet)
{
QVector<Remove> r = changeSet.m_removes;
QVector<Insert> i = changeSet.m_inserts;
@ -174,13 +174,13 @@ void QQuickChangeSet::apply(const QQuickChangeSet &changeSet)
corresponding intersection in the optional \a inserts list.
*/
void QQuickChangeSet::remove(const QVector<Remove> &removes, QVector<Insert> *inserts)
void QQmlChangeSet::remove(const QVector<Remove> &removes, QVector<Insert> *inserts)
{
QVector<Remove> r = removes;
remove(&r, inserts);
}
void QQuickChangeSet::remove(QVector<Remove> *removes, QVector<Insert> *inserts)
void QQmlChangeSet::remove(QVector<Remove> *removes, QVector<Insert> *inserts)
{
int removeCount = 0;
int insertCount = 0;
@ -395,7 +395,7 @@ void QQuickChangeSet::remove(QVector<Remove> *removes, QVector<Insert> *inserts)
Applies a list of \a inserts to a change set.
*/
void QQuickChangeSet::insert(const QVector<Insert> &inserts)
void QQmlChangeSet::insert(const QVector<Insert> &inserts)
{
int insertCount = 0;
QVector<Insert>::iterator insert = m_inserts.begin();
@ -487,7 +487,7 @@ void QQuickChangeSet::insert(const QVector<Insert> &inserts)
calling \l remove() followed by \l insert() with the same lists.
*/
void QQuickChangeSet::move(const QVector<Remove> &removes, const QVector<Insert> &inserts)
void QQmlChangeSet::move(const QVector<Remove> &removes, const QVector<Insert> &inserts)
{
QVector<Remove> r = removes;
QVector<Insert> i = inserts;
@ -499,13 +499,13 @@ void QQuickChangeSet::move(const QVector<Remove> &removes, const QVector<Insert>
Applies a list of \a changes to a change set.
*/
void QQuickChangeSet::change(const QVector<Change> &changes)
void QQmlChangeSet::change(const QVector<Change> &changes)
{
QVector<Change> c = changes;
change(&c);
}
void QQuickChangeSet::change(QVector<Change> *changes)
void QQmlChangeSet::change(QVector<Change> *changes)
{
QVector<Insert>::iterator insert = m_inserts.begin();
QVector<Change>::iterator change = m_changes.begin();
@ -557,12 +557,12 @@ void QQuickChangeSet::change(QVector<Change> *changes)
Prints the contents of a change \a set to the \a debug stream.
*/
QDebug operator <<(QDebug debug, const QQuickChangeSet &set)
QDebug operator <<(QDebug debug, const QQmlChangeSet &set)
{
debug.nospace() << "QQuickChangeSet(";
foreach (const QQuickChangeSet::Remove &remove, set.removes()) debug << remove;
foreach (const QQuickChangeSet::Insert &insert, set.inserts()) debug << insert;
foreach (const QQuickChangeSet::Change &change, set.changes()) debug << change;
debug.nospace() << "QQmlChangeSet(";
foreach (const QQmlChangeSet::Remove &remove, set.removes()) debug << remove;
foreach (const QQmlChangeSet::Insert &insert, set.inserts()) debug << insert;
foreach (const QQmlChangeSet::Change &change, set.changes()) debug << change;
return debug.nospace() << ')';
}
@ -570,7 +570,7 @@ QDebug operator <<(QDebug debug, const QQuickChangeSet &set)
Prints a \a remove to the \a debug stream.
*/
QDebug operator <<(QDebug debug, const QQuickChangeSet::Remove &remove)
QDebug operator <<(QDebug debug, const QQmlChangeSet::Remove &remove)
{
if (remove.moveId == -1) {
return (debug.nospace()
@ -591,7 +591,7 @@ QDebug operator <<(QDebug debug, const QQuickChangeSet::Remove &remove)
Prints an \a insert to the \a debug stream.
*/
QDebug operator <<(QDebug debug, const QQuickChangeSet::Insert &insert)
QDebug operator <<(QDebug debug, const QQmlChangeSet::Insert &insert)
{
if (insert.moveId == -1) {
return (debug.nospace()
@ -612,7 +612,7 @@ QDebug operator <<(QDebug debug, const QQuickChangeSet::Insert &insert)
Prints a \a change to the \a debug stream.
*/
QDebug operator <<(QDebug debug, const QQuickChangeSet::Change &change)
QDebug operator <<(QDebug debug, const QQmlChangeSet::Change &change)
{
return (debug.nospace() << "Change(" << change.index << ',' << change.count << ')').space();
}

37
src/quick/util/qquickchangeset_p.h → src/qml/util/qqmlchangeset_p.h
View File

@ -39,8 +39,8 @@
**
****************************************************************************/
#ifndef QQUICKCHANGESET_P_H
#define QQUICKCHANGESET_P_H
#ifndef QQMLCHANGESET_P_H
#define QQMLCHANGESET_P_H
//
// W A R N I N G
@ -55,10 +55,11 @@
#include <QtCore/qdebug.h>
#include <QtCore/qvector.h>
#include <QtQml/private/qtqmlglobal_p.h>
QT_BEGIN_NAMESPACE
class Q_AUTOTEST_EXPORT QQuickChangeSet
class Q_QML_PRIVATE_EXPORT QQmlChangeSet
{
public:
struct MoveKey
@ -104,11 +105,11 @@ public:
: Change(index, count, moveId, offset) {}
};
QQuickChangeSet();
QQuickChangeSet(const QQuickChangeSet &changeSet);
~QQuickChangeSet();
QQmlChangeSet();
QQmlChangeSet(const QQmlChangeSet &changeSet);
~QQmlChangeSet();
QQuickChangeSet &operator =(const QQuickChangeSet &changeSet);
QQmlChangeSet &operator =(const QQmlChangeSet &changeSet);
const QVector<Remove> &removes() const { return m_removes; }
const QVector<Insert> &inserts() const { return m_inserts; }
@ -123,7 +124,7 @@ public:
void remove(const QVector<Remove> &removes, QVector<Insert> *inserts = 0);
void move(const QVector<Remove> &removes, const QVector<Insert> &inserts);
void change(const QVector<Change> &changes);
void apply(const QQuickChangeSet &changeSet);
void apply(const QQmlChangeSet &changeSet);
bool isEmpty() const { return m_removes.empty() && m_inserts.empty() && m_changes.isEmpty(); }
@ -147,19 +148,19 @@ private:
int m_difference;
};
Q_DECLARE_TYPEINFO(QQuickChangeSet::Change, Q_PRIMITIVE_TYPE);
Q_DECLARE_TYPEINFO(QQuickChangeSet::Remove, Q_PRIMITIVE_TYPE);
Q_DECLARE_TYPEINFO(QQuickChangeSet::Insert, Q_PRIMITIVE_TYPE);
Q_DECLARE_TYPEINFO(QQuickChangeSet::MoveKey, Q_PRIMITIVE_TYPE);
Q_DECLARE_TYPEINFO(QQmlChangeSet::Change, Q_PRIMITIVE_TYPE);
Q_DECLARE_TYPEINFO(QQmlChangeSet::Remove, Q_PRIMITIVE_TYPE);
Q_DECLARE_TYPEINFO(QQmlChangeSet::Insert, Q_PRIMITIVE_TYPE);
Q_DECLARE_TYPEINFO(QQmlChangeSet::MoveKey, Q_PRIMITIVE_TYPE);
inline uint qHash(const QQuickChangeSet::MoveKey &key) { return qHash(qMakePair(key.moveId, key.offset)); }
inline bool operator ==(const QQuickChangeSet::MoveKey &l, const QQuickChangeSet::MoveKey &r) {
inline uint qHash(const QQmlChangeSet::MoveKey &key) { return qHash(qMakePair(key.moveId, key.offset)); }
inline bool operator ==(const QQmlChangeSet::MoveKey &l, const QQmlChangeSet::MoveKey &r) {
return l.moveId == r.moveId && l.offset == r.offset; }
Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQuickChangeSet::Remove &remove);
Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQuickChangeSet::Insert &insert);
Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQuickChangeSet::Change &change);
Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQuickChangeSet &change);
Q_QML_PRIVATE_EXPORT QDebug operator <<(QDebug debug, const QQmlChangeSet::Remove &remove);
Q_QML_PRIVATE_EXPORT QDebug operator <<(QDebug debug, const QQmlChangeSet::Insert &insert);
Q_QML_PRIVATE_EXPORT QDebug operator <<(QDebug debug, const QQmlChangeSet::Change &change);
Q_QML_PRIVATE_EXPORT QDebug operator <<(QDebug debug, const QQmlChangeSet &change);
QT_END_NAMESPACE

16
src/quick/util/qquicklistaccessor.cpp → src/qml/util/qqmllistaccessor.cpp
View File

@ -39,7 +39,7 @@
**
****************************************************************************/
#include "qquicklistaccessor_p.h"
#include "qqmllistaccessor_p.h"
#include <private/qqmlmetatype_p.h>
@ -51,21 +51,21 @@
QT_BEGIN_NAMESPACE
QQuickListAccessor::QQuickListAccessor()
QQmlListAccessor::QQmlListAccessor()
: m_type(Invalid)
{
}
QQuickListAccessor::~QQuickListAccessor()
QQmlListAccessor::~QQmlListAccessor()
{
}
QVariant QQuickListAccessor::list() const
QVariant QQmlListAccessor::list() const
{
return d;
}
void QQuickListAccessor::setList(const QVariant &v, QQmlEngine *engine)
void QQmlListAccessor::setList(const QVariant &v, QQmlEngine *engine)
{
d = v;
@ -91,7 +91,7 @@ void QQuickListAccessor::setList(const QVariant &v, QQmlEngine *engine)
}
}
int QQuickListAccessor::count() const
int QQmlListAccessor::count() const
{
switch(m_type) {
case StringList:
@ -110,7 +110,7 @@ int QQuickListAccessor::count() const
}
}
QVariant QQuickListAccessor::at(int idx) const
QVariant QQmlListAccessor::at(int idx) const
{
Q_ASSERT(idx >= 0 && idx < count());
switch(m_type) {
@ -130,7 +130,7 @@ QVariant QQuickListAccessor::at(int idx) const
}
}
bool QQuickListAccessor::isValid() const
bool QQmlListAccessor::isValid() const
{
return m_type != Invalid;
}

12
src/quick/util/qquicklistaccessor_p.h → src/qml/util/qqmllistaccessor_p.h
View File

@ -39,8 +39,8 @@
**
****************************************************************************/
#ifndef QQUICKLISTACCESSOR_H
#define QQUICKLISTACCESSOR_H
#ifndef QQMLLISTACCESSOR_H
#define QQMLLISTACCESSOR_H
#include <QtCore/QVariant>
@ -49,11 +49,11 @@ QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
class QQmlEngine;
class Q_AUTOTEST_EXPORT QQuickListAccessor
class Q_AUTOTEST_EXPORT QQmlListAccessor
{
public:
QQuickListAccessor();
~QQuickListAccessor();
QQmlListAccessor();
~QQmlListAccessor();
QVariant list() const;
void setList(const QVariant &, QQmlEngine * = 0);
@ -75,4 +75,4 @@ QT_END_NAMESPACE
QT_END_HEADER
#endif // QQUICKLISTACCESSOR_H
#endif // QQMLLISTACCESSOR_H

184
src/quick/util/qquicklistcompositor.cpp → src/qml/util/qqmllistcompositor.cpp
View File

@ -39,7 +39,7 @@
**
****************************************************************************/
#include "qquicklistcompositor_p.h"
#include "qqmllistcompositor_p.h"
#include <QtCore/qvarlengtharray.h>
@ -49,12 +49,12 @@
QT_BEGIN_NAMESPACE
/*!
\class QQuickListCompositor
\brief The QQuickListCompositor class provides a lookup table for filtered, or re-ordered list
\class QQmlListCompositor
\brief The QQmlListCompositor class provides a lookup table for filtered, or re-ordered list
indexes.
\internal
QQuickListCompositor is intended as an aid for developing proxy models. It doesn't however
QQmlListCompositor is intended as an aid for developing proxy models. It doesn't however
directly proxy a list or model, instead a range of indexes from one or many lists can be
inserted into the compositor and then categorized and shuffled around and it will manage the
task of translating from an index in the combined space into an index in a particular list.
@ -118,15 +118,15 @@ QT_BEGIN_NAMESPACE
*/
static bool qt_verifyMinimal(
const QQuickListCompositor::iterator &begin,
const QQuickListCompositor::iterator &end)
const QQmlListCompositor::iterator &begin,
const QQmlListCompositor::iterator &end)
{
bool minimal = true;
int index = 0;
for (const QQuickListCompositor::Range *range = begin->next; range != *end; range = range->next, ++index) {
for (const QQmlListCompositor::Range *range = begin->next; range != *end; range = range->next, ++index) {
if (range->previous->list == range->list
&& range->previous->flags == (range->flags & ~QQuickListCompositor::AppendFlag)
&& range->previous->flags == (range->flags & ~QQmlListCompositor::AppendFlag)
&& range->previous->end() == range->index) {
qWarning() << index << "Consecutive ranges";
qWarning() << *range->previous;
@ -141,7 +141,7 @@ static bool qt_verifyMinimal(
#endif
#ifdef QT_QML_VERIFY_INTEGRITY
static bool qt_printInfo(const QQuickListCompositor &compositor)
static bool qt_printInfo(const QQmlListCompositor &compositor)
{
qWarning() << compositor;
return true;
@ -158,14 +158,14 @@ static bool qt_printInfo(const QQuickListCompositor &compositor)
*/
static bool qt_verifyIntegrity(
const QQuickListCompositor::iterator &begin,
const QQuickListCompositor::iterator &end,
const QQuickListCompositor::iterator &cachedIt)
const QQmlListCompositor::iterator &begin,
const QQmlListCompositor::iterator &end,
const QQmlListCompositor::iterator &cachedIt)
{
bool valid = true;
int index = 0;
QQuickListCompositor::iterator it;
QQmlListCompositor::iterator it;
for (it = begin; *it != *end; *it = it->next) {
if (it->count == 0 && !it->append()) {
qWarning() << index << "Empty non-append range";
@ -175,7 +175,7 @@ static bool qt_verifyIntegrity(
qWarning() << index << "Negative count";
valid = false;
}
if (it->list && it->flags != QQuickListCompositor::CacheFlag && it->index < 0) {
if (it->list && it->flags != QQmlListCompositor::CacheFlag && it->index < 0) {
qWarning() << index <<"Negative index";
valid = false;
}
@ -195,7 +195,7 @@ static bool qt_verifyIntegrity(
if (groupIndex != cachedIt.index[i]) {
qWarning() << index
<< "invalid cached index"
<< QQuickListCompositor::Group(i)
<< QQmlListCompositor::Group(i)
<< "Expected:"
<< groupIndex
<< "Actual"
@ -233,7 +233,7 @@ static bool qt_verifyIntegrity(
//#define QT_QML_TRACE_LISTCOMPOSITOR(args) qDebug() << m_end.index[1] << m_end.index[0] << Q_FUNC_INFO args;
#define QT_QML_TRACE_LISTCOMPOSITOR(args)
QQuickListCompositor::iterator &QQuickListCompositor::iterator::operator +=(int difference)
QQmlListCompositor::iterator &QQmlListCompositor::iterator::operator +=(int difference)
{
// Update all indexes to the start of the range.
decrementIndexes(offset);
@ -267,7 +267,7 @@ QQuickListCompositor::iterator &QQuickListCompositor::iterator::operator +=(int
return *this;
}
QQuickListCompositor::insert_iterator &QQuickListCompositor::insert_iterator::operator +=(int difference)
QQmlListCompositor::insert_iterator &QQmlListCompositor::insert_iterator::operator +=(int difference)
{
iterator::operator +=(difference);
@ -286,7 +286,7 @@ QQuickListCompositor::insert_iterator &QQuickListCompositor::insert_iterator::op
Constructs an empty list compositor.
*/
QQuickListCompositor::QQuickListCompositor()
QQmlListCompositor::QQmlListCompositor()
: m_end(m_ranges.next, 0, Default, 2)
, m_cacheIt(m_end)
, m_groupCount(2)
@ -300,7 +300,7 @@ QQuickListCompositor::QQuickListCompositor()
Destroys a list compositor.
*/
QQuickListCompositor::~QQuickListCompositor()
QQmlListCompositor::~QQmlListCompositor()
{
for (Range *next, *range = m_ranges.next; range != &m_ranges; range = next) {
next = range->next;
@ -313,7 +313,7 @@ QQuickListCompositor::~QQuickListCompositor()
of the existing range \a before.
*/
inline QQuickListCompositor::Range *QQuickListCompositor::insert(
inline QQmlListCompositor::Range *QQmlListCompositor::insert(
Range *before, void *list, int index, int count, uint flags)
{
return new Range(before, list, index, count, flags);
@ -325,7 +325,7 @@ inline QQuickListCompositor::Range *QQuickListCompositor::insert(
Returns a pointer to the next range in the compositor.
*/
inline QQuickListCompositor::Range *QQuickListCompositor::erase(
inline QQmlListCompositor::Range *QQmlListCompositor::erase(
Range *range)
{
Range *next = range->next;
@ -339,7 +339,7 @@ inline QQuickListCompositor::Range *QQuickListCompositor::erase(
Sets the number (\a count) of possible groups that items may belong to in a compositor.
*/
void QQuickListCompositor::setGroupCount(int count)
void QQmlListCompositor::setGroupCount(int count)
{
m_groupCount = count;
m_end = iterator(&m_ranges, 0, Default, m_groupCount);
@ -350,7 +350,7 @@ void QQuickListCompositor::setGroupCount(int count)
Returns the number of items that belong to a \a group.
*/
int QQuickListCompositor::count(Group group) const
int QQmlListCompositor::count(Group group) const
{
return m_end.index[group];
}
@ -361,7 +361,7 @@ int QQuickListCompositor::count(Group group) const
The index must be between 0 and count(group) - 1.
*/
QQuickListCompositor::iterator QQuickListCompositor::find(Group group, int index)
QQmlListCompositor::iterator QQmlListCompositor::find(Group group, int index)
{
QT_QML_TRACE_LISTCOMPOSITOR(<< group << index)
Q_ASSERT(index >=0 && index < count(group));
@ -385,9 +385,9 @@ QQuickListCompositor::iterator QQuickListCompositor::find(Group group, int index
The index must be between 0 and count(group) - 1.
*/
QQuickListCompositor::iterator QQuickListCompositor::find(Group group, int index) const
QQmlListCompositor::iterator QQmlListCompositor::find(Group group, int index) const
{
return const_cast<QQuickListCompositor *>(this)->find(group, index);
return const_cast<QQmlListCompositor *>(this)->find(group, index);
}
/*!
@ -402,7 +402,7 @@ QQuickListCompositor::iterator QQuickListCompositor::find(Group group, int index
The index must be between 0 and count(group) - 1.
*/
QQuickListCompositor::insert_iterator QQuickListCompositor::findInsertPosition(Group group, int index)
QQmlListCompositor::insert_iterator QQmlListCompositor::findInsertPosition(Group group, int index)
{
QT_QML_TRACE_LISTCOMPOSITOR(<< group << index)
Q_ASSERT(index >=0 && index <= count(group));
@ -428,7 +428,7 @@ QQuickListCompositor::insert_iterator QQuickListCompositor::findInsertPosition(G
in each group.
*/
void QQuickListCompositor::append(
void QQmlListCompositor::append(
void *list, int index, int count, uint flags, QVector<Insert> *inserts)
{
QT_QML_TRACE_LISTCOMPOSITOR(<< list << index << count << flags)
@ -443,7 +443,7 @@ void QQuickListCompositor::append(
each group.
*/
void QQuickListCompositor::insert(
void QQmlListCompositor::insert(
Group group, int before, void *list, int index, int count, uint flags, QVector<Insert> *inserts)
{
QT_QML_TRACE_LISTCOMPOSITOR(<< group << before << list << index << count << flags)
@ -458,7 +458,7 @@ void QQuickListCompositor::insert(
each group.
*/
QQuickListCompositor::iterator QQuickListCompositor::insert(
QQmlListCompositor::iterator QQmlListCompositor::insert(
iterator before, void *list, int index, int count, uint flags, QVector<Insert> *inserts)
{
QT_QML_TRACE_LISTCOMPOSITOR(<< before << list << index << count << flags)
@ -512,7 +512,7 @@ QQuickListCompositor::iterator QQuickListCompositor::insert(
If supplied the \a inserts list will be populated with insert notifications for affected groups.
*/
void QQuickListCompositor::setFlags(
void QQmlListCompositor::setFlags(
Group fromGroup, int from, int count, Group group, int flags, QVector<Insert> *inserts)
{
QT_QML_TRACE_LISTCOMPOSITOR(<< fromGroup << from << count << group << flags)
@ -526,7 +526,7 @@ void QQuickListCompositor::setFlags(
If supplied the \a inserts list will be populated with insert notifications for affected groups.
*/
void QQuickListCompositor::setFlags(
void QQmlListCompositor::setFlags(
iterator from, int count, Group group, uint flags, QVector<Insert> *inserts)
{
QT_QML_TRACE_LISTCOMPOSITOR(<< from << count << flags)
@ -622,7 +622,7 @@ void QQuickListCompositor::setFlags(
If supplied the \a removes list will be populated with remove notifications for affected groups.
*/
void QQuickListCompositor::clearFlags(
void QQmlListCompositor::clearFlags(
Group fromGroup, int from, int count, Group group, uint flags, QVector<Remove> *removes)
{
QT_QML_TRACE_LISTCOMPOSITOR(<< fromGroup << from << count << group << flags)
@ -636,7 +636,7 @@ void QQuickListCompositor::clearFlags(
If supplied the \a removes list will be populated with remove notifications for affected groups.
*/
void QQuickListCompositor::clearFlags(
void QQmlListCompositor::clearFlags(
iterator from, int count, Group group, uint flags, QVector<Remove> *removes)
{
QT_QML_TRACE_LISTCOMPOSITOR(<< from << count << flags)
@ -730,7 +730,7 @@ void QQuickListCompositor::clearFlags(
QT_QML_VERIFY_LISTCOMPOSITOR
}
bool QQuickListCompositor::verifyMoveTo(
bool QQmlListCompositor::verifyMoveTo(
Group fromGroup, int from, Group toGroup, int to, int count, Group group) const
{
if (group != toGroup) {
@ -765,7 +765,7 @@ bool QQuickListCompositor::verifyMoveTo(
of the items moved.
*/
void QQuickListCompositor::move(
void QQmlListCompositor::move(
Group fromGroup,
int from,
Group toGroup,
@ -940,7 +940,7 @@ void QQuickListCompositor::move(
Clears the contents of a compositor.
*/
void QQuickListCompositor::clear()
void QQmlListCompositor::clear()
{
QT_QML_TRACE_LISTCOMPOSITOR( )
for (Range *range = m_ranges.next; range != &m_ranges; range = erase(range)) {}
@ -948,10 +948,10 @@ void QQuickListCompositor::clear()
m_cacheIt = m_end;
}
void QQuickListCompositor::listItemsInserted(
void QQmlListCompositor::listItemsInserted(
QVector<Insert> *translatedInsertions,
void *list,
const QVector<QQuickChangeSet::Insert> &insertions,
const QVector<QQmlChangeSet::Insert> &insertions,
const QVector<MovedFlags> *movedFlags)
{
QT_QML_TRACE_LISTCOMPOSITOR(<< list << insertions)
@ -966,7 +966,7 @@ void QQuickListCompositor::listItemsInserted(
it.incrementIndexes(it->count);
continue;
}
foreach (const QQuickChangeSet::Insert &insertion, insertions) {
foreach (const QQmlChangeSet::Insert &insertion, insertions) {
int offset = insertion.index - it->index;
if ((offset > 0 && offset < it->count)
|| (offset == 0 && it->prepend())
@ -1058,23 +1058,23 @@ void QQuickListCompositor::listItemsInserted(
groups.
*/
void QQuickListCompositor::listItemsInserted(
void QQmlListCompositor::listItemsInserted(
void *list, int index, int count, QVector<Insert> *translatedInsertions)
{
QT_QML_TRACE_LISTCOMPOSITOR(<< list << index << count)
Q_ASSERT(count > 0);
QVector<QQuickChangeSet::Insert> insertions;
insertions.append(QQuickChangeSet::Insert(index, count));
QVector<QQmlChangeSet::Insert> insertions;
insertions.append(QQmlChangeSet::Insert(index, count));
listItemsInserted(translatedInsertions, list, insertions);
}
void QQuickListCompositor::listItemsRemoved(
void QQmlListCompositor::listItemsRemoved(
QVector<Remove> *translatedRemovals,
void *list,
QVector<QQuickChangeSet::Remove> *removals,
QVector<QQuickChangeSet::Insert> *insertions,
QVector<QQmlChangeSet::Remove> *removals,
QVector<QQmlChangeSet::Insert> *insertions,
QVector<MovedFlags> *movedFlags)
{
QT_QML_TRACE_LISTCOMPOSITOR(<< list << *removals)
@ -1086,7 +1086,7 @@ void QQuickListCompositor::listItemsRemoved(
continue;
}
bool removed = false;
for (QVector<QQuickChangeSet::Remove>::iterator removal = removals->begin();
for (QVector<QQmlChangeSet::Remove>::iterator removal = removals->begin();
!removed && removal != removals->end();
++removal) {
int relativeIndex = removal->index - it->index;
@ -1104,7 +1104,7 @@ void QQuickListCompositor::listItemsRemoved(
}
if (removal->isMove()) {
// If the removal was part of a move find the corresponding insert.
QVector<QQuickChangeSet::Insert>::iterator insertion = insertions->begin();
QVector<QQmlChangeSet::Insert>::iterator insertion = insertions->begin();
for (; insertion != insertions->end() && insertion->moveId != removal->moveId;
++insertion) {}
Q_ASSERT(insertion != insertions->end());
@ -1114,11 +1114,11 @@ void QQuickListCompositor::listItemsRemoved(
// If the remove started before the current range, split it and the
// corresponding insert so we're only working with intersecting part.
int splitMoveId = ++m_moveId;
removal = removals->insert(removal, QQuickChangeSet::Remove(
removal = removals->insert(removal, QQmlChangeSet::Remove(
removal->index, -relativeIndex, splitMoveId));
++removal;
removal->count -= -relativeIndex;
insertion = insertions->insert(insertion, QQuickChangeSet::Insert(
insertion = insertions->insert(insertion, QQmlChangeSet::Insert(
insertion->index, -relativeIndex, splitMoveId));
++insertion;
insertion->index += -relativeIndex;
@ -1135,10 +1135,10 @@ void QQuickListCompositor::listItemsRemoved(
if (removeCount < removal->count) {
// If the remove doesn't encompass all of the current range,
// split it and the corresponding insert.
removal = removals->insert(removal, QQuickChangeSet::Remove(
removal = removals->insert(removal, QQmlChangeSet::Remove(
removal->index, removeCount, translatedRemoval.moveId));
++removal;
insertion = insertions->insert(insertion, QQuickChangeSet::Insert(
insertion = insertions->insert(insertion, QQmlChangeSet::Insert(
insertion->index, removeCount, translatedRemoval.moveId));
++insertion;
@ -1247,14 +1247,14 @@ void QQuickListCompositor::listItemsRemoved(
*/
void QQuickListCompositor::listItemsRemoved(
void QQmlListCompositor::listItemsRemoved(
void *list, int index, int count, QVector<Remove> *translatedRemovals)
{
QT_QML_TRACE_LISTCOMPOSITOR(<< list << index << count)
Q_ASSERT(count >= 0);
QVector<QQuickChangeSet::Remove> removals;
removals.append(QQuickChangeSet::Remove(index, count));
QVector<QQmlChangeSet::Remove> removals;
removals.append(QQmlChangeSet::Remove(index, count));
listItemsRemoved(translatedRemovals, list, &removals, 0, 0);
}
@ -1269,7 +1269,7 @@ void QQuickListCompositor::listItemsRemoved(
notifications for the affected groups.
*/
void QQuickListCompositor::listItemsMoved(
void QQmlListCompositor::listItemsMoved(
void *list,
int from,
int to,
@ -1280,20 +1280,20 @@ void QQuickListCompositor::listItemsMoved(
QT_QML_TRACE_LISTCOMPOSITOR(<< list << from << to << count)
Q_ASSERT(count >= 0);
QVector<QQuickChangeSet::Remove> removals;
QVector<QQuickChangeSet::Insert> insertions;
QVector<QQmlChangeSet::Remove> removals;
QVector<QQmlChangeSet::Insert> insertions;
QVector<MovedFlags> movedFlags;
removals.append(QQuickChangeSet::Remove(from, count, 0));
insertions.append(QQuickChangeSet::Insert(to, count, 0));
removals.append(QQmlChangeSet::Remove(from, count, 0));
insertions.append(QQmlChangeSet::Insert(to, count, 0));
listItemsRemoved(translatedRemovals, list, &removals, &insertions, &movedFlags);
listItemsInserted(translatedInsertions, list, insertions, &movedFlags);
}
void QQuickListCompositor::listItemsChanged(
void QQmlListCompositor::listItemsChanged(
QVector<Change> *translatedChanges,
void *list,
const QVector<QQuickChangeSet::Change> &changes)
const QVector<QQmlChangeSet::Change> &changes)
{
QT_QML_TRACE_LISTCOMPOSITOR(<< list << changes)
for (iterator it(m_ranges.next, 0, Default, m_groupCount); *it != &m_ranges; *it = it->next) {
@ -1303,7 +1303,7 @@ void QQuickListCompositor::listItemsChanged(
} else if (!it->inGroup()) {
continue;
}
foreach (const QQuickChangeSet::Change &change, changes) {
foreach (const QQmlChangeSet::Change &change, changes) {
const int offset = change.index - it->index;
if (offset + change.count > 0 && offset < it->count) {
const int changeOffset = qMax(0, offset);
@ -1329,29 +1329,29 @@ void QQuickListCompositor::listItemsChanged(
affected groups.
*/
void QQuickListCompositor::listItemsChanged(
void QQmlListCompositor::listItemsChanged(
void *list, int index, int count, QVector<Change> *translatedChanges)
{
QT_QML_TRACE_LISTCOMPOSITOR(<< list << index << count)
Q_ASSERT(count >= 0);
QVector<QQuickChangeSet::Change> changes;
changes.append(QQuickChangeSet::Change(index, count));
QVector<QQmlChangeSet::Change> changes;
changes.append(QQmlChangeSet::Change(index, count));
listItemsChanged(translatedChanges, list, changes);
}
void QQuickListCompositor::transition(
void QQmlListCompositor::transition(
Group from,
Group to,
QVector<QQuickChangeSet::Remove> *removes,
QVector<QQuickChangeSet::Insert> *inserts)
QVector<QQmlChangeSet::Remove> *removes,
QVector<QQmlChangeSet::Insert> *inserts)
{
int removeCount = 0;
for (iterator it(m_ranges.next, 0, Default, m_groupCount); *it != &m_ranges; *it = it->next) {
if (it == from && it != to) {
removes->append(QQuickChangeSet::Remove(it.index[from]- removeCount, it->count));
removes->append(QQmlChangeSet::Remove(it.index[from]- removeCount, it->count));
removeCount += it->count;
} else if (it != from && it == to) {
inserts->append(QQuickChangeSet::Insert(it.index[to], it->count));
inserts->append(QQmlChangeSet::Insert(it.index[to], it->count));
}
it.incrementIndexes(it->count);
}
@ -1362,11 +1362,11 @@ void QQuickListCompositor::transition(
Writes the name of \a group to \a debug.
*/
QDebug operator <<(QDebug debug, const QQuickListCompositor::Group &group)
QDebug operator <<(QDebug debug, const QQmlListCompositor::Group &group)
{
switch (group) {
case QQuickListCompositor::Cache: return debug << "Cache";
case QQuickListCompositor::Default: return debug << "Default";
case QQmlListCompositor::Cache: return debug << "Cache";
case QQmlListCompositor::Default: return debug << "Default";
default: return (debug.nospace() << "Group" << int(group)).space();
}
@ -1377,7 +1377,7 @@ QDebug operator <<(QDebug debug, const QQuickListCompositor::Group &group)
Writes the contents of \a range to \a debug.
*/
QDebug operator <<(QDebug debug, const QQuickListCompositor::Range &range)
QDebug operator <<(QDebug debug, const QQmlListCompositor::Range &range)
{
(debug.nospace()
<< "Range("
@ -1387,11 +1387,11 @@ QDebug operator <<(QDebug debug, const QQuickListCompositor::Range &range)
<< (range.isUnresolved() ? 'U' : '0')
<< (range.append() ? 'A' : '0')
<< (range.prepend() ? 'P' : '0');
for (int i = QQuickListCompositor::MaximumGroupCount - 1; i >= 2; --i)
for (int i = QQmlListCompositor::MaximumGroupCount - 1; i >= 2; --i)
debug << (range.inGroup(i) ? '1' : '0');
return (debug
<< (range.inGroup(QQuickListCompositor::Default) ? 'D' : '0')
<< (range.inGroup(QQuickListCompositor::Cache) ? 'C' : '0'));
<< (range.inGroup(QQmlListCompositor::Default) ? 'D' : '0')
<< (range.inGroup(QQmlListCompositor::Cache) ? 'C' : '0'));
}
static void qt_print_indexes(QDebug &debug, int count, const int *indexes)
@ -1405,21 +1405,21 @@ static void qt_print_indexes(QDebug &debug, int count, const int *indexes)
Writes the contents of \a it to \a debug.
*/
QDebug operator <<(QDebug debug, const QQuickListCompositor::iterator &it)
QDebug operator <<(QDebug debug, const QQmlListCompositor::iterator &it)
{
(debug.nospace() << "iterator(" << it.group).space() << "offset:" << it.offset;
qt_print_indexes(debug, it.groupCount, it.index);
return ((debug << **it).nospace() << ')').space();
}
static QDebug qt_print_change(QDebug debug, const char *name, const QQuickListCompositor::Change &change)
static QDebug qt_print_change(QDebug debug, const char *name, const QQmlListCompositor::Change &change)
{
debug.nospace() << name << '(' << change.moveId << ' ' << change.count << ' ';
for (int i = QQuickListCompositor::MaximumGroupCount - 1; i >= 2; --i)
for (int i = QQmlListCompositor::MaximumGroupCount - 1; i >= 2; --i)
debug << (change.inGroup(i) ? '1' : '0');
debug << (change.inGroup(QQuickListCompositor::Default) ? 'D' : '0')
<< (change.inGroup(QQuickListCompositor::Cache) ? 'C' : '0');
int i = QQuickListCompositor::MaximumGroupCount - 1;
debug << (change.inGroup(QQmlListCompositor::Default) ? 'D' : '0')
<< (change.inGroup(QQmlListCompositor::Cache) ? 'C' : '0');
int i = QQmlListCompositor::MaximumGroupCount - 1;
for (; i >= 0 && !change.inGroup(i); --i) {}
for (; i >= 0; --i)
debug << ' ' << change.index[i];
@ -1431,7 +1431,7 @@ static QDebug qt_print_change(QDebug debug, const char *name, const QQuickListCo
Writes the contents of \a change to \a debug.
*/
QDebug operator <<(QDebug debug, const QQuickListCompositor::Change &change)
QDebug operator <<(QDebug debug, const QQmlListCompositor::Change &change)
{
return qt_print_change(debug, "Change", change);
}
@ -1441,7 +1441,7 @@ QDebug operator <<(QDebug debug, const QQuickListCompositor::Change &change)
Writes the contents of \a remove to \a debug.
*/
QDebug operator <<(QDebug debug, const QQuickListCompositor::Remove &remove)
QDebug operator <<(QDebug debug, const QQmlListCompositor::Remove &remove)
{
return qt_print_change(debug, "Remove", remove);
}
@ -1451,7 +1451,7 @@ QDebug operator <<(QDebug debug, const QQuickListCompositor::Remove &remove)
Writes the contents of \a insert to \a debug.
*/
QDebug operator <<(QDebug debug, const QQuickListCompositor::Insert &insert)
QDebug operator <<(QDebug debug, const QQmlListCompositor::Insert &insert)
{
return qt_print_change(debug, "Insert", insert);
}
@ -1461,14 +1461,14 @@ QDebug operator <<(QDebug debug, const QQuickListCompositor::Insert &insert)
Writes the contents of \a list to \a debug.
*/
QDebug operator <<(QDebug debug, const QQuickListCompositor &list)
QDebug operator <<(QDebug debug, const QQmlListCompositor &list)
{
int indexes[QQuickListCompositor::MaximumGroupCount];
for (int i = 0; i < QQuickListCompositor::MaximumGroupCount; ++i)
int indexes[QQmlListCompositor::MaximumGroupCount];
for (int i = 0; i < QQmlListCompositor::MaximumGroupCount; ++i)
indexes[i] = 0;
debug.nospace() << "QQuickListCompositor(";
debug.nospace() << "QQmlListCompositor(";
qt_print_indexes(debug, list.m_groupCount, list.m_end.index);
for (QQuickListCompositor::Range *range = list.m_ranges.next; range != &list.m_ranges; range = range->next) {
for (QQmlListCompositor::Range *range = list.m_ranges.next; range != &list.m_ranges; range = range->next) {
(debug << '\n').space();
qt_print_indexes(debug, list.m_groupCount, indexes);
debug << ' ' << *range;

60
src/quick/util/qquicklistcompositor_p.h → src/qml/util/qqmllistcompositor_p.h
View File

@ -39,8 +39,8 @@
**
****************************************************************************/
#ifndef QQUICKLISTCOMPOSITOR_P_H
#define QQUICKLISTCOMPOSITOR_P_H
#ifndef QQMLLISTCOMPOSITOR_P_H
#define QQMLLISTCOMPOSITOR_P_H
//
// W A R N I N G
@ -56,13 +56,13 @@
#include <QtCore/qglobal.h>
#include <QtCore/qvector.h>
#include <private/qquickchangeset_p.h>
#include <private/qqmlchangeset_p.h>
#include <QtCore/qdebug.h>
QT_BEGIN_NAMESPACE
class Q_AUTOTEST_EXPORT QQuickListCompositor
class Q_AUTOTEST_EXPORT QQmlListCompositor
{
public:
enum { MinimumGroupCount = 3, MaximumGroupCount = 11 };
@ -207,8 +207,8 @@ public:
: Change(it, count, flags, moveId) {}
};
QQuickListCompositor();
~QQuickListCompositor();
QQmlListCompositor();
~QQmlListCompositor();
int defaultGroups() const { return m_defaultFlags & ~PrependFlag; }
void setDefaultGroups(int groups) { m_defaultFlags = groups | PrependFlag; }
@ -263,8 +263,8 @@ public:
void transition(
Group from,
Group to,
QVector<QQuickChangeSet::Remove> *removes,
QVector<QQuickChangeSet::Insert> *inserts);
QVector<QQmlChangeSet::Remove> *removes,
QVector<QQmlChangeSet::Insert> *inserts);
private:
Range m_ranges;
@ -290,29 +290,29 @@ private:
void listItemsRemoved(
QVector<Remove> *translatedRemovals,
void *list,
QVector<QQuickChangeSet::Remove> *removals,
QVector<QQuickChangeSet::Insert> *insertions = 0,
QVector<QQmlChangeSet::Remove> *removals,
QVector<QQmlChangeSet::Insert> *insertions = 0,
QVector<MovedFlags> *movedFlags = 0);
void listItemsInserted(
QVector<Insert> *translatedInsertions,
void *list,
const QVector<QQuickChangeSet::Insert> &insertions,
const QVector<QQmlChangeSet::Insert> &insertions,
const QVector<MovedFlags> *movedFlags = 0);
void listItemsChanged(
QVector<Change> *translatedChanges,
void *list,
const QVector<QQuickChangeSet::Change> &changes);
const QVector<QQmlChangeSet::Change> &changes);
friend Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQuickListCompositor &list);
friend Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQmlListCompositor &list);
};
Q_DECLARE_TYPEINFO(QQuickListCompositor::Change, Q_PRIMITIVE_TYPE);
Q_DECLARE_TYPEINFO(QQuickListCompositor::Remove, Q_PRIMITIVE_TYPE);
Q_DECLARE_TYPEINFO(QQuickListCompositor::Insert, Q_PRIMITIVE_TYPE);
Q_DECLARE_TYPEINFO(QQmlListCompositor::Change, Q_PRIMITIVE_TYPE);
Q_DECLARE_TYPEINFO(QQmlListCompositor::Remove, Q_PRIMITIVE_TYPE);
Q_DECLARE_TYPEINFO(QQmlListCompositor::Insert, Q_PRIMITIVE_TYPE);
inline QQuickListCompositor::iterator::iterator()
inline QQmlListCompositor::iterator::iterator()
: range(0), offset(0), group(Default), groupCount(0) {}
inline QQuickListCompositor::iterator::iterator(const iterator &it)
inline QQmlListCompositor::iterator::iterator(const iterator &it)
: range(it.range)
, offset(it.offset)
, group(it.group)
@ -323,7 +323,7 @@ inline QQuickListCompositor::iterator::iterator(const iterator &it)
index[i] = it.index[i];
}
inline QQuickListCompositor::iterator::iterator(
inline QQmlListCompositor::iterator::iterator(
Range *range, int offset, Group group, int groupCount)
: range(range)
, offset(offset)
@ -335,7 +335,7 @@ inline QQuickListCompositor::iterator::iterator(
index[i] = 0;
}
inline void QQuickListCompositor::iterator::incrementIndexes(int difference, uint flags)
inline void QQmlListCompositor::iterator::incrementIndexes(int difference, uint flags)
{
for (int i = 0; i < groupCount; ++i) {
if (flags & (1 << i))
@ -343,7 +343,7 @@ inline void QQuickListCompositor::iterator::incrementIndexes(int difference, uin
}
}
inline void QQuickListCompositor::iterator::decrementIndexes(int difference, uint flags)
inline void QQmlListCompositor::iterator::decrementIndexes(int difference, uint flags)
{
for (int i = 0; i < groupCount; ++i) {
if (flags & (1 << i))
@ -351,24 +351,24 @@ inline void QQuickListCompositor::iterator::decrementIndexes(int difference, uin
}
}
inline QQuickListCompositor::insert_iterator::insert_iterator(
inline QQmlListCompositor::insert_iterator::insert_iterator(
Range *range, int offset, Group group, int groupCount)
: iterator(range, offset, group, groupCount) {}
inline QQuickListCompositor::Change::Change(iterator it, int count, uint flags, int moveId)
inline QQmlListCompositor::Change::Change(iterator it, int count, uint flags, int moveId)
: count(count), flags(flags), moveId(moveId)
{
for (int i = 0; i < MaximumGroupCount; ++i)
index[i] = it.index[i];
}
Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQuickListCompositor::Group &group);
Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQuickListCompositor::Range &range);
Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQuickListCompositor::iterator &it);
Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQuickListCompositor::Change &change);
Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQuickListCompositor::Remove &remove);
Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQuickListCompositor::Insert &insert);
Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQuickListCompositor &list);
Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQmlListCompositor::Group &group);
Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQmlListCompositor::Range &range);
Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQmlListCompositor::iterator &it);
Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQmlListCompositor::Change &change);
Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQmlListCompositor::Remove &remove);
Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQmlListCompositor::Insert &insert);
Q_AUTOTEST_EXPORT QDebug operator <<(QDebug debug, const QQmlListCompositor &list);
QT_END_NAMESPACE

8
src/qml/util/util.pri
View File

@ -1,5 +1,13 @@
SOURCES += \
$$PWD/qqmlchangeset.cpp \
$$PWD/qqmllistaccessor.cpp \
$$PWD/qqmllistcompositor.cpp \
$$PWD/qqmladaptormodel.cpp \
$$PWD/qqmlpropertymap.cpp
HEADERS += \
$$PWD/qqmlchangeset_p.h \
$$PWD/qqmllistaccessor_p.h \
$$PWD/qqmllistcompositor_p.h \
$$PWD/qqmladaptormodel_p.h \
$$PWD/qqmlpropertymap.h

7
src/quick/items/items.pri
View File

@ -38,10 +38,6 @@ HEADERS += \
$$PWD/qquickflickable_p.h \
$$PWD/qquickflickable_p_p.h \
$$PWD/qquicklistview_p.h \
$$PWD/qquickvisualadaptormodel_p.h \
$$PWD/qquickvisualdatamodel_p.h \
$$PWD/qquickvisualdatamodel_p_p.h \
$$PWD/qquickvisualitemmodel_p.h \
$$PWD/qquickrepeater_p.h \
$$PWD/qquickrepeater_p_p.h \
$$PWD/qquickgridview_p.h \
@ -99,9 +95,6 @@ SOURCES += \
$$PWD/qquickpincharea.cpp \
$$PWD/qquickflickable.cpp \
$$PWD/qquicklistview.cpp \
$$PWD/qquickvisualadaptormodel.cpp \
$$PWD/qquickvisualdatamodel.cpp \
$$PWD/qquickvisualitemmodel.cpp \
$$PWD/qquickrepeater.cpp \
$$PWD/qquickgridview.cpp \
$$PWD/qquickpathview.cpp \

21
src/quick/items/qquickgridview.cpp
View File

@ -40,10 +40,10 @@
****************************************************************************/
#include "qquickgridview_p.h"
#include "qquickvisualitemmodel_p.h"
#include "qquickflickable_p_p.h"
#include "qquickitemview_p_p.h"
#include <private/qqmlobjectmodel_p.h>
#include <private/qquicksmoothedanimation_p_p.h>
#include <QtGui/qevent.h>
@ -209,7 +209,7 @@ public:
virtual void setPosition(qreal pos);
virtual void layoutVisibleItems(int fromModelIndex = 0);
virtual bool applyInsertionChange(const QQuickChangeSet::Insert &insert, ChangeResult *changeResult, QList<FxViewItem *> *addedItems, QList<MovedItem> *movingIntoView);
virtual bool applyInsertionChange(const QQmlChangeSet::Insert &insert, ChangeResult *changeResult, QList<FxViewItem *> *addedItems, QList<MovedItem> *movingIntoView);
virtual void translateAndTransitionItemsAfter(int afterModelIndex, const ChangeResult &insertionResult, const ChangeResult &removalResult);
virtual bool needsRefillForAddedOrRemovedIndex(int index) const;
@ -2105,13 +2105,16 @@ void QQuickGridView::geometryChanged(const QRectF &newGeometry, const QRectF &ol
QQuickItemView::geometryChanged(newGeometry, oldGeometry);
}
void QQuickGridView::initItem(int index, QQuickItem *item)
void QQuickGridView::initItem(int index, QObject *obj)
{
QQuickItemView::initItem(index, item);
QQuickGridViewAttached *attached = static_cast<QQuickGridViewAttached *>(
qmlAttachedPropertiesObject<QQuickGridView>(item));
if (attached)
attached->setView(this);
QQuickItemView::initItem(index, obj);
QQuickItem *item = qmlobject_cast<QQuickItem*>(obj);
if (item) {
QQuickGridViewAttached *attached = static_cast<QQuickGridViewAttached *>(
qmlAttachedPropertiesObject<QQuickGridView>(item));
if (attached)
attached->setView(this);
}
}
/*!
@ -2286,7 +2289,7 @@ void QQuickGridView::moveCurrentIndexRight()
}
}
bool QQuickGridViewPrivate::applyInsertionChange(const QQuickChangeSet::Insert &change, ChangeResult *insertResult, QList<FxViewItem *> *addedItems, QList<MovedItem> *movingIntoView)
bool QQuickGridViewPrivate::applyInsertionChange(const QQmlChangeSet::Insert &change, ChangeResult *insertResult, QList<FxViewItem *> *addedItems, QList<MovedItem> *movingIntoView)
{
Q_Q(QQuickGridView);

3
src/quick/items/qquickgridview_p.h
View File

@ -50,7 +50,6 @@ QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
class QQuickVisualModel;
class QQuickGridViewAttached;
class QQuickGridViewPrivate;
class Q_AUTOTEST_EXPORT QQuickGridView : public QQuickItemView
@ -112,7 +111,7 @@ protected:
virtual void viewportMoved(Qt::Orientations);
virtual void keyPressEvent(QKeyEvent *);
virtual void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
virtual void initItem(int index, QQuickItem *item);
virtual void initItem(int index, QObject *item);
};
class QQuickGridViewAttached : public QQuickItemViewAttached

6
src/quick/items/qquickitemsmodule.cpp
View File

@ -57,8 +57,6 @@
#include "qquickflickable_p.h"
#include "qquickflickable_p_p.h"
#include "qquicklistview_p.h"
#include "qquickvisualitemmodel_p.h"
#include "qquickvisualdatamodel_p.h"
#include "qquickgridview_p.h"
#include "qquickpathview_p.h"
#include "qquickitemviewtransition_p.h"
@ -161,9 +159,6 @@ static void qt_quickitems_defineModule(const char *uri, int major, int minor)
qmlRegisterType<QQuickTextEdit>(uri,major,minor,"TextEdit");
qmlRegisterType<QQuickTextInput>(uri,major,minor,"TextInput");
qmlRegisterType<QQuickViewSection>(uri,major,minor,"ViewSection");
qmlRegisterType<QQuickVisualDataModel>(uri,major,minor,"VisualDataModel");
qmlRegisterType<QQuickVisualDataGroup>(uri,major,minor,"VisualDataGroup");
qmlRegisterType<QQuickVisualItemModel>(uri,major,minor,"VisualItemModel");
qmlRegisterType<QQuickItemLayer>();
qmlRegisterType<QQuickAnchors>();
@ -178,7 +173,6 @@ static void qt_quickitems_defineModule(const char *uri, int major, int minor)
#ifndef QT_NO_VALIDATOR
qmlRegisterType<QValidator>();
#endif
qmlRegisterType<QQuickVisualModel>();
qmlRegisterType<QQuickPen>();
qmlRegisterType<QQuickFlickableVisibleArea>();
qRegisterMetaType<QQuickAnchorLine>("QQuickAnchorLine");

114
src/quick/items/qquickitemview.cpp
View File

@ -41,6 +41,7 @@
#include "qquickitemview_p_p.h"
#include <QtQuick/private/qquicktransition_p.h>
#include <QtQml/QQmlInfo>
#include "qplatformdefs.h"
QT_BEGIN_NAMESPACE
@ -147,14 +148,14 @@ bool QQuickItemViewChangeSet::hasPendingChanges() const
return !pendingChanges.isEmpty();
}
void QQuickItemViewChangeSet::applyChanges(const QQuickChangeSet &changeSet)
void QQuickItemViewChangeSet::applyChanges(const QQmlChangeSet &changeSet)
{
pendingChanges.apply(changeSet);
int moveId = -1;
int moveOffset = 0;
foreach (const QQuickChangeSet::Remove &r, changeSet.removes()) {
foreach (const QQmlChangeSet::Remove &r, changeSet.removes()) {
itemCount -= r.count;
if (moveId == -1 && newCurrentIndex >= r.index + r.count) {
newCurrentIndex -= r.count;
@ -173,7 +174,7 @@ void QQuickItemViewChangeSet::applyChanges(const QQuickChangeSet &changeSet)
currentChanged = true;
}
}
foreach (const QQuickChangeSet::Insert &i, changeSet.inserts()) {
foreach (const QQmlChangeSet::Insert &i, changeSet.inserts()) {
if (moveId == -1) {
if (itemCount && newCurrentIndex >= i.index) {
newCurrentIndex += i.count;
@ -266,14 +267,14 @@ void QQuickItemView::setModel(const QVariant &model)
if (d->modelVariant == model)
return;
if (d->model) {
disconnect(d->model, SIGNAL(modelUpdated(QQuickChangeSet,bool)),
this, SLOT(modelUpdated(QQuickChangeSet,bool)));
disconnect(d->model, SIGNAL(initItem(int,QQuickItem*)), this, SLOT(initItem(int,QQuickItem*)));
disconnect(d->model, SIGNAL(createdItem(int,QQuickItem*)), this, SLOT(createdItem(int,QQuickItem*)));
disconnect(d->model, SIGNAL(destroyingItem(QQuickItem*)), this, SLOT(destroyingItem(QQuickItem*)));
disconnect(d->model, SIGNAL(modelUpdated(QQmlChangeSet,bool)),
this, SLOT(modelUpdated(QQmlChangeSet,bool)));
disconnect(d->model, SIGNAL(initItem(int,QObject*)), this, SLOT(initItem(int,QObject*)));
disconnect(d->model, SIGNAL(createdItem(int,QObject*)), this, SLOT(createdItem(int,QObject*)));
disconnect(d->model, SIGNAL(destroyingItem(QObject*)), this, SLOT(destroyingItem(QObject*)));
}
QQuickVisualModel *oldModel = d->model;
QQmlInstanceModel *oldModel = d->model;
d->clear();
d->model = 0;
@ -281,8 +282,8 @@ void QQuickItemView::setModel(const QVariant &model)
d->modelVariant = model;
QObject *object = qvariant_cast<QObject*>(model);
QQuickVisualModel *vim = 0;
if (object && (vim = qobject_cast<QQuickVisualModel *>(object))) {
QQmlInstanceModel *vim = 0;
if (object && (vim = qobject_cast<QQmlInstanceModel *>(object))) {
if (d->ownModel) {
delete oldModel;
d->ownModel = false;
@ -290,22 +291,22 @@ void QQuickItemView::setModel(const QVariant &model)
d->model = vim;
} else {
if (!d->ownModel) {
d->model = new QQuickVisualDataModel(qmlContext(this), this);
d->model = new QQmlDelegateModel(qmlContext(this), this);
d->ownModel = true;
if (isComponentComplete())
static_cast<QQuickVisualDataModel *>(d->model.data())->componentComplete();
static_cast<QQmlDelegateModel *>(d->model.data())->componentComplete();
} else {
d->model = oldModel;
}
if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model))
if (QQmlDelegateModel *dataModel = qobject_cast<QQmlDelegateModel*>(d->model))
dataModel->setModel(model);
}
if (d->model) {
d->bufferMode = QQuickItemViewPrivate::BufferBefore | QQuickItemViewPrivate::BufferAfter;
connect(d->model, SIGNAL(createdItem(int,QQuickItem*)), this, SLOT(createdItem(int,QQuickItem*)));
connect(d->model, SIGNAL(initItem(int,QQuickItem*)), this, SLOT(initItem(int,QQuickItem*)));
connect(d->model, SIGNAL(destroyingItem(QQuickItem*)), this, SLOT(destroyingItem(QQuickItem*)));
connect(d->model, SIGNAL(createdItem(int,QObject*)), this, SLOT(createdItem(int,QObject*)));
connect(d->model, SIGNAL(initItem(int,QObject*)), this, SLOT(initItem(int,QObject*)));
connect(d->model, SIGNAL(destroyingItem(QObject*)), this, SLOT(destroyingItem(QObject*)));
if (isComponentComplete()) {
d->updateSectionCriteria();
d->refill();
@ -319,8 +320,8 @@ void QQuickItemView::setModel(const QVariant &model)
}
}
connect(d->model, SIGNAL(modelUpdated(QQuickChangeSet,bool)),
this, SLOT(modelUpdated(QQuickChangeSet,bool)));
connect(d->model, SIGNAL(modelUpdated(QQmlChangeSet,bool)),
this, SLOT(modelUpdated(QQmlChangeSet,bool)));
emit countChanged();
}
emit modelChanged();
@ -330,7 +331,7 @@ QQmlComponent *QQuickItemView::delegate() const
{
Q_D(const QQuickItemView);
if (d->model) {
if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model))
if (QQmlDelegateModel *dataModel = qobject_cast<QQmlDelegateModel*>(d->model))
return dataModel->delegate();
}
@ -343,10 +344,10 @@ void QQuickItemView::setDelegate(QQmlComponent *delegate)
if (delegate == this->delegate())
return;
if (!d->ownModel) {
d->model = new QQuickVisualDataModel(qmlContext(this));
d->model = new QQmlDelegateModel(qmlContext(this));
d->ownModel = true;
}
if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model)) {
if (QQmlDelegateModel *dataModel = qobject_cast<QQmlDelegateModel*>(d->model)) {
int oldCount = dataModel->count();
dataModel->setDelegate(delegate);
if (isComponentComplete()) {
@ -371,6 +372,7 @@ void QQuickItemView::setDelegate(QQmlComponent *delegate)
emit countChanged();
}
emit delegateChanged();
d->delegateValidated = false;
}
@ -972,7 +974,7 @@ void QQuickItemViewPrivate::applyPendingChanges()
layout();
}
int QQuickItemViewPrivate::findMoveKeyIndex(QQuickChangeSet::MoveKey key, const QVector<QQuickChangeSet::Remove> &changes) const
int QQuickItemViewPrivate::findMoveKeyIndex(QQmlChangeSet::MoveKey key, const QVector<QQmlChangeSet::Remove> &changes) const
{
for (int i=0; i<changes.count(); i++) {
for (int j=changes[i].index; j<changes[i].index + changes[i].count; j++) {
@ -1152,7 +1154,7 @@ void QQuickItemView::destroyRemoved()
d->forceLayoutPolish();
}
void QQuickItemView::modelUpdated(const QQuickChangeSet &changeSet, bool reset)
void QQuickItemView::modelUpdated(const QQmlChangeSet &changeSet, bool reset)
{
Q_D(QQuickItemView);
if (reset) {
@ -1388,7 +1390,7 @@ void QQuickItemView::componentComplete()
{
Q_D(QQuickItemView);
if (d->model && d->ownModel)
static_cast<QQuickVisualDataModel *>(d->model.data())->componentComplete();
static_cast<QQmlDelegateModel *>(d->model.data())->componentComplete();
QQuickFlickable::componentComplete();
@ -1440,7 +1442,7 @@ QQuickItemViewPrivate::QQuickItemViewPrivate()
, inLayout(false), inViewportMoved(false), forceLayout(false), currentIndexCleared(false)
, haveHighlightRange(false), autoHighlight(true), highlightRangeStartValid(false), highlightRangeEndValid(false)
, fillCacheBuffer(false), inRequest(false)
, runDelayedRemoveTransition(false)
, runDelayedRemoveTransition(false), delegateValidated(false)
{
bufferPause.addAnimationChangeListener(this, QAbstractAnimationJob::Completion);
bufferPause.setLoopCount(1);
@ -1874,8 +1876,8 @@ bool QQuickItemViewPrivate::applyModelChanges(ChangeResult *totalInsertionResult
totalInsertionResult->visiblePos = prevViewPos;
totalRemovalResult->visiblePos = prevViewPos;
const QVector<QQuickChangeSet::Remove> &removals = currentChanges.pendingChanges.removes();
const QVector<QQuickChangeSet::Insert> &insertions = currentChanges.pendingChanges.inserts();
const QVector<QQmlChangeSet::Remove> &removals = currentChanges.pendingChanges.removes();
const QVector<QQmlChangeSet::Insert> &insertions = currentChanges.pendingChanges.inserts();
ChangeResult insertionResult(prevViewPos);
ChangeResult removalResult(prevViewPos);
@ -1895,7 +1897,7 @@ bool QQuickItemViewPrivate::applyModelChanges(ChangeResult *totalInsertionResult
}
}
if (runDelayedRemoveTransition) {
QQuickChangeSet::Remove removal;
QQmlChangeSet::Remove removal;
for (QList<FxViewItem*>::Iterator it = visibleItems.begin(); it != visibleItems.end();) {
FxViewItem *item = *it;
if (item->index == -1 && !item->attached->delayRemove()) {
@ -1963,7 +1965,7 @@ bool QQuickItemViewPrivate::applyModelChanges(ChangeResult *totalInsertionResult
// Whatever removed/moved items remain are no longer visible items.
prepareRemoveTransitions(&currentChanges.removedItems);
for (QHash<QQuickChangeSet::MoveKey, FxViewItem *>::Iterator it = currentChanges.removedItems.begin();
for (QHash<QQmlChangeSet::MoveKey, FxViewItem *>::Iterator it = currentChanges.removedItems.begin();
it != currentChanges.removedItems.end(); ++it) {
releaseItem(it.value());
}
@ -1992,7 +1994,7 @@ bool QQuickItemViewPrivate::applyModelChanges(ChangeResult *totalInsertionResult
return visibleAffected;
}
bool QQuickItemViewPrivate::applyRemovalChange(const QQuickChangeSet::Remove &removal, ChangeResult *removeResult, int *removedCount)
bool QQuickItemViewPrivate::applyRemovalChange(const QQmlChangeSet::Remove &removal, ChangeResult *removeResult, int *removedCount)
{
Q_Q(QQuickItemView);
bool visibleAffected = false;
@ -2042,7 +2044,7 @@ bool QQuickItemViewPrivate::applyRemovalChange(const QQuickChangeSet::Remove &re
return visibleAffected;
}
void QQuickItemViewPrivate::removeItem(FxViewItem *item, const QQuickChangeSet::Remove &removal, ChangeResult *removeResult)
void QQuickItemViewPrivate::removeItem(FxViewItem *item, const QQmlChangeSet::Remove &removal, ChangeResult *removeResult)
{
if (removeResult->visiblePos.isValid()) {
if (item->position() < removeResult->visiblePos)
@ -2055,7 +2057,7 @@ void QQuickItemViewPrivate::removeItem(FxViewItem *item, const QQuickChangeSet::
item->transitionNextReposition(transitioner, QQuickItemViewTransitioner::MoveTransition, true);
} else {
// track item so it is released later
currentChanges.removedItems.insertMulti(QQuickChangeSet::MoveKey(), item);
currentChanges.removedItems.insertMulti(QQmlChangeSet::MoveKey(), item);
}
if (!removeResult->changedFirstItem && item == *visibleItems.constBegin())
removeResult->changedFirstItem = true;
@ -2120,14 +2122,14 @@ void QQuickItemViewPrivate::prepareVisibleItemTransitions()
visibleItems[i]->prepareTransition(transitioner, viewBounds);
}
void QQuickItemViewPrivate::prepareRemoveTransitions(QHash<QQuickChangeSet::MoveKey, FxViewItem *> *removedItems)
void QQuickItemViewPrivate::prepareRemoveTransitions(QHash<QQmlChangeSet::MoveKey, FxViewItem *> *removedItems)
{
if (!transitioner)
return;
if (transitioner->canTransition(QQuickItemViewTransitioner::RemoveTransition, true)
|| transitioner->canTransition(QQuickItemViewTransitioner::RemoveTransition, false)) {
for (QHash<QQuickChangeSet::MoveKey, FxViewItem *>::Iterator it = removedItems->begin();
for (QHash<QQmlChangeSet::MoveKey, FxViewItem *>::Iterator it = removedItems->begin();
it != removedItems->end(); ) {
bool isRemove = it.key().moveId < 0;
if (isRemove) {
@ -2197,7 +2199,20 @@ FxViewItem *QQuickItemViewPrivate::createItem(int modelIndex, bool asynchronous)
requestedIndex = modelIndex;
inRequest = true;
if (QQuickItem *item = model->item(modelIndex, asynchronous)) {
QObject* object = model->object(modelIndex, asynchronous);
QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
if (!item) {
if (object) {
model->release(object);
if (!delegateValidated) {
delegateValidated = true;
QObject* delegate = q->delegate();
qmlInfo(delegate ? delegate : q) << q->tr("Delegate must be of Item type");
}
}
inRequest = false;
return 0;
} else {
item->setParentItem(q->contentItem());
if (requestedIndex == modelIndex)
requestedIndex = -1;
@ -2212,15 +2227,13 @@ FxViewItem *QQuickItemViewPrivate::createItem(int modelIndex, bool asynchronous)
inRequest = false;
return viewItem;
}
inRequest = false;
return 0;
}
void QQuickItemView::createdItem(int index, QQuickItem *item)
void QQuickItemView::createdItem(int index, QObject* object)
{
Q_D(QQuickItemView);
QQuickItem* item = qmlobject_cast<QQuickItem*>(object);
if (!d->inRequest) {
d->unrequestedItems.insert(item, index);
d->requestedIndex = -1;
@ -2235,16 +2248,21 @@ void QQuickItemView::createdItem(int index, QQuickItem *item)
}
}
void QQuickItemView::initItem(int, QQuickItem *item)
void QQuickItemView::initItem(int, QObject *object)
{
item->setZ(1);
item->setParentItem(contentItem());
QQuickItemPrivate::get(item)->setCulled(true);
QQuickItem* item = qmlobject_cast<QQuickItem*>(object);
if (item) {
item->setZ(1);
item->setParentItem(contentItem());
QQuickItemPrivate::get(item)->setCulled(true);
}
}
void QQuickItemView::destroyingItem(QQuickItem *item)
void QQuickItemView::destroyingItem(QObject *object)
{
Q_D(QQuickItemView);
QQuickItem* item = qmlobject_cast<QQuickItem*>(object);
item->setParentItem(0);
d->unrequestedItems.remove(item);
}
@ -2257,14 +2275,16 @@ bool QQuickItemViewPrivate::releaseItem(FxViewItem *item)
trackedItem = 0;
QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item->item);
itemPrivate->removeItemChangeListener(this, QQuickItemPrivate::Geometry);
QQuickVisualModel::ReleaseFlags flags = model->release(item->item);
QQmlInstanceModel::ReleaseFlags flags = model->release(item->item);
if (flags == 0) {
// item was not destroyed, and we no longer reference it.
QQuickItemPrivate::get(item->item)->setCulled(true);
unrequestedItems.insert(item->item, model->indexOf(item->item, q));
} else if (flags & QQmlInstanceModel::Destroyed) {
item->item->setParentItem(0);
}
delete item;
return flags != QQuickVisualModel::Referenced;
return flags != QQmlInstanceModel::Referenced;
}
QQuickItem *QQuickItemViewPrivate::createHighlightItem()

10
src/quick/items/qquickitemview_p.h
View File

@ -48,7 +48,7 @@ QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
class QQuickChangeSet;
class QQmlChangeSet;
class QQuickItemViewPrivate;
@ -257,10 +257,10 @@ protected:
protected slots:
void destroyRemoved();
void createdItem(int index, QQuickItem *item);
virtual void initItem(int index, QQuickItem *item);
void modelUpdated(const QQuickChangeSet &changeSet, bool reset);
void destroyingItem(QQuickItem *item);
void createdItem(int index, QObject *item);
virtual void initItem(int index, QObject *item);
void modelUpdated(const QQmlChangeSet &changeSet, bool reset);
void destroyingItem(QObject *item);
void animStopped();
void trackedPositionChanged();

29
src/quick/items/qquickitemview_p_p.h
View File

@ -45,9 +45,9 @@
#include "qquickitemview_p.h"
#include "qquickitemviewtransition_p.h"
#include "qquickflickable_p_p.h"
#include "qquickvisualdatamodel_p.h"
#include "qquickvisualitemmodel_p.h"
#include <private/qquickchangeset_p.h>
#include <QtQml/private/qqmlobjectmodel_p.h>
#include <QtQml/private/qqmldelegatemodel_p.h>
#include <QtQml/private/qqmlchangeset_p.h>
QT_BEGIN_HEADER
@ -103,14 +103,14 @@ public:
void prepare(int currentIndex, int count);
void reset();
void applyChanges(const QQuickChangeSet &changeSet);
void applyChanges(const QQmlChangeSet &changeSet);
void applyBufferedChanges(const QQuickItemViewChangeSet &other);
int itemCount;
int newCurrentIndex;
QQuickChangeSet pendingChanges;
QHash<QQuickChangeSet::MoveKey, FxViewItem *> removedItems;
QQmlChangeSet pendingChanges;
QHash<QQmlChangeSet::MoveKey, FxViewItem *> removedItems;
bool active : 1;
bool currentChanged : 1;
@ -209,18 +209,18 @@ public:
void applyPendingChanges();
bool applyModelChanges(ChangeResult *insertionResult, ChangeResult *removalResult);
bool applyRemovalChange(const QQuickChangeSet::Remove &removal, ChangeResult *changeResult, int *removedCount);
void removeItem(FxViewItem *item, const QQuickChangeSet::Remove &removal, ChangeResult *removeResult);
bool applyRemovalChange(const QQmlChangeSet::Remove &removal, ChangeResult *changeResult, int *removedCount);
void removeItem(FxViewItem *item, const QQmlChangeSet::Remove &removal, ChangeResult *removeResult);
void repositionFirstItem(FxViewItem *prevVisibleItemsFirst, qreal prevVisibleItemsFirstPos,
FxViewItem *prevFirstVisible, ChangeResult *insertionResult, ChangeResult *removalResult);
void createTransitioner();
void prepareVisibleItemTransitions();
void prepareRemoveTransitions(QHash<QQuickChangeSet::MoveKey, FxViewItem *> *removedItems);
void prepareRemoveTransitions(QHash<QQmlChangeSet::MoveKey, FxViewItem *> *removedItems);
bool prepareNonVisibleItemTransition(FxViewItem *item, const QRectF &viewBounds);
virtual void viewItemTransitionFinished(QQuickItemViewTransitionableItem *item);
int findMoveKeyIndex(QQuickChangeSet::MoveKey key, const QVector<QQuickChangeSet::Remove> &changes) const;
int findMoveKeyIndex(QQmlChangeSet::MoveKey key, const QVector<QQmlChangeSet::Remove> &changes) const;
void checkVisible() const;
void showVisibleItems() const;
@ -251,7 +251,7 @@ public:
q->polish();
}
QQmlGuard<QQuickVisualModel> model;
QQmlGuard<QQmlInstanceModel> model;
QVariant modelVariant;
int itemCount;
int buffer;
@ -286,8 +286,8 @@ public:
struct MovedItem {
FxViewItem *item;
QQuickChangeSet::MoveKey moveKey;
MovedItem(FxViewItem *i, QQuickChangeSet::MoveKey k)
QQmlChangeSet::MoveKey moveKey;
MovedItem(FxViewItem *i, QQmlChangeSet::MoveKey k)
: item(i), moveKey(k) {}
};
QQuickItemViewTransitioner *transitioner;
@ -309,6 +309,7 @@ public:
bool fillCacheBuffer : 1;
bool inRequest : 1;
bool runDelayedRemoveTransition : 1;
bool delegateValidated : 1;
protected:
virtual Qt::Orientation layoutOrientation() const = 0;
@ -346,7 +347,7 @@ protected:
virtual void layoutVisibleItems(int fromModelIndex = 0) = 0;
virtual void changedVisibleIndex(int newIndex) = 0;
virtual bool applyInsertionChange(const QQuickChangeSet::Insert &insert, ChangeResult *changeResult,
virtual bool applyInsertionChange(const QQmlChangeSet::Insert &insert, ChangeResult *changeResult,
QList<FxViewItem *> *newItems, QList<MovedItem> *movingIntoView) = 0;
virtual bool needsRefillForAddedOrRemovedIndex(int) const { return false; }

21
src/quick/items/qquicklistview.cpp
View File

@ -41,8 +41,8 @@
#include "qquicklistview_p.h"
#include "qquickitemview_p_p.h"
#include "qquickvisualitemmodel_p.h"
#include <private/qqmlobjectmodel_p.h>
#include <QtQml/qqmlexpression.h>
#include <QtQml/qqmlengine.h>
#include <QtQml/qqmlinfo.h>
@ -106,7 +106,7 @@ public:
virtual void setPosition(qreal pos);
virtual void layoutVisibleItems(int fromModelIndex = 0);
virtual bool applyInsertionChange(const QQuickChangeSet::Insert &insert, ChangeResult *changeResult, QList<FxViewItem *> *addedItems, QList<MovedItem> *movingIntoView);
virtual bool applyInsertionChange(const QQmlChangeSet::Insert &insert, ChangeResult *changeResult, QList<FxViewItem *> *addedItems, QList<MovedItem> *movingIntoView);
virtual void translateAndTransitionItemsAfter(int afterIndex, const ChangeResult &insertionResult, const ChangeResult &removalResult);
virtual void updateSectionCriteria();
@ -2803,13 +2803,16 @@ void QQuickListView::geometryChanged(const QRectF &newGeometry, const QRectF &ol
QQuickItemView::geometryChanged(newGeometry, oldGeometry);
}
void QQuickListView::initItem(int index, QQuickItem *item)
void QQuickListView::initItem(int index, QObject *object)
{
QQuickItemView::initItem(index, item);
QQuickListViewAttached *attached = static_cast<QQuickListViewAttached *>(
qmlAttachedPropertiesObject<QQuickListView>(item));
if (attached)
attached->setView(this);
QQuickItemView::initItem(index, object);
QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
if (item) {
QQuickListViewAttached *attached = static_cast<QQuickListViewAttached *>(
qmlAttachedPropertiesObject<QQuickListView>(item));
if (attached)
attached->setView(this);
}
}
@ -2867,7 +2870,7 @@ void QQuickListViewPrivate::updateSectionCriteria()
}
}
bool QQuickListViewPrivate::applyInsertionChange(const QQuickChangeSet::Insert &change, ChangeResult *insertResult, QList<FxViewItem *> *addedItems, QList<MovedItem> *movingIntoView)
bool QQuickListViewPrivate::applyInsertionChange(const QQmlChangeSet::Insert &change, ChangeResult *insertResult, QList<FxViewItem *> *addedItems, QList<MovedItem> *movingIntoView)
{
int modelIndex = change.index;
int count = change.count;

4
src/quick/items/qquicklistview_p.h
View File

@ -96,7 +96,7 @@ private:
};
class QQuickVisualModel;
class QQmlInstanceModel;
class QQuickListViewAttached;
class Q_AUTOTEST_EXPORT QQuickListView : public QQuickItemView
{
@ -169,7 +169,7 @@ protected:
virtual void viewportMoved(Qt::Orientations orient);
virtual void keyPressEvent(QKeyEvent *);
virtual void geometryChanged(const QRectF &newGeometry,const QRectF &oldGeometry);
virtual void initItem(int index, QQuickItem *item);
virtual void initItem(int index, QObject *item);
};
class QQuickListViewAttached : public QQuickItemViewAttached

84
src/quick/items/qquickpathview.cpp
View File

@ -46,8 +46,9 @@
#include <QtQuick/private/qquickstate_p.h>
#include <private/qqmlglobal_p.h>
#include <private/qqmlopenmetaobject_p.h>
#include <private/qquickchangeset_p.h>
#include <private/qqmlchangeset_p.h>
#include <QtQml/qqmlinfo.h>
#include <QtGui/qevent.h>
#include <QtGui/qevent.h>
#include <QtGui/qguiapplication.h>
@ -117,7 +118,7 @@ QQuickPathViewPrivate::QQuickPathViewPrivate()
, offset(0.0), offsetAdj(0.0), mappedRange(1.0), mappedCache(0.0)
, stealMouse(false), ownModel(false), interactive(true), haveHighlightRange(true)
, autoHighlight(true), highlightUp(false), layoutScheduled(false)
, moving(false), flicking(false), dragging(false), inRequest(false)
, moving(false), flicking(false), dragging(false), inRequest(false), delegateValidated(false)
, dragMargin(0), deceleration(100), maximumFlickVelocity(QML_FLICK_DEFAULTMAXVELOCITY)
, moveOffset(this, &QQuickPathViewPrivate::setAdjustedOffset), flickDuration(0)
, firstIndex(-1), pathItems(-1), requestedIndex(-1), cacheSize(0), requestedZ(0)
@ -150,8 +151,18 @@ QQuickItem *QQuickPathViewPrivate::getItem(int modelIndex, qreal z, bool async)
requestedIndex = modelIndex;
requestedZ = z;
inRequest = true;
QQuickItem *item = model->item(modelIndex, async);
if (item) {
QObject *object = model->object(modelIndex, async);
QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
if (!item) {
if (object) {
model->release(object);
if (!delegateValidated) {
delegateValidated = true;
QObject* delegate = q->delegate();
qmlInfo(delegate ? delegate : q) << q->tr("Delegate must be of Item type");
}
}
} else {
item->setParentItem(q);
requestedIndex = -1;
QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
@ -161,9 +172,10 @@ QQuickItem *QQuickPathViewPrivate::getItem(int modelIndex, qreal z, bool async)
return item;
}
void QQuickPathView::createdItem(int index, QQuickItem *item)
void QQuickPathView::createdItem(int index, QObject *object)
{
Q_D(QQuickPathView);
QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
if (d->requestedIndex != index) {
qPathViewAttachedType = d->attachedType();
QQuickPathViewAttached *att = static_cast<QQuickPathViewAttached *>(qmlAttachedPropertiesObject<QQuickPathView>(item));
@ -181,10 +193,11 @@ void QQuickPathView::createdItem(int index, QQuickItem *item)
}
}
void QQuickPathView::initItem(int index, QQuickItem *item)
void QQuickPathView::initItem(int index, QObject *object)
{
Q_D(QQuickPathView);
if (d->requestedIndex == index) {
QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
if (item && d->requestedIndex == index) {
QQuickItemPrivate::get(item)->setCulled(true);
item->setParentItem(this);
qPathViewAttachedType = d->attachedType();
@ -209,10 +222,14 @@ void QQuickPathViewPrivate::releaseItem(QQuickItem *item)
return;
QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
itemPrivate->removeItemChangeListener(this, QQuickItemPrivate::Geometry);
if (model->release(item) == 0) {
QQmlInstanceModel::ReleaseFlags flags = model->release(item);
if (!flags) {
// item was not destroyed, and we no longer reference it.
if (QQuickPathViewAttached *att = attached(item))
att->setOnPath(false);
} else if (flags & QQmlInstanceModel::Destroyed) {
// but we still reference it
item->setParentItem(0);
}
}
@ -619,19 +636,19 @@ void QQuickPathView::setModel(const QVariant &model)
return;
if (d->model) {
qmlobject_disconnect(d->model, QQuickVisualModel, SIGNAL(modelUpdated(QQuickChangeSet,bool)),
this, QQuickPathView, SLOT(modelUpdated(QQuickChangeSet,bool)));
qmlobject_disconnect(d->model, QQuickVisualModel, SIGNAL(createdItem(int,QQuickItem*)),
this, QQuickPathView, SLOT(createdItem(int,QQuickItem*)));
qmlobject_disconnect(d->model, QQuickVisualModel, SIGNAL(initItem(int,QQuickItem*)),
this, QQuickPathView, SLOT(initItem(int,QQuickItem*)));
qmlobject_disconnect(d->model, QQmlInstanceModel, SIGNAL(modelUpdated(QQmlChangeSet,bool)),
this, QQuickPathView, SLOT(modelUpdated(QQmlChangeSet,bool)));
qmlobject_disconnect(d->model, QQmlInstanceModel, SIGNAL(createdItem(int,QObject*)),
this, QQuickPathView, SLOT(createdItem(int,QObject*)));
qmlobject_disconnect(d->model, QQmlInstanceModel, SIGNAL(initItem(int,QObject*)),
this, QQuickPathView, SLOT(initItem(int,QObject*)));
d->clear();
}
d->modelVariant = model;
QObject *object = qvariant_cast<QObject*>(model);
QQuickVisualModel *vim = 0;
if (object && (vim = qobject_cast<QQuickVisualModel *>(object))) {
QQmlInstanceModel *vim = 0;
if (object && (vim = qobject_cast<QQmlInstanceModel *>(object))) {
if (d->ownModel) {
delete d->model;
d->ownModel = false;
@ -639,23 +656,23 @@ void QQuickPathView::setModel(const QVariant &model)
d->model = vim;
} else {
if (!d->ownModel) {
d->model = new QQuickVisualDataModel(qmlContext(this));
d->model = new QQmlDelegateModel(qmlContext(this));
d->ownModel = true;
if (isComponentComplete())
static_cast<QQuickVisualDataModel *>(d->model.data())->componentComplete();
static_cast<QQmlDelegateModel *>(d->model.data())->componentComplete();
}
if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model))
if (QQmlDelegateModel *dataModel = qobject_cast<QQmlDelegateModel*>(d->model))
dataModel->setModel(model);
}
int oldModelCount = d->modelCount;
d->modelCount = 0;
if (d->model) {
qmlobject_connect(d->model, QQuickVisualModel, SIGNAL(modelUpdated(QQuickChangeSet,bool)),
this, QQuickPathView, SLOT(modelUpdated(QQuickChangeSet,bool)));
qmlobject_connect(d->model, QQuickVisualModel, SIGNAL(createdItem(int,QQuickItem*)),
this, QQuickPathView, SLOT(createdItem(int,QQuickItem*)));
qmlobject_connect(d->model, QQuickVisualModel, SIGNAL(initItem(int,QQuickItem*)),
this, QQuickPathView, SLOT(initItem(int,QQuickItem*)));
qmlobject_connect(d->model, QQmlInstanceModel, SIGNAL(modelUpdated(QQmlChangeSet,bool)),
this, QQuickPathView, SLOT(modelUpdated(QQmlChangeSet,bool)));
qmlobject_connect(d->model, QQmlInstanceModel, SIGNAL(createdItem(int,QObject*)),
this, QQuickPathView, SLOT(createdItem(int,QObject*)));
qmlobject_connect(d->model, QQmlInstanceModel, SIGNAL(initItem(int,QObject*)),
this, QQuickPathView, SLOT(initItem(int,QObject*)));
d->modelCount = d->model->count();
}
if (isComponentComplete()) {
@ -1210,7 +1227,7 @@ QQmlComponent *QQuickPathView::delegate() const
{
Q_D(const QQuickPathView);
if (d->model) {
if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model))
if (QQmlDelegateModel *dataModel = qobject_cast<QQmlDelegateModel*>(d->model))
return dataModel->delegate();
}
@ -1223,10 +1240,10 @@ void QQuickPathView::setDelegate(QQmlComponent *delegate)
if (delegate == this->delegate())
return;
if (!d->ownModel) {
d->model = new QQuickVisualDataModel(qmlContext(this));
d->model = new QQmlDelegateModel(qmlContext(this));
d->ownModel = true;
}
if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model)) {
if (QQmlDelegateModel *dataModel = qobject_cast<QQmlDelegateModel*>(d->model)) {
int oldCount = dataModel->count();
dataModel->setDelegate(delegate);
d->modelCount = dataModel->count();
@ -1234,6 +1251,7 @@ void QQuickPathView::setDelegate(QQmlComponent *delegate)
if (oldCount != dataModel->count())
emit countChanged();
emit delegateChanged();
d->delegateValidated = false;
}
}
@ -1821,7 +1839,7 @@ void QQuickPathView::componentComplete()
{
Q_D(QQuickPathView);
if (d->model && d->ownModel)
static_cast<QQuickVisualDataModel *>(d->model.data())->componentComplete();
static_cast<QQmlDelegateModel *>(d->model.data())->componentComplete();
QQuickItem::componentComplete();
@ -1983,7 +2001,7 @@ void QQuickPathView::refill()
d->releaseItem(d->itemCache.takeLast());
}
void QQuickPathView::modelUpdated(const QQuickChangeSet &changeSet, bool reset)
void QQuickPathView::modelUpdated(const QQmlChangeSet &changeSet, bool reset)
{
Q_D(QQuickPathView);
if (!d->model || !d->model->isValid() || !d->path || !isComponentComplete())
@ -2004,7 +2022,7 @@ void QQuickPathView::modelUpdated(const QQuickChangeSet &changeSet, bool reset)
int moveOffset;
bool currentChanged = false;
bool changedOffset = false;
foreach (const QQuickChangeSet::Remove &r, changeSet.removes()) {
foreach (const QQmlChangeSet::Remove &r, changeSet.removes()) {
if (moveId == -1 && d->currentIndex >= r.index + r.count) {
d->currentIndex -= r.count;
currentChanged = true;
@ -2030,7 +2048,7 @@ void QQuickPathView::modelUpdated(const QQuickChangeSet &changeSet, bool reset)
}
d->modelCount -= r.count;
}
foreach (const QQuickChangeSet::Insert &i, changeSet.inserts()) {
foreach (const QQmlChangeSet::Insert &i, changeSet.inserts()) {
if (d->modelCount) {
if (moveId == -1 && i.index <= d->currentIndex) {
d->currentIndex += i.count;
@ -2082,7 +2100,7 @@ void QQuickPathView::modelUpdated(const QQuickChangeSet &changeSet, bool reset)
emit countChanged();
}
void QQuickPathView::destroyingItem(QQuickItem *item)
void QQuickPathView::destroyingItem(QObject *item)
{
Q_UNUSED(item);
}

10
src/quick/items/qquickpathview_p.h
View File

@ -50,7 +50,7 @@ QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
class QQuickChangeSet;
class QQmlChangeSet;
class QQuickPathViewPrivate;
class QQuickPathViewAttached;
@ -216,10 +216,10 @@ private Q_SLOTS:
void refill();
void ticked();
void movementEnding();
void modelUpdated(const QQuickChangeSet &changeSet, bool reset);
void createdItem(int index, QQuickItem *item);
void initItem(int index, QQuickItem *item);
void destroyingItem(QQuickItem *item);
void modelUpdated(const QQmlChangeSet &changeSet, bool reset);
void createdItem(int index, QObject *item);
void initItem(int index, QObject *item);
void destroyingItem(QObject *item);
void pathUpdated();
private:

5
src/quick/items/qquickpathview_p_p.h
View File

@ -55,7 +55,6 @@
#include "qquickpathview_p.h"
#include "qquickitem_p.h"
#include "qquickvisualdatamodel_p.h"
#include <QtQml/qqml.h>
#include <QtCore/qdatetime.h>
@ -63,6 +62,7 @@
#include <private/qquickanimation_p_p.h>
#include <private/qqmlguard_p.h>
#include <private/qqmldelegatemodel_p.h>
#include <private/qquicktimeline_p_p.h>
QT_BEGIN_NAMESPACE
@ -152,6 +152,7 @@ public:
bool dragging : 1;
bool requestedOnPath : 1;
bool inRequest : 1;
bool delegateValidated : 1;
QElapsedTimer timer;
qint64 lastPosTime;
QPointF lastPos;
@ -168,7 +169,7 @@ public:
qreal requestedZ;
QList<QQuickItem *> items;
QList<QQuickItem *> itemCache;
QQmlGuard<QQuickVisualModel> model;
QQmlGuard<QQmlInstanceModel> model;
QVariant modelVariant;
enum MovementReason { Other, SetIndex, Mouse };
MovementReason moveReason;

82
src/quick/items/qquickrepeater.cpp
View File

@ -41,16 +41,18 @@
#include "qquickrepeater_p.h"
#include "qquickrepeater_p_p.h"
#include "qquickvisualdatamodel_p.h"
#include <private/qqmlglobal_p.h>
#include <private/qquicklistaccessor_p.h>
#include <private/qquickchangeset_p.h>
#include <private/qqmllistaccessor_p.h>
#include <private/qqmlchangeset_p.h>
#include <private/qqmldelegatemodel_p.h>
#include <QtQml/QQmlInfo>
QT_BEGIN_NAMESPACE
QQuickRepeaterPrivate::QQuickRepeaterPrivate()
: model(0), ownModel(false), inRequest(false), dataSourceIsObject(false), itemCount(0), createFrom(-1)
: model(0), ownModel(false), inRequest(false), dataSourceIsObject(false), delegateValidated(false), itemCount(0), createFrom(-1)
{
}
@ -192,18 +194,18 @@ void QQuickRepeater::setModel(const QVariant &model)
clear();
if (d->model) {
disconnect(d->model, SIGNAL(modelUpdated(QQuickChangeSet,bool)),
this, SLOT(modelUpdated(QQuickChangeSet,bool)));
disconnect(d->model, SIGNAL(createdItem(int,QQuickItem*)), this, SLOT(createdItem(int,QQuickItem*)));
disconnect(d->model, SIGNAL(initItem(int,QQuickItem*)), this, SLOT(initItem(int,QQuickItem*)));
// disconnect(d->model, SIGNAL(destroyingItem(QQuickItem*)), this, SLOT(destroyingItem(QQuickItem*)));
disconnect(d->model, SIGNAL(modelUpdated(QQmlChangeSet,bool)),
this, SLOT(modelUpdated(QQmlChangeSet,bool)));
disconnect(d->model, SIGNAL(createdItem(int,QObject*)), this, SLOT(createdItem(int,QObject*)));
disconnect(d->model, SIGNAL(initItem(int,QObject*)), this, SLOT(initItem(int,QObject*)));
// disconnect(d->model, SIGNAL(destroyingItem(QObject*)), this, SLOT(destroyingItem(QObject*)));
}
d->dataSource = model;
QObject *object = qvariant_cast<QObject*>(model);
d->dataSourceAsObject = object;
d->dataSourceIsObject = object != 0;
QQuickVisualModel *vim = 0;
if (object && (vim = qobject_cast<QQuickVisualModel *>(object))) {
QQmlInstanceModel *vim = 0;
if (object && (vim = qobject_cast<QQmlInstanceModel *>(object))) {
if (d->ownModel) {
delete d->model;
d->ownModel = false;
@ -211,20 +213,20 @@ void QQuickRepeater::setModel(const QVariant &model)
d->model = vim;
} else {
if (!d->ownModel) {
d->model = new QQuickVisualDataModel(qmlContext(this));
d->model = new QQmlDelegateModel(qmlContext(this));
d->ownModel = true;
if (isComponentComplete())
static_cast<QQuickVisualDataModel *>(d->model)->componentComplete();
static_cast<QQmlDelegateModel *>(d->model)->componentComplete();
}
if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model))
if (QQmlDelegateModel *dataModel = qobject_cast<QQmlDelegateModel*>(d->model))
dataModel->setModel(model);
}
if (d->model) {
connect(d->model, SIGNAL(modelUpdated(QQuickChangeSet,bool)),
this, SLOT(modelUpdated(QQuickChangeSet,bool)));
connect(d->model, SIGNAL(createdItem(int,QQuickItem*)), this, SLOT(createdItem(int,QQuickItem*)));
connect(d->model, SIGNAL(initItem(int,QQuickItem*)), this, SLOT(initItem(int,QQuickItem*)));
// connect(d->model, SIGNAL(destroyingItem(QQuickItem*)), this, SLOT(destroyingItem(QQuickItem*)));
connect(d->model, SIGNAL(modelUpdated(QQmlChangeSet,bool)),
this, SLOT(modelUpdated(QQmlChangeSet,bool)));
connect(d->model, SIGNAL(createdItem(int,QObject*)), this, SLOT(createdItem(int,QObject*)));
connect(d->model, SIGNAL(initItem(int,QObject*)), this, SLOT(initItem(int,QObject*)));
// connect(d->model, SIGNAL(destroyingItem(QObject*)), this, SLOT(destroyingItem(QObject*)));
regenerate();
}
emit modelChanged();
@ -268,7 +270,7 @@ QQmlComponent *QQuickRepeater::delegate() const
{
Q_D(const QQuickRepeater);
if (d->model) {
if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model))
if (QQmlDelegateModel *dataModel = qobject_cast<QQmlDelegateModel*>(d->model))
return dataModel->delegate();
}
@ -278,18 +280,20 @@ QQmlComponent *QQuickRepeater::delegate() const
void QQuickRepeater::setDelegate(QQmlComponent *delegate)
{
Q_D(QQuickRepeater);
if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model))
if (QQmlDelegateModel *dataModel = qobject_cast<QQmlDelegateModel*>(d->model))
if (delegate == dataModel->delegate())
return;
if (!d->ownModel) {
d->model = new QQuickVisualDataModel(qmlContext(this));
d->model = new QQmlDelegateModel(qmlContext(this));
d->ownModel = true;
}
if (QQuickVisualDataModel *dataModel = qobject_cast<QQuickVisualDataModel*>(d->model)) {
if (QQmlDelegateModel *dataModel = qobject_cast<QQmlDelegateModel*>(d->model)) {
dataModel->setDelegate(delegate);
regenerate();
emit delegateChanged();
d->delegateValidated = false;
}
}
@ -324,7 +328,7 @@ void QQuickRepeater::componentComplete()
{
Q_D(QQuickRepeater);
if (d->model && d->ownModel)
static_cast<QQuickVisualDataModel *>(d->model)->componentComplete();
static_cast<QQmlDelegateModel *>(d->model)->componentComplete();
QQuickItem::componentComplete();
regenerate();
if (d->model && d->model->count())
@ -349,6 +353,7 @@ void QQuickRepeater::clear()
QQuickItem *item = d->deletables.at(i);
if (complete)
emit itemRemoved(i, item);
item->setParentItem(0);
d->model->release(item);
}
}
@ -381,8 +386,17 @@ void QQuickRepeaterPrivate::createItems()
inRequest = true;
for (int ii = createFrom; ii < itemCount; ++ii) {
if (!deletables.at(ii)) {
QQuickItem *item = model->item(ii, false);
QObject *object = model->object(ii, false);
QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
if (!item) {
if (object) {
model->release(object);
if (!delegateValidated) {
delegateValidated = true;
QObject* delegate = q->delegate();
qmlInfo(delegate ? delegate : q) << q->tr("Delegate must be of Item type");
}
}
createFrom = ii;
break;
}
@ -406,19 +420,21 @@ void QQuickRepeaterPrivate::createItems()
inRequest = false;
}
void QQuickRepeater::createdItem(int, QQuickItem *)
void QQuickRepeater::createdItem(int, QObject *)
{
Q_D(QQuickRepeater);
if (!d->inRequest)
d->createItems();
}
void QQuickRepeater::initItem(int, QQuickItem *item)
void QQuickRepeater::initItem(int, QObject *object)
{
item->setParentItem(parentItem());
QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
if (item)
item->setParentItem(parentItem());
}
void QQuickRepeater::modelUpdated(const QQuickChangeSet &changeSet, bool reset)
void QQuickRepeater::modelUpdated(const QQmlChangeSet &changeSet, bool reset)
{
Q_D(QQuickRepeater);
@ -434,7 +450,7 @@ void QQuickRepeater::modelUpdated(const QQuickChangeSet &changeSet, bool reset)
int difference = 0;
QHash<int, QVector<QPointer<QQuickItem> > > moved;
foreach (const QQuickChangeSet::Remove &remove, changeSet.removes()) {
foreach (const QQmlChangeSet::Remove &remove, changeSet.removes()) {
int index = qMin(remove.index, d->deletables.count());
int count = qMin(remove.index + remove.count, d->deletables.count()) - index;
if (remove.isMove()) {
@ -446,8 +462,10 @@ void QQuickRepeater::modelUpdated(const QQuickChangeSet &changeSet, bool reset)
QQuickItem *item = d->deletables.at(index);
d->deletables.remove(index);
emit itemRemoved(index, item);
if (item)
if (item) {
item->setParentItem(0);
d->model->release(item);
}
--d->itemCount;
}
@ -455,7 +473,7 @@ void QQuickRepeater::modelUpdated(const QQuickChangeSet &changeSet, bool reset)
}
d->createFrom = -1;
foreach (const QQuickChangeSet::Insert &insert, changeSet.inserts()) {
foreach (const QQmlChangeSet::Insert &insert, changeSet.inserts()) {
int index = qMin(insert.index, d->deletables.count());
if (insert.isMove()) {
QVector<QPointer<QQuickItem> > items = moved.value(insert.moveId);

8
src/quick/items/qquickrepeater_p.h
View File

@ -48,7 +48,7 @@ QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
class QQuickChangeSet;
class QQmlChangeSet;
class QQuickRepeaterPrivate;
class Q_AUTOTEST_EXPORT QQuickRepeater : public QQuickItem
@ -91,9 +91,9 @@ protected:
void itemChange(ItemChange change, const ItemChangeData &value);
private Q_SLOTS:
void createdItem(int index, QQuickItem *item);
void initItem(int, QQuickItem *item);
void modelUpdated(const QQuickChangeSet &changeSet, bool reset);
void createdItem(int index, QObject *item);
void initItem(int, QObject *item);
void modelUpdated(const QQmlChangeSet &changeSet, bool reset);
private:
Q_DISABLE_COPY(QQuickRepeater)

5
src/quick/items/qquickrepeater_p_p.h
View File

@ -61,7 +61,7 @@
QT_BEGIN_NAMESPACE
class QQmlContext;
class QQuickVisualModel;
class QQmlInstanceModel;
class QQuickRepeaterPrivate : public QQuickItemPrivate
{
Q_DECLARE_PUBLIC(QQuickRepeater)
@ -73,12 +73,13 @@ public:
private:
void createItems();
QQuickVisualModel *model;
QQmlInstanceModel *model;
QVariant dataSource;
QQmlGuard<QObject> dataSourceAsObject;
bool ownModel : 1;
bool inRequest : 1;
bool dataSourceIsObject : 1;
bool delegateValidated : 1;
int itemCount;
int createFrom;

2
src/quick/util/qquickutilmodule.cpp
View File

@ -45,7 +45,6 @@
#include "qquickbehavior_p.h"
#include "qquicksmoothedanimation_p.h"
#include "qquickfontloader_p.h"
#include "qquickpackage_p.h"
#include "qquickpropertychanges_p.h"
#include "qquickspringanimation_p.h"
#include "qquickstategroup_p.h"
@ -73,7 +72,6 @@ void QQuickUtilModule::defineModule()
qmlRegisterType<QQuickSmoothedAnimation>("QtQuick",2,0,"SmoothedAnimation");
qmlRegisterType<QQuickFontLoader>("QtQuick",2,0,"FontLoader");
qmlRegisterType<QQuickNumberAnimation>("QtQuick",2,0,"NumberAnimation");
qmlRegisterType<QQuickPackage>("QtQuick",2,0,"Package");
qmlRegisterType<QQuickParallelAnimation>("QtQuick",2,0,"ParallelAnimation");
qmlRegisterType<QQuickPauseAnimation>("QtQuick",2,0,"PauseAnimation");
qmlRegisterType<QQuickPropertyAction>("QtQuick",2,0,"PropertyAction");

8
src/quick/util/util.pri
View File

@ -1,7 +1,6 @@
SOURCES += \
$$PWD/qquickapplication.cpp\
$$PWD/qquickutilmodule.cpp\
$$PWD/qquickpackage.cpp \
$$PWD/qquickanimation.cpp \
$$PWD/qquicksystempalette.cpp \
$$PWD/qquickspringanimation.cpp \
@ -13,15 +12,12 @@ SOURCES += \
$$PWD/qquickpropertychanges.cpp \
$$PWD/qquickstategroup.cpp \
$$PWD/qquicktransition.cpp \
$$PWD/qquicklistaccessor.cpp \
$$PWD/qquicktimeline.cpp \
$$PWD/qquickpixmapcache.cpp \
$$PWD/qquickbehavior.cpp \
$$PWD/qquickfontloader.cpp \
$$PWD/qquickstyledtext.cpp \
$$PWD/qquickpath.cpp \
$$PWD/qquickchangeset.cpp \
$$PWD/qquicklistcompositor.cpp \
$$PWD/qquickpathinterpolator.cpp \
$$PWD/qquickimageprovider.cpp \
$$PWD/qquicksvgparser.cpp \
@ -31,7 +27,6 @@ SOURCES += \
HEADERS += \
$$PWD/qquickapplication_p.h\
$$PWD/qquickutilmodule_p.h\
$$PWD/qquickpackage_p.h \
$$PWD/qquickanimation_p.h \
$$PWD/qquickanimation_p_p.h \
$$PWD/qquicksystempalette_p.h \
@ -46,7 +41,6 @@ HEADERS += \
$$PWD/qquicktransitionmanager_p_p.h \
$$PWD/qquickstategroup_p.h \
$$PWD/qquicktransition_p.h \
$$PWD/qquicklistaccessor_p.h \
$$PWD/qquicktimeline_p_p.h \
$$PWD/qquickpixmapcache_p.h \
$$PWD/qquickbehavior_p.h \
@ -54,8 +48,6 @@ HEADERS += \
$$PWD/qquickstyledtext_p.h \
$$PWD/qquickpath_p.h \
$$PWD/qquickpath_p_p.h \
$$PWD/qquickchangeset_p.h \
$$PWD/qquicklistcompositor_p.h \
$$PWD/qquickpathinterpolator_p.h \
$$PWD/qquickimageprovider.h \
$$PWD/qquicksvgparser_p.h \

4
tests/auto/qml/qml.pro
View File

@ -42,9 +42,9 @@ PRIVATETESTS += \
qqmlvaluetypes \
qqmlvaluetypeproviders \
qqmlbinding \
qquickchangeset \
qqmlchangeset \
qqmlconnections \
qquicklistcompositor \
qqmllistcompositor \
qqmllistmodel \
qqmllistmodelworkerscript \
qquickworkerscript \

10
tests/auto/qml/qqmlchangeset/qqmlchangeset.pro Normal file
View File

@ -0,0 +1,10 @@
CONFIG += testcase
TARGET = tst_qqmlhangeset
macx:CONFIG -= app_bundle
SOURCES += tst_qqmlchangeset.cpp
CONFIG += parallel_test
QT += core-private gui-private qml-private testlib
DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0

106
tests/auto/qml/qquickchangeset/tst_qquickchangeset.cpp → tests/auto/qml/qqmlchangeset/tst_qqmlchangeset.cpp
View File

@ -39,9 +39,9 @@
**
****************************************************************************/
#include <qtest.h>
#include <private/qquickchangeset_p.h>
#include <private/qqmlchangeset_p.h>
class tst_qquickchangeset : public QObject
class tst_qqmlchangeset : public QObject
{
Q_OBJECT
private slots:
@ -140,7 +140,7 @@ public:
bool applyChanges(QVector<int> &list, const QVector<Signal> &changes)
{
QHash<QQuickChangeSet::MoveKey, int> removedValues;
QHash<QQmlChangeSet::MoveKey, int> removedValues;
foreach (const Signal &signal, changes) {
if (signal.isInsert()) {
if (signal.index < 0 || signal.index > list.count()) {
@ -148,7 +148,7 @@ public:
return false;
}
if (signal.moveId != -1) {
QQuickChangeSet::Insert insert(signal.index, signal.count, signal.moveId, signal.offset);
QQmlChangeSet::Insert insert(signal.index, signal.count, signal.moveId, signal.offset);
for (int i = insert.start(); i < insert.end(); ++i)
list.insert(i, removedValues.take(insert.moveKey(i)));
} else {
@ -160,7 +160,7 @@ public:
return false;
}
if (signal.moveId != -1) {
QQuickChangeSet::Remove remove(signal.index, signal.count, signal.moveId, signal.offset);
QQmlChangeSet::Remove remove(signal.index, signal.count, signal.moveId, signal.offset);
for (int i = remove.start(); i < remove.end(); ++i)
removedValues.insert(remove.moveKey(i), list.at(i));
}
@ -184,7 +184,7 @@ public:
};
bool operator ==(const tst_qquickchangeset::Signal &left, const tst_qquickchangeset::Signal &right)
bool operator ==(const tst_qqmlchangeset::Signal &left, const tst_qqmlchangeset::Signal &right)
{
return left.index == right.index
&& left.count == right.count
@ -194,13 +194,13 @@ bool operator ==(const tst_qquickchangeset::Signal &left, const tst_qquickchange
}
QT_BEGIN_NAMESPACE
bool operator ==(const QQuickChangeSet::Change &left, const QQuickChangeSet::Change &right)
bool operator ==(const QQmlChangeSet::Change &left, const QQmlChangeSet::Change &right)
{
return left.index == right.index && left.count == right.count && left.moveId == right.moveId;
}
QT_END_NAMESPACE
QDebug operator <<(QDebug debug, const tst_qquickchangeset::Signal &signal)
QDebug operator <<(QDebug debug, const tst_qqmlchangeset::Signal &signal)
{
if (signal.isInsert() && signal.moveId == -1)
debug.nospace() << "Insert(" << signal.index << "," << signal.count << ")";
@ -217,8 +217,8 @@ QDebug operator <<(QDebug debug, const tst_qquickchangeset::Signal &signal)
return debug;
}
Q_DECLARE_METATYPE(tst_qquickchangeset::SignalList)
Q_DECLARE_METATYPE(tst_qquickchangeset::SignalListList)
Q_DECLARE_METATYPE(tst_qqmlchangeset::SignalList)
Q_DECLARE_METATYPE(tst_qqmlchangeset::SignalListList)
#if 0
# define VERIFY_EXPECTED_OUTPUT \
@ -256,7 +256,7 @@ Q_DECLARE_METATYPE(tst_qquickchangeset::SignalListList)
}
#endif
void tst_qquickchangeset::sequence_data()
void tst_qqmlchangeset::sequence_data()
{
QTest::addColumn<SignalList>("input");
QTest::addColumn<SignalList>("output");
@ -1163,12 +1163,12 @@ void tst_qquickchangeset::sequence_data()
<< Insert(24,1,5,9) << Insert(25,2) << Insert(27,2));
}
void tst_qquickchangeset::sequence()
void tst_qqmlchangeset::sequence()
{
QFETCH(SignalList, input);
QFETCH(SignalList, output);
QQuickChangeSet set;
QQmlChangeSet set;
foreach (const Signal &signal, input) {
if (signal.isRemove())
@ -1182,18 +1182,18 @@ void tst_qquickchangeset::sequence()
}
SignalList changes;
foreach (const QQuickChangeSet::Remove &remove, set.removes())
foreach (const QQmlChangeSet::Remove &remove, set.removes())
changes << Remove(remove.index, remove.count, remove.moveId, remove.offset);
foreach (const QQuickChangeSet::Insert &insert, set.inserts())
foreach (const QQmlChangeSet::Insert &insert, set.inserts())
changes << Insert(insert.index, insert.count, insert.moveId, insert.offset);
foreach (const QQuickChangeSet::Change &change, set.changes())
foreach (const QQmlChangeSet::Change &change, set.changes())
changes << Change(change.index, change.count);
VERIFY_EXPECTED_OUTPUT
QCOMPARE(changes, output);
}
void tst_qquickchangeset::apply_data()
void tst_qqmlchangeset::apply_data()
{
QTest::addColumn<SignalListList>("input");
@ -1297,15 +1297,15 @@ void tst_qquickchangeset::apply_data()
<< (SignalList() << Move(38,23,1,3) << Move(38,31,0,4) << Remove(26,11) << Move(5,7,18,5) << Move(19,0,8,6)));
}
void tst_qquickchangeset::apply()
void tst_qqmlchangeset::apply()
{
QFETCH(SignalListList, input);
QQuickChangeSet set;
QQuickChangeSet linearSet;
QQmlChangeSet set;
QQmlChangeSet linearSet;
foreach (const SignalList &list, input) {
QQuickChangeSet intermediateSet;
QQmlChangeSet intermediateSet;
foreach (const Signal &signal, list) {
if (signal.isRemove()) {
intermediateSet.remove(signal.index, signal.count);
@ -1322,15 +1322,15 @@ void tst_qquickchangeset::apply()
}
SignalList changes;
foreach (const QQuickChangeSet::Remove &remove, set.removes())
foreach (const QQmlChangeSet::Remove &remove, set.removes())
changes << Remove(remove.index, remove.count, remove.moveId, remove.offset);
foreach (const QQuickChangeSet::Insert &insert, set.inserts())
foreach (const QQmlChangeSet::Insert &insert, set.inserts())
changes << Insert(insert.index, insert.count, insert.moveId, insert.offset);
SignalList linearChanges;
foreach (const QQuickChangeSet::Remove &remove, linearSet.removes())
foreach (const QQmlChangeSet::Remove &remove, linearSet.removes())
linearChanges << Remove(remove.index, remove.count, remove.moveId, remove.offset);
foreach (const QQuickChangeSet::Insert &insert, linearSet.inserts())
foreach (const QQmlChangeSet::Insert &insert, linearSet.inserts())
linearChanges << Insert(insert.index, insert.count, insert.moveId, insert.offset);
// The output in the failing tests isn't incorrect, merely sub-optimal.
@ -1343,7 +1343,7 @@ void tst_qquickchangeset::apply()
QCOMPARE(changes, linearChanges);
}
void tst_qquickchangeset::removeConsecutive_data()
void tst_qqmlchangeset::removeConsecutive_data()
{
QTest::addColumn<SignalList>("input");
QTest::addColumn<SignalList>("output");
@ -1359,22 +1359,22 @@ void tst_qquickchangeset::removeConsecutive_data()
<< (SignalList() << Remove(0,2) << Remove(0,1,0,0) << Remove(0,5));
}
void tst_qquickchangeset::removeConsecutive()
void tst_qqmlchangeset::removeConsecutive()
{
QFETCH(SignalList, input);
QFETCH(SignalList, output);
QVector<QQuickChangeSet::Remove> removes;
QVector<QQmlChangeSet::Remove> removes;
foreach (const Signal &signal, input) {
QVERIFY(signal.isRemove());
removes.append(QQuickChangeSet::Remove(signal.index, signal.count, signal.moveId, signal.offset));
removes.append(QQmlChangeSet::Remove(signal.index, signal.count, signal.moveId, signal.offset));
}
QQuickChangeSet set;
QQmlChangeSet set;
set.remove(removes);
SignalList changes;
foreach (const QQuickChangeSet::Remove &remove, set.removes())
foreach (const QQmlChangeSet::Remove &remove, set.removes())
changes << Remove(remove.index, remove.count, remove.moveId, remove.offset);
QVERIFY(set.inserts().isEmpty());
QVERIFY(set.changes().isEmpty());
@ -1383,7 +1383,7 @@ void tst_qquickchangeset::removeConsecutive()
QCOMPARE(changes, output);
}
void tst_qquickchangeset::insertConsecutive_data()
void tst_qqmlchangeset::insertConsecutive_data()
{
QTest::addColumn<SignalList>("input");
QTest::addColumn<SignalList>("output");
@ -1399,22 +1399,22 @@ void tst_qquickchangeset::insertConsecutive_data()
<< (SignalList() << Insert(0,2) << Insert(2,1,0,0) << Insert(3,5));
}
void tst_qquickchangeset::insertConsecutive()
void tst_qqmlchangeset::insertConsecutive()
{
QFETCH(SignalList, input);
QFETCH(SignalList, output);
QVector<QQuickChangeSet::Insert> inserts;
QVector<QQmlChangeSet::Insert> inserts;
foreach (const Signal &signal, input) {
QVERIFY(signal.isInsert());
inserts.append(QQuickChangeSet::Insert(signal.index, signal.count, signal.moveId, signal.offset));
inserts.append(QQmlChangeSet::Insert(signal.index, signal.count, signal.moveId, signal.offset));
}
QQuickChangeSet set;
QQmlChangeSet set;
set.insert(inserts);
SignalList changes;
foreach (const QQuickChangeSet::Insert &insert, set.inserts())
foreach (const QQmlChangeSet::Insert &insert, set.inserts())
changes << Insert(insert.index, insert.count, insert.moveId, insert.offset);
QVERIFY(set.removes().isEmpty());
QVERIFY(set.changes().isEmpty());
@ -1423,9 +1423,9 @@ void tst_qquickchangeset::insertConsecutive()
QCOMPARE(changes, output);
}
void tst_qquickchangeset::copy()
void tst_qqmlchangeset::copy()
{
QQuickChangeSet changeSet;
QQmlChangeSet changeSet;
changeSet.remove(0, 12);
changeSet.remove(5, 4);
changeSet.insert(3, 9);
@ -1433,9 +1433,9 @@ void tst_qquickchangeset::copy()
changeSet.change(24, 8);
changeSet.move(3, 5, 9, 0);
QQuickChangeSet copy(changeSet);
QQmlChangeSet copy(changeSet);
QQuickChangeSet assign;
QQmlChangeSet assign;
assign = changeSet;
copy.move(4, 2, 5, 1);
@ -1453,27 +1453,27 @@ void tst_qquickchangeset::copy()
QCOMPARE(assign.difference(), changeSet.difference());
}
void tst_qquickchangeset::debug()
void tst_qqmlchangeset::debug()
{
QQuickChangeSet changeSet;
QQmlChangeSet changeSet;
changeSet.remove(0, 12);
changeSet.remove(5, 4);
changeSet.insert(3, 9);
changeSet.insert(15, 2);
changeSet.change(24, 8);
QTest::ignoreMessage(QtDebugMsg, "QQuickChangeSet(Remove(0,12) Remove(5,4) Insert(3,9) Insert(15,2) Change(24,8) )");
QTest::ignoreMessage(QtDebugMsg, "QQmlChangeSet(Remove(0,12) Remove(5,4) Insert(3,9) Insert(15,2) Change(24,8) )");
qDebug() << changeSet;
changeSet.clear();
QTest::ignoreMessage(QtDebugMsg, "QQuickChangeSet(Remove(12,4,0,0) Insert(5,4,0,0) )");
QTest::ignoreMessage(QtDebugMsg, "QQmlChangeSet(Remove(12,4,0,0) Insert(5,4,0,0) )");
changeSet.move(12, 5, 4, 0);
qDebug() << changeSet;
}
void tst_qquickchangeset::random_data()
void tst_qqmlchangeset::random_data()
{
QTest::addColumn<int>("seed");
QTest::addColumn<int>("combinations");
@ -1484,7 +1484,7 @@ void tst_qquickchangeset::random_data()
QTest::newRow("3*5") << 32 << 3 << 5;
}
void tst_qquickchangeset::random()
void tst_qqmlchangeset::random()
{
QFETCH(int, seed);
QFETCH(int, combinations);
@ -1494,14 +1494,14 @@ void tst_qquickchangeset::random()
int failures = 0;
for (int i = 0; i < 20000; ++i) {
QQuickChangeSet accumulatedSet;
QQmlChangeSet accumulatedSet;
SignalList input;
int modelCount = 40;
int moveCount = 0;
for (int j = 0; j < combinations; ++j) {
QQuickChangeSet set;
QQmlChangeSet set;
for (int k = 0; k < depth; ++k) {
switch (-(qrand() % 3)) {
case InsertOp: {
@ -1537,9 +1537,9 @@ void tst_qquickchangeset::random()
}
SignalList output;
foreach (const QQuickChangeSet::Remove &remove, accumulatedSet.removes())
foreach (const QQmlChangeSet::Remove &remove, accumulatedSet.removes())
output << Remove(remove.index, remove.count, remove.moveId, remove.offset);
foreach (const QQuickChangeSet::Insert &insert, accumulatedSet.inserts())
foreach (const QQmlChangeSet::Insert &insert, accumulatedSet.inserts())
output << Insert(insert.index, insert.count, insert.moveId, insert.offset);
QVector<int> inputList;
@ -1569,6 +1569,6 @@ void tst_qquickchangeset::random()
QCOMPARE(failures, 0);
}
QTEST_MAIN(tst_qquickchangeset)
QTEST_MAIN(tst_qqmlchangeset)
#include "tst_qquickchangeset.moc"
#include "tst_qqmlchangeset.moc"

4
tests/auto/qml/qquickchangeset/qquickchangeset.pro → tests/auto/qml/qqmllistcompositor/qqmllistcompositor.pro
View File

@ -1,8 +1,8 @@
CONFIG += testcase
TARGET = tst_qquickchangeset
TARGET = tst_qqmllistcompositor
macx:CONFIG -= app_bundle
SOURCES += tst_qquickchangeset.cpp
SOURCES += tst_qqmllistcompositor.cpp
CONFIG += parallel_test

106
tests/auto/qml/qquicklistcompositor/tst_qquicklistcompositor.cpp → tests/auto/qml/qqmllistcompositor/tst_qqmllistcompositor.cpp
View File

@ -39,11 +39,11 @@
**
****************************************************************************/
#include <qtest.h>
#include <private/qquicklistcompositor_p.h>
#include <private/qqmllistcompositor_p.h>
template<typename T, int N> int lengthOf(const T (&)[N]) { return N; }
typedef QQuickListCompositor C;
typedef QQmlListCompositor C;
struct Range
{
@ -70,9 +70,9 @@ template <typename T> struct Array
typedef Array<int> IndexArray;
typedef Array<const void *> ListArray;
typedef QVector<QQuickListCompositor::Remove> RemoveList;
typedef QVector<QQuickListCompositor::Insert> InsertList;
typedef QVector<QQuickListCompositor::Change> ChangeList;
typedef QVector<QQmlListCompositor::Remove> RemoveList;
typedef QVector<QQmlListCompositor::Insert> InsertList;
typedef QVector<QQmlListCompositor::Change> ChangeList;
typedef QVector<Range> RangeList;
@ -102,7 +102,7 @@ QT_END_NAMESPACE
static const C::Group Visible = C::Group(2);
static const C::Group Selection = C::Group(3);
class tst_qquicklistcompositor : public QObject
class tst_qqmllistcompositor : public QObject
{
Q_OBJECT
@ -174,7 +174,7 @@ private slots:
void groupDebug();
};
void tst_qquicklistcompositor::find_data()
void tst_qqmllistcompositor::find_data()
{
QTest::addColumn<RangeList>("ranges");
QTest::addColumn<C::Group>("startGroup");
@ -201,7 +201,7 @@ void tst_qquicklistcompositor::find_data()
<< uint(C::PrependFlag | SelectionFlag | C::DefaultFlag | C::CacheFlag) << 0;
}
void tst_qquicklistcompositor::find()
void tst_qqmllistcompositor::find()
{
QFETCH(RangeList, ranges);
QFETCH(C::Group, startGroup);
@ -215,7 +215,7 @@ void tst_qquicklistcompositor::find()
QFETCH(uint, rangeFlags);
QFETCH(int, rangeIndex);
QQuickListCompositor compositor;
QQmlListCompositor compositor;
compositor.setGroupCount(4);
compositor.setDefaultGroups(VisibleFlag | C::DefaultFlag);
@ -224,7 +224,7 @@ void tst_qquicklistcompositor::find()
compositor.find(startGroup, startIndex);
QQuickListCompositor::iterator it = compositor.find(group, index);
QQmlListCompositor::iterator it = compositor.find(group, index);
QCOMPARE(it.index[C::Cache], cacheIndex);
QCOMPARE(it.index[C::Default], defaultIndex);
QCOMPARE(it.index[Visible], visibleIndex);
@ -233,7 +233,7 @@ void tst_qquicklistcompositor::find()
QCOMPARE(it->index, rangeIndex);
}
void tst_qquicklistcompositor::findInsertPosition_data()
void tst_qqmllistcompositor::findInsertPosition_data()
{
QTest::addColumn<RangeList>("ranges");
QTest::addColumn<C::Group>("group");
@ -265,7 +265,7 @@ void tst_qquicklistcompositor::findInsertPosition_data()
<< uint(0) << 0;
}
void tst_qquicklistcompositor::findInsertPosition()
void tst_qqmllistcompositor::findInsertPosition()
{
QFETCH(RangeList, ranges);
QFETCH(C::Group, group);
@ -277,14 +277,14 @@ void tst_qquicklistcompositor::findInsertPosition()
QFETCH(uint, rangeFlags);
QFETCH(int, rangeIndex);
QQuickListCompositor compositor;
QQmlListCompositor compositor;
compositor.setGroupCount(4);
compositor.setDefaultGroups(VisibleFlag | C::DefaultFlag);
foreach (const Range &range, ranges)
compositor.append(range.list, range.index, range.count, range.flags);
QQuickListCompositor::insert_iterator it = compositor.findInsertPosition(group, index);
QQmlListCompositor::insert_iterator it = compositor.findInsertPosition(group, index);
QCOMPARE(it.index[C::Cache], cacheIndex);
QCOMPARE(it.index[C::Default], defaultIndex);
@ -294,9 +294,9 @@ void tst_qquicklistcompositor::findInsertPosition()
QCOMPARE(it->index, rangeIndex);
}
void tst_qquicklistcompositor::insert()
void tst_qqmllistcompositor::insert()
{
QQuickListCompositor compositor;
QQmlListCompositor compositor;
compositor.setGroupCount(4);
compositor.setDefaultGroups(VisibleFlag | C::DefaultFlag);
@ -383,7 +383,7 @@ void tst_qquicklistcompositor::insert()
}
}
void tst_qquicklistcompositor::clearFlags_data()
void tst_qqmllistcompositor::clearFlags_data()
{
QTest::addColumn<RangeList>("ranges");
QTest::addColumn<C::Group>("group");
@ -518,7 +518,7 @@ void tst_qquicklistcompositor::clearFlags_data()
}
}
void tst_qquicklistcompositor::clearFlags()
void tst_qqmllistcompositor::clearFlags()
{
QFETCH(RangeList, ranges);
QFETCH(C::Group, group);
@ -535,7 +535,7 @@ void tst_qquicklistcompositor::clearFlags()
QFETCH(IndexArray, selectionIndexes);
QFETCH(ListArray, selectionLists);
QQuickListCompositor compositor;
QQmlListCompositor compositor;
compositor.setGroupCount(4);
compositor.setDefaultGroups(VisibleFlag | C::DefaultFlag);
@ -577,7 +577,7 @@ void tst_qquicklistcompositor::clearFlags()
}
}
void tst_qquicklistcompositor::setFlags_data()
void tst_qqmllistcompositor::setFlags_data()
{
QTest::addColumn<RangeList>("ranges");
QTest::addColumn<C::Group>("group");
@ -700,7 +700,7 @@ void tst_qquicklistcompositor::setFlags_data()
}
}
void tst_qquicklistcompositor::setFlags()
void tst_qqmllistcompositor::setFlags()
{
QFETCH(RangeList, ranges);
QFETCH(C::Group, group);
@ -717,7 +717,7 @@ void tst_qquicklistcompositor::setFlags()
QFETCH(IndexArray, selectionIndexes);
QFETCH(ListArray, selectionLists);
QQuickListCompositor compositor;
QQmlListCompositor compositor;
compositor.setGroupCount(4);
compositor.setDefaultGroups(VisibleFlag | C::DefaultFlag);
@ -759,7 +759,7 @@ void tst_qquicklistcompositor::setFlags()
}
}
void tst_qquicklistcompositor::move_data()
void tst_qqmllistcompositor::move_data()
{
QTest::addColumn<RangeList>("ranges");
QTest::addColumn<C::Group>("fromGroup");
@ -985,7 +985,7 @@ void tst_qquicklistcompositor::move_data()
}
}
void tst_qquicklistcompositor::move()
void tst_qqmllistcompositor::move()
{
QFETCH(RangeList, ranges);
QFETCH(C::Group, fromGroup);
@ -1004,7 +1004,7 @@ void tst_qquicklistcompositor::move()
QFETCH(IndexArray, selectionIndexes);
QFETCH(ListArray, selectionLists);
QQuickListCompositor compositor;
QQmlListCompositor compositor;
compositor.setGroupCount(4);
compositor.setDefaultGroups(VisibleFlag | C::DefaultFlag);
@ -1048,11 +1048,11 @@ void tst_qquicklistcompositor::move()
}
}
void tst_qquicklistcompositor::moveFromEnd()
void tst_qqmllistcompositor::moveFromEnd()
{
int listA; void *a = &listA;
QQuickListCompositor compositor;
QQmlListCompositor compositor;
compositor.append(a, 0, 1, C::AppendFlag | C::PrependFlag | C::DefaultFlag);
// Moving an item anchors it to that position.
@ -1074,9 +1074,9 @@ void tst_qquicklistcompositor::moveFromEnd()
QCOMPARE(it.modelIndex(), 0);
}
void tst_qquicklistcompositor::clear()
void tst_qqmllistcompositor::clear()
{
QQuickListCompositor compositor;
QQmlListCompositor compositor;
compositor.setGroupCount(4);
compositor.setDefaultGroups(VisibleFlag | C::DefaultFlag);
@ -1097,7 +1097,7 @@ void tst_qquicklistcompositor::clear()
QCOMPARE(compositor.count(C::Cache), 0);
}
void tst_qquicklistcompositor::listItemsInserted_data()
void tst_qqmllistcompositor::listItemsInserted_data()
{
QTest::addColumn<RangeList>("ranges");
QTest::addColumn<void *>("list");
@ -1226,7 +1226,7 @@ void tst_qquicklistcompositor::listItemsInserted_data()
}
}
void tst_qquicklistcompositor::listItemsInserted()
void tst_qqmllistcompositor::listItemsInserted()
{
QFETCH(RangeList, ranges);
QFETCH(void *, list);
@ -1238,7 +1238,7 @@ void tst_qquicklistcompositor::listItemsInserted()
QFETCH(IndexArray, visibleIndexes);
QFETCH(IndexArray, selectionIndexes);
QQuickListCompositor compositor;
QQmlListCompositor compositor;
compositor.setGroupCount(4);
compositor.setDefaultGroups(VisibleFlag | C::DefaultFlag);
@ -1276,7 +1276,7 @@ void tst_qquicklistcompositor::listItemsInserted()
}
}
void tst_qquicklistcompositor::listItemsRemoved_data()
void tst_qqmllistcompositor::listItemsRemoved_data()
{
QTest::addColumn<RangeList>("ranges");
QTest::addColumn<void *>("list");
@ -1362,7 +1362,7 @@ void tst_qquicklistcompositor::listItemsRemoved_data()
}
}
void tst_qquicklistcompositor::listItemsRemoved()
void tst_qqmllistcompositor::listItemsRemoved()
{
QFETCH(RangeList, ranges);
QFETCH(void *, list);
@ -1374,7 +1374,7 @@ void tst_qquicklistcompositor::listItemsRemoved()
QFETCH(IndexArray, visibleIndexes);
QFETCH(IndexArray, selectionIndexes);
QQuickListCompositor compositor;
QQmlListCompositor compositor;
compositor.setGroupCount(4);
compositor.setDefaultGroups(VisibleFlag | C::DefaultFlag);
@ -1412,7 +1412,7 @@ void tst_qquicklistcompositor::listItemsRemoved()
}
}
void tst_qquicklistcompositor::listItemsMoved_data()
void tst_qqmllistcompositor::listItemsMoved_data()
{
QTest::addColumn<RangeList>("ranges");
QTest::addColumn<void *>("list");
@ -1554,7 +1554,7 @@ void tst_qquicklistcompositor::listItemsMoved_data()
}
}
void tst_qquicklistcompositor::listItemsMoved()
void tst_qqmllistcompositor::listItemsMoved()
{
QFETCH(RangeList, ranges);
QFETCH(void *, list);
@ -1568,7 +1568,7 @@ void tst_qquicklistcompositor::listItemsMoved()
QFETCH(IndexArray, visibleIndexes);
QFETCH(IndexArray, selectionIndexes);
QQuickListCompositor compositor;
QQmlListCompositor compositor;
compositor.setGroupCount(4);
compositor.setDefaultGroups(VisibleFlag | C::DefaultFlag);
@ -1608,7 +1608,7 @@ void tst_qquicklistcompositor::listItemsMoved()
}
}
void tst_qquicklistcompositor::listItemsChanged_data()
void tst_qqmllistcompositor::listItemsChanged_data()
{
QTest::addColumn<RangeList>("ranges");
QTest::addColumn<void *>("list");
@ -1640,7 +1640,7 @@ void tst_qquicklistcompositor::listItemsChanged_data()
<< Change(0, 0, 3, 6, 2, C::DefaultFlag | C::CacheFlag));
}
void tst_qquicklistcompositor::listItemsChanged()
void tst_qqmllistcompositor::listItemsChanged()
{
QFETCH(RangeList, ranges);
QFETCH(void *, list);
@ -1648,7 +1648,7 @@ void tst_qquicklistcompositor::listItemsChanged()
QFETCH(int, count);
QFETCH(ChangeList, expectedChanges);
QQuickListCompositor compositor;
QQmlListCompositor compositor;
compositor.setGroupCount(4);
compositor.setDefaultGroups(VisibleFlag | C::DefaultFlag);
@ -1661,12 +1661,12 @@ void tst_qquicklistcompositor::listItemsChanged()
QCOMPARE(changes, expectedChanges);
}
void tst_qquicklistcompositor::compositorDebug()
void tst_qqmllistcompositor::compositorDebug()
{
void *a = (void *)0xa0;
void *b = (void *)0xb0;
QQuickListCompositor compositor;
QQmlListCompositor compositor;
compositor.setGroupCount(4);
compositor.setDefaultGroups(VisibleFlag | C::DefaultFlag);
compositor.append(a, 0, 2, C::PrependFlag | C::DefaultFlag);
@ -1676,7 +1676,7 @@ void tst_qquicklistcompositor::compositorDebug()
compositor.append(a, 2, 3, C::DefaultFlag);
QTest::ignoreMessage(QtDebugMsg,
"QQuickListCompositor(00110\n"
"QQmlListCompositor(00110\n"
" 0 0 0 0 Range(0xa0 0 2 00P000000000D0\n"
" 0 0 2 0 Range(0xa0 2 3 00P00000000000\n"
" 0 0 2 0 Range(0xa0 5 2 0AP000000000D0\n"
@ -1687,7 +1687,7 @@ void tst_qquicklistcompositor::compositorDebug()
compositor.setFlags(C::Default, 5, 2, SelectionFlag);
QTest::ignoreMessage(QtDebugMsg,
"QQuickListCompositor(20110\n"
"QQmlListCompositor(20110\n"
" 0 0 0 0 Range(0xa0 0 2 00P000000000D0\n"
" 0 0 2 0 Range(0xa0 2 3 00P00000000000\n"
" 0 0 2 0 Range(0xa0 5 2 0AP000000000D0\n"
@ -1698,12 +1698,12 @@ void tst_qquicklistcompositor::compositorDebug()
qDebug() << compositor;
}
void tst_qquicklistcompositor::changeDebug()
void tst_qqmllistcompositor::changeDebug()
{
void *a = (void *)0xa0;
void *b = (void *)0xb0;
QQuickListCompositor compositor;
QQmlListCompositor compositor;
compositor.setGroupCount(4);
compositor.setDefaultGroups(VisibleFlag | C::DefaultFlag);
compositor.append(a, 0, 2, C::PrependFlag | C::DefaultFlag);
@ -1716,14 +1716,14 @@ void tst_qquicklistcompositor::changeDebug()
QTest::ignoreMessage(QtDebugMsg, "Change(-1 2 000000010D0 2 0 7 0)");
qDebug() << QQuickListCompositor::Change(compositor.find(C::Default, 7), 2, SelectionFlag | C::DefaultFlag);
qDebug() << QQmlListCompositor::Change(compositor.find(C::Default, 7), 2, SelectionFlag | C::DefaultFlag);
QTest::ignoreMessage(QtDebugMsg, "Remove(9 4 000000000D0 10 0)");
qDebug() << QQuickListCompositor::Remove(compositor.find(C::Default, 10), 4, C::DefaultFlag, 9);
qDebug() << QQmlListCompositor::Remove(compositor.find(C::Default, 10), 4, C::DefaultFlag, 9);
QTest::ignoreMessage(QtDebugMsg, "Insert(9 4 000000000D0 3 0)");
qDebug() << QQuickListCompositor::Insert(compositor.find(C::Default, 3), 4, C::DefaultFlag, 9);
qDebug() << QQmlListCompositor::Insert(compositor.find(C::Default, 3), 4, C::DefaultFlag, 9);
}
void tst_qquicklistcompositor::groupDebug()
void tst_qqmllistcompositor::groupDebug()
{
QTest::ignoreMessage(QtDebugMsg, "Default ");
qDebug() << C::Default;
@ -1733,8 +1733,8 @@ void tst_qquicklistcompositor::groupDebug()
qDebug() << Selection;
}
QTEST_MAIN(tst_qquicklistcompositor)
QTEST_MAIN(tst_qqmllistcompositor)
#include "tst_qquicklistcompositor.moc"
#include "tst_qqmllistcompositor.moc"

10
tests/auto/qml/qquicklistcompositor/qquicklistcompositor.pro
View File

@ -1,10 +0,0 @@
CONFIG += testcase
TARGET = tst_qquicklistcompositor
macx:CONFIG -= app_bundle
SOURCES += tst_qquicklistcompositor.cpp
CONFIG += parallel_test
QT += core-private gui-private qml-private quick-private testlib
DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0

1
tests/auto/quick/qquickgridview/tst_qquickgridview.cpp
View File

@ -51,7 +51,6 @@
#include <QtQuick/private/qquickitem_p.h>
#include <QtQuick/private/qquickgridview_p.h>
#include <QtQuick/private/qquicktext_p.h>
#include <QtQuick/private/qquickvisualitemmodel_p.h>
#include <QtQml/private/qqmllistmodel_p.h>
#include "../../shared/util.h"
#include "../shared/viewtestutil.h"

8
tests/auto/quick/qquicklistview/tst_qquicklistview.cpp
View File

@ -48,7 +48,7 @@
#include <QtQml/qqmlincubator.h>
#include <QtQuick/private/qquicklistview_p.h>
#include <QtQuick/private/qquicktext_p.h>
#include <QtQuick/private/qquickvisualitemmodel_p.h>
#include <QtQml/private/qqmlobjectmodel_p.h>
#include <QtQml/private/qqmllistmodel_p.h>
#include "../../shared/util.h"
#include "../shared/viewtestutil.h"
@ -2767,7 +2767,7 @@ void tst_QQuickListView::itemList()
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QQuickVisualItemModel *model = window->rootObject()->findChild<QQuickVisualItemModel*>("itemModel");
QQmlObjectModel *model = window->rootObject()->findChild<QQmlObjectModel*>("itemModel");
QTRY_VERIFY(model != 0);
QTRY_VERIFY(model->count() == 3);
@ -2808,7 +2808,7 @@ void tst_QQuickListView::itemListFlicker()
QQuickItem *contentItem = listview->contentItem();
QTRY_VERIFY(contentItem != 0);
QQuickVisualItemModel *model = window->rootObject()->findChild<QQuickVisualItemModel*>("itemModel");
QQmlObjectModel *model = window->rootObject()->findChild<QQmlObjectModel*>("itemModel");
QTRY_VERIFY(model != 0);
QTRY_VERIFY(model->count() == 3);
@ -4605,7 +4605,7 @@ void tst_QQuickListView::rightToLeft()
QTRY_COMPARE(QQuickItemPrivate::get(listview)->polishScheduled, false);
QQuickVisualItemModel *model = window->rootObject()->findChild<QQuickVisualItemModel*>("itemModel");
QQmlObjectModel *model = window->rootObject()->findChild<QQmlObjectModel*>("itemModel");
QTRY_VERIFY(model != 0);
QTRY_VERIFY(model->count() == 3);

264
tests/auto/quick/qquickvisualdatamodel/tst_qquickvisualdatamodel.cpp
View File

@ -52,9 +52,9 @@
#include <QtQuick/qquickview.h>
#include <private/qquicklistview_p.h>
#include <QtQuick/private/qquicktext_p.h>
#include <QtQuick/private/qquickvisualdatamodel_p.h>
#include <QtQml/private/qqmldelegatemodel_p.h>
#include <private/qqmlvaluetype_p.h>
#include <private/qquickchangeset_p.h>
#include <private/qqmlchangeset_p.h>
#include <private/qqmlengine_p.h>
#include <math.h>
#include <QtGui/qstandarditemmodel.h>
@ -360,21 +360,21 @@ public:
int indexCreated;
public Q_SLOTS:
void initItem(int index, QQuickItem *item)
void initItem(int index, QObject *item)
{
itemInitialized = item;
itemInitialized = qobject_cast<QQuickItem*>(item);
indexInitialized = index;
}
void createdItem(int index, QQuickItem *item)
void createdItem(int index, QObject *item)
{
itemCreated = item;
itemCreated = qobject_cast<QQuickItem*>(item);
indexCreated = index;
}
void destroyingItem(QQuickItem *item)
void destroyingItem(QObject *item)
{
itemDestroyed = item;
itemDestroyed = qobject_cast<QQuickItem*>(item);
}
};
@ -452,9 +452,9 @@ private:
template <int N> void get_verify(
const SingleRoleModel &model,
QQuickVisualDataModel *visualModel,
QQuickVisualDataGroup *visibleItems,
QQuickVisualDataGroup *selectedItems,
QQmlDelegateModel *visualModel,
QQmlDataGroup *visibleItems,
QQmlDataGroup *selectedItems,
const int (&mIndex)[N],
const int (&iIndex)[N],
const int (&vIndex)[N],
@ -467,7 +467,7 @@ private:
QQmlEngine engine;
};
Q_DECLARE_METATYPE(QQuickChangeSet)
Q_DECLARE_METATYPE(QQmlChangeSet)
template <typename T> static T evaluate(QObject *scope, const QString &expression)
{
@ -489,7 +489,7 @@ template <> void evaluate<void>(QObject *scope, const QString &expression)
void tst_qquickvisualdatamodel::initTestCase()
{
QQmlDataTest::initTestCase();
qRegisterMetaType<QQuickChangeSet>();
qRegisterMetaType<QQmlChangeSet>();
qmlRegisterType<SingleRoleModel>("tst_qquickvisualdatamodel", 1, 0, "SingleRoleModel");
qmlRegisterType<DataObject>("tst_qquickvisualdatamodel", 1, 0, "DataObject");
@ -517,7 +517,7 @@ void tst_qquickvisualdatamodel::rootIndex()
engine.rootContext()->setContextProperty("myModel", &model);
QQuickVisualDataModel *obj = qobject_cast<QQuickVisualDataModel*>(c.create());
QQmlDelegateModel *obj = qobject_cast<QQmlDelegateModel*>(c.create());
QVERIFY(obj != 0);
QMetaObject::invokeMethod(obj, "setRoot");
@ -611,7 +611,7 @@ void tst_qquickvisualdatamodel::childChanged()
QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
QQuickVisualDataModel *vdm = listview->findChild<QQuickVisualDataModel*>("visualModel");
QQmlDelegateModel *vdm = listview->findChild<QQmlDelegateModel*>("visualModel");
vdm->setRootIndex(QVariant::fromValue(model.indexFromItem(model.item(1,0))));
QCOMPARE(listview->count(), 1);
@ -922,7 +922,7 @@ void tst_qquickvisualdatamodel::noDelegate()
QQuickListView *listview = qobject_cast<QQuickListView*>(view.rootObject());
QVERIFY(listview != 0);
QQuickVisualDataModel *vdm = listview->findChild<QQuickVisualDataModel*>("visualModel");
QQmlDelegateModel *vdm = listview->findChild<QQmlDelegateModel*>("visualModel");
QVERIFY(vdm != 0);
QCOMPARE(vdm->count(), 3);
@ -1052,15 +1052,15 @@ void tst_qquickvisualdatamodel::qaimRowsMoved()
SingleRoleModel model(list);
engine.rootContext()->setContextProperty("myModel", &model);
QQuickVisualDataModel *obj = qobject_cast<QQuickVisualDataModel*>(c.create());
QQmlDelegateModel *obj = qobject_cast<QQmlDelegateModel*>(c.create());
QVERIFY(obj != 0);
QSignalSpy spy(obj, SIGNAL(modelUpdated(QQuickChangeSet,bool)));
QSignalSpy spy(obj, SIGNAL(modelUpdated(QQmlChangeSet,bool)));
model.emitMove(sourceFirst, sourceLast, destinationChild);
QCOMPARE(spy.count(), 1);
QCOMPARE(spy[0].count(), 2);
QQuickChangeSet changeSet = spy[0][0].value<QQuickChangeSet>();
QQmlChangeSet changeSet = spy[0][0].value<QQmlChangeSet>();
QCOMPARE(changeSet.removes().count(), 1);
QCOMPARE(changeSet.removes().at(0).index, expectFrom);
QCOMPARE(changeSet.removes().at(0).count, expectCount);
@ -1115,11 +1115,11 @@ void tst_qquickvisualdatamodel::subtreeRowsMoved()
QQmlComponent component(&engine, testFileUrl("visualdatamodel.qml"));
QScopedPointer<QObject> object(component.create());
QQuickVisualDataModel *vdm = qobject_cast<QQuickVisualDataModel*>(object.data());
QQmlDelegateModel *vdm = qobject_cast<QQmlDelegateModel*>(object.data());
QVERIFY(vdm);
QSignalSpy spy(vdm, SIGNAL(modelUpdated(QQuickChangeSet,bool)));
QQuickChangeSet changeSet;
QSignalSpy spy(vdm, SIGNAL(modelUpdated(QQmlChangeSet,bool)));
QQmlChangeSet changeSet;
QCOMPARE(vdm->count(), 4);
@ -1127,7 +1127,7 @@ void tst_qquickvisualdatamodel::subtreeRowsMoved()
model.move(QModelIndex(), 1, model.index(0, 0), 3, 2);
QCOMPARE(vdm->count(), 2);
QCOMPARE(spy.count(), 1);
changeSet = spy.last().at(0).value<QQuickChangeSet>();
changeSet = spy.last().at(0).value<QQmlChangeSet>();
QCOMPARE(changeSet.removes().count(), 1);
QCOMPARE(changeSet.removes().at(0).index, 1);
QCOMPARE(changeSet.removes().at(0).count, 2);
@ -1137,7 +1137,7 @@ void tst_qquickvisualdatamodel::subtreeRowsMoved()
model.move(model.index(0, 0), 4, QModelIndex(), 2, 1);
QCOMPARE(vdm->count(), 3);
QCOMPARE(spy.count(), 2);
changeSet = spy.last().at(0).value<QQuickChangeSet>();
changeSet = spy.last().at(0).value<QQmlChangeSet>();
QCOMPARE(changeSet.removes().count(), 0);
QCOMPARE(changeSet.inserts().count(), 1);
QCOMPARE(changeSet.inserts().at(0).index, 2);
@ -1147,11 +1147,11 @@ void tst_qquickvisualdatamodel::subtreeRowsMoved()
QCOMPARE(vdm->rootIndex().value<QModelIndex>(), model.index(2, 0));
QCOMPARE(vdm->count(), 3);
QCOMPARE(spy.count(), 4);
changeSet = spy.at(2).at(0).value<QQuickChangeSet>();
changeSet = spy.at(2).at(0).value<QQmlChangeSet>();
QCOMPARE(changeSet.removes().count(), 1);
QCOMPARE(changeSet.removes().at(0).index, 0);
QCOMPARE(changeSet.removes().at(0).count, 3);
changeSet = spy.last().at(0).value<QQuickChangeSet>();
changeSet = spy.last().at(0).value<QQmlChangeSet>();
QCOMPARE(changeSet.inserts().count(), 1);
QCOMPARE(changeSet.inserts().at(0).index, 0);
QCOMPARE(changeSet.inserts().at(0).count, 3);
@ -1182,7 +1182,7 @@ void tst_qquickvisualdatamodel::subtreeRowsMoved()
QCOMPARE(vdm->rootIndex().value<QModelIndex>(), QModelIndex());
QCOMPARE(vdm->count(), 0);
QCOMPARE(spy.count(), 5);
changeSet = spy.last().at(0).value<QQuickChangeSet>();
changeSet = spy.last().at(0).value<QQmlChangeSet>();
QCOMPARE(changeSet.removes().count(), 1);
QCOMPARE(changeSet.removes().at(0).index, 0);
QCOMPARE(changeSet.removes().at(0).count, 3);
@ -1192,7 +1192,7 @@ void tst_qquickvisualdatamodel::subtreeRowsMoved()
QCOMPARE(vdm->rootIndex().value<QModelIndex>(), QModelIndex());
QCOMPARE(vdm->count(), 2);
QCOMPARE(spy.count(), 6);
changeSet = spy.last().at(0).value<QQuickChangeSet>();
changeSet = spy.last().at(0).value<QQmlChangeSet>();
QCOMPARE(changeSet.removes().count(), 0);
QCOMPARE(changeSet.inserts().count(), 1);
QCOMPARE(changeSet.inserts().at(0).index, 0);
@ -1211,17 +1211,17 @@ void tst_qquickvisualdatamodel::watchedRoles()
QQmlComponent component(&engine, testFileUrl("visualdatamodel.qml"));
QScopedPointer<QObject> object(component.create());
QQuickVisualDataModel *vdm = qobject_cast<QQuickVisualDataModel*>(object.data());
QQmlDelegateModel *vdm = qobject_cast<QQmlDelegateModel*>(object.data());
QVERIFY(vdm);
// VisualDataModel doesn't initialize model data until the first item is requested.
QQuickItem *item = vdm->item(0);
QQuickItem *item = qobject_cast<QQuickItem*>(vdm->object(0));
QVERIFY(item);
vdm->release(item);
QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete); // Ensure released items are deleted before test exits.
QSignalSpy spy(vdm, SIGNAL(modelUpdated(QQuickChangeSet,bool)));
QQuickChangeSet changeSet;
QSignalSpy spy(vdm, SIGNAL(modelUpdated(QQmlChangeSet,bool)));
QQmlChangeSet changeSet;
QCOMPARE(vdm->count(), 30);
@ -1238,13 +1238,13 @@ void tst_qquickvisualdatamodel::watchedRoles()
emit model.dataChanged(model.index(0), model.index(4));
QCOMPARE(spy.count(), 1);
changeSet = spy.last().at(0).value<QQuickChangeSet>();
changeSet = spy.last().at(0).value<QQmlChangeSet>();
QCOMPARE(changeSet.changes().at(0).index, 0);
QCOMPARE(changeSet.changes().at(0).count, 5);
emit model.dataChanged(model.index(1), model.index(6), QVector<int>() << QaimModel::Name);
QCOMPARE(spy.count(), 2);
changeSet = spy.last().at(0).value<QQuickChangeSet>();
changeSet = spy.last().at(0).value<QQmlChangeSet>();
QCOMPARE(changeSet.changes().at(0).index, 1);
QCOMPARE(changeSet.changes().at(0).count, 6);
@ -1255,7 +1255,7 @@ void tst_qquickvisualdatamodel::watchedRoles()
emit model.dataChanged(model.index(0), model.index(4));
QCOMPARE(spy.count(), 3);
changeSet = spy.last().at(0).value<QQuickChangeSet>();
changeSet = spy.last().at(0).value<QQmlChangeSet>();
QCOMPARE(changeSet.changes().at(0).index, 0);
QCOMPARE(changeSet.changes().at(0).count, 5);
@ -1264,7 +1264,7 @@ void tst_qquickvisualdatamodel::watchedRoles()
emit model.dataChanged(model.index(8), model.index(8), QVector<int>() << QaimModel::Number);
QCOMPARE(spy.count(), 4);
changeSet = spy.last().at(0).value<QQuickChangeSet>();
changeSet = spy.last().at(0).value<QQmlChangeSet>();
QCOMPARE(changeSet.changes().at(0).index, 8);
QCOMPARE(changeSet.changes().at(0).count, 1);
@ -1272,19 +1272,19 @@ void tst_qquickvisualdatamodel::watchedRoles()
emit model.dataChanged(model.index(0), model.index(4));
QCOMPARE(spy.count(), 5);
changeSet = spy.last().at(0).value<QQuickChangeSet>();
changeSet = spy.last().at(0).value<QQmlChangeSet>();
QCOMPARE(changeSet.changes().at(0).index, 0);
QCOMPARE(changeSet.changes().at(0).count, 5);
emit model.dataChanged(model.index(1), model.index(6), QVector<int>() << QaimModel::Name);
QCOMPARE(spy.count(), 6);
changeSet = spy.last().at(0).value<QQuickChangeSet>();
changeSet = spy.last().at(0).value<QQmlChangeSet>();
QCOMPARE(changeSet.changes().at(0).index, 1);
QCOMPARE(changeSet.changes().at(0).count, 6);
emit model.dataChanged(model.index(8), model.index(8), QVector<int>() << QaimModel::Number);
QCOMPARE(spy.count(), 7);
changeSet = spy.last().at(0).value<QQuickChangeSet>();
changeSet = spy.last().at(0).value<QQmlChangeSet>();
QCOMPARE(changeSet.changes().at(0).index, 8);
QCOMPARE(changeSet.changes().at(0).count, 1);
}
@ -1301,29 +1301,29 @@ void tst_qquickvisualdatamodel::hasModelChildren()
QQmlComponent component(&engine, testFileUrl("visualdatamodel.qml"));
QScopedPointer<QObject> object(component.create());
QQuickVisualDataModel *vdm = qobject_cast<QQuickVisualDataModel*>(object.data());
QQmlDelegateModel *vdm = qobject_cast<QQmlDelegateModel*>(object.data());
QVERIFY(vdm);
QCOMPARE(vdm->count(), 4);
QQuickItem *item = 0;
item = vdm->item(0);
item = qobject_cast<QQuickItem*>(vdm->object(0));
QVERIFY(item);
QCOMPARE(item->property("modelChildren").toBool(), true);
vdm->release(item);
item = vdm->item(1);
item = qobject_cast<QQuickItem*>(vdm->object(1));
QVERIFY(item);
QCOMPARE(item->property("modelChildren").toBool(), false);
vdm->release(item);
item = vdm->item(2);
item = qobject_cast<QQuickItem*>(vdm->object(2));
QVERIFY(item);
QCOMPARE(item->property("modelChildren").toBool(), true);
vdm->release(item);
item = vdm->item(3);
item = qobject_cast<QQuickItem*>(vdm->object(3));
QVERIFY(item);
QCOMPARE(item->property("modelChildren").toBool(), false);
vdm->release(item);
@ -1351,14 +1351,14 @@ void tst_qquickvisualdatamodel::setValue()
QQmlComponent component(&engine, testFileUrl("visualdatamodel.qml"));
QScopedPointer<QObject> object(component.create());
QQuickVisualDataModel *vdm = qobject_cast<QQuickVisualDataModel*>(object.data());
QQmlDelegateModel *vdm = qobject_cast<QQmlDelegateModel*>(object.data());
QVERIFY(vdm);
QCOMPARE(vdm->count(), 3);
QQuickItem *item = 0;
item = vdm->item(0);
item = qobject_cast<QQuickItem*>(vdm->object(0));
QVERIFY(item);
QCOMPARE(evaluate<QString>(item, "display"), QString("Row 1 Item"));
evaluate<void>(item, "display = 'Changed Item 1'");
@ -1412,7 +1412,7 @@ void tst_qquickvisualdatamodel::remove()
QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
QQuickVisualDataModel *visualModel = qobject_cast<QQuickVisualDataModel *>(qvariant_cast<QObject *>(listview->model()));
QQmlDelegateModel *visualModel = qobject_cast<QQmlDelegateModel *>(qvariant_cast<QObject *>(listview->model()));
QVERIFY(visualModel);
{
@ -1521,7 +1521,7 @@ void tst_qquickvisualdatamodel::move()
QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
QQuickVisualDataModel *visualModel = qobject_cast<QQuickVisualDataModel *>(qvariant_cast<QObject *>(listview->model()));
QQmlDelegateModel *visualModel = qobject_cast<QQmlDelegateModel *>(qvariant_cast<QObject *>(listview->model()));
QVERIFY(visualModel);
{
@ -1710,13 +1710,13 @@ void tst_qquickvisualdatamodel::groups()
QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
QQuickVisualDataModel *visualModel = listview->findChild<QQuickVisualDataModel *>("visualModel");
QQmlDelegateModel *visualModel = listview->findChild<QQmlDelegateModel *>("visualModel");
QVERIFY(visualModel);
QQuickVisualDataGroup *visibleItems = listview->findChild<QQuickVisualDataGroup *>("visibleItems");
QQmlDataGroup *visibleItems = listview->findChild<QQmlDataGroup *>("visibleItems");
QVERIFY(visibleItems);
QQuickVisualDataGroup *selectedItems = listview->findChild<QQuickVisualDataGroup *>("selectedItems");
QQmlDataGroup *selectedItems = listview->findChild<QQmlDataGroup *>("selectedItems");
QVERIFY(selectedItems);
const bool f = false;
@ -1939,9 +1939,9 @@ void tst_qquickvisualdatamodel::groups()
template <int N> void tst_qquickvisualdatamodel::get_verify(
const SingleRoleModel &model,
QQuickVisualDataModel *visualModel,
QQuickVisualDataGroup *visibleItems,
QQuickVisualDataGroup *selectedItems,
QQmlDelegateModel *visualModel,
QQmlDataGroup *visibleItems,
QQmlDataGroup *selectedItems,
const int (&mIndex)[N],
const int (&iIndex)[N],
const int (&vIndex)[N],
@ -2030,13 +2030,13 @@ void tst_qquickvisualdatamodel::get()
QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
QQuickVisualDataModel *visualModel = qobject_cast<QQuickVisualDataModel *>(qvariant_cast<QObject *>(listview->model()));
QQmlDelegateModel *visualModel = qobject_cast<QQmlDelegateModel *>(qvariant_cast<QObject *>(listview->model()));
QVERIFY(visualModel);
QQuickVisualDataGroup *visibleItems = visualModel->findChild<QQuickVisualDataGroup *>("visibleItems");
QQmlDataGroup *visibleItems = visualModel->findChild<QQmlDataGroup *>("visibleItems");
QVERIFY(visibleItems);
QQuickVisualDataGroup *selectedItems = visualModel->findChild<QQuickVisualDataGroup *>("selectedItems");
QQmlDataGroup *selectedItems = visualModel->findChild<QQmlDataGroup *>("selectedItems");
QVERIFY(selectedItems);
QV8Engine *v8Engine = QQmlEnginePrivate::getV8Engine(ctxt->engine());
@ -2154,7 +2154,7 @@ void tst_qquickvisualdatamodel::get()
void tst_qquickvisualdatamodel::invalidGroups()
{
QUrl source = testFileUrl("groups-invalid.qml");
QTest::ignoreMessage(QtWarningMsg, (source.toString() + ":12:9: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("Group names must start with a lower case letter")).toUtf8());
QTest::ignoreMessage(QtWarningMsg, (source.toString() + ":12:9: QML VisualDataGroup: " + QQmlDataGroup::tr("Group names must start with a lower case letter")).toUtf8());
QQmlComponent component(&engine, source);
QScopedPointer<QObject> object(component.create());
@ -2326,7 +2326,7 @@ void tst_qquickvisualdatamodel::create()
QQuickItem *contentItem = listview->contentItem();
QVERIFY(contentItem != 0);
QQuickVisualDataModel *visualModel = qobject_cast<QQuickVisualDataModel *>(qvariant_cast<QObject *>(listview->model()));
QQmlDelegateModel *visualModel = qobject_cast<QQmlDelegateModel *>(qvariant_cast<QObject *>(listview->model()));
QVERIFY(visualModel);
QCOMPARE(listview->count(), 20);
@ -2440,7 +2440,7 @@ void tst_qquickvisualdatamodel::incompleteModel()
QScopedPointer<QObject> object(component.beginCreate(engine.rootContext()));
QQuickVisualDataModel *model = qobject_cast<QQuickVisualDataModel *>(object.data());
QQmlDelegateModel *model = qobject_cast<QQmlDelegateModel *>(object.data());
QVERIFY(model);
QSignalSpy itemsSpy(model->items(), SIGNAL(countChanged()));
@ -3665,67 +3665,67 @@ void tst_qquickvisualdatamodel::warnings_data()
QTest::newRow("insert < 0")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.insert(-2, {\"number\": \"eight\"})")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("insert: index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("insert: index out of range"))
<< 4;
QTest::newRow("insert > length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.insert(8, {\"number\": \"eight\"})")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("insert: index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("insert: index out of range"))
<< 4;
QTest::newRow("create < 0")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.create(-2, {\"number\": \"eight\"})")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("create: index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("create: index out of range"))
<< 4;
QTest::newRow("create > length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.create(8, {\"number\": \"eight\"})")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("create: index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("create: index out of range"))
<< 4;
QTest::newRow("resolve from < 0")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.resolve(-2, 3)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("resolve: from index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("resolve: from index out of range"))
<< 4;
QTest::newRow("resolve from > length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.resolve(8, 3)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("resolve: from index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("resolve: from index out of range"))
<< 4;
QTest::newRow("resolve to < 0")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.resolve(3, -2)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("resolve: to index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("resolve: to index out of range"))
<< 4;
QTest::newRow("resolve to > length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.resolve(3, 8)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("resolve: to index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("resolve: to index out of range"))
<< 4;
QTest::newRow("resolve from invalid index")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.resolve(\"two\", 3)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("resolve: from index invalid"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("resolve: from index invalid"))
<< 4;
QTest::newRow("resolve to invalid index")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.resolve(3, \"two\")")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("resolve: to index invalid"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("resolve: to index invalid"))
<< 4;
QTest::newRow("resolve already resolved item")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.resolve(3, 2)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("resolve: from is not an unresolved item"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("resolve: from is not an unresolved item"))
<< 4;
QTest::newRow("resolve already resolved item")
@ -3733,193 +3733,193 @@ void tst_qquickvisualdatamodel::warnings_data()
<< QString("{ items.insert(0, {\"number\": \"eight\"});"
"items.insert(1, {\"number\": \"seven\"});"
"items.resolve(0, 1)}")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("resolve: to is not a model item"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("resolve: to is not a model item"))
<< 6;
QTest::newRow("remove index < 0")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.remove(-2, 1)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("remove: index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("remove: index out of range"))
<< 4;
QTest::newRow("remove index == length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.remove(4, 1)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("remove: index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("remove: index out of range"))
<< 4;
QTest::newRow("remove index > length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.remove(9, 1)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("remove: index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("remove: index out of range"))
<< 4;
QTest::newRow("remove invalid index")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.remove(\"nine\", 1)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("remove: invalid index"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("remove: invalid index"))
<< 4;
QTest::newRow("remove count < 0")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.remove(1, -2)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("remove: invalid count"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("remove: invalid count"))
<< 4;
QTest::newRow("remove index + count > length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.remove(2, 4, \"selected\")")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("remove: invalid count"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("remove: invalid count"))
<< 4;
QTest::newRow("addGroups index < 0")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.addGroups(-2, 1, \"selected\")")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("addGroups: index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("addGroups: index out of range"))
<< 4;
QTest::newRow("addGroups index == length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.addGroups(4, 1, \"selected\")")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("addGroups: index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("addGroups: index out of range"))
<< 4;
QTest::newRow("addGroups index > length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.addGroups(9, 1, \"selected\")")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("addGroups: index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("addGroups: index out of range"))
<< 4;
QTest::newRow("addGroups count < 0")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.addGroups(1, -2, \"selected\")")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("addGroups: invalid count"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("addGroups: invalid count"))
<< 4;
QTest::newRow("addGroups index + count > length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.addGroups(2, 4, \"selected\")")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("addGroups: invalid count"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("addGroups: invalid count"))
<< 4;
QTest::newRow("removeGroups index < 0")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.removeGroups(-2, 1, \"selected\")")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("removeGroups: index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("removeGroups: index out of range"))
<< 4;
QTest::newRow("removeGroups index == length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.removeGroups(4, 1, \"selected\")")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("removeGroups: index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("removeGroups: index out of range"))
<< 4;
QTest::newRow("removeGroups index > length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.removeGroups(9, 1, \"selected\")")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("removeGroups: index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("removeGroups: index out of range"))
<< 4;
QTest::newRow("removeGroups count < 0")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.removeGroups(1, -2, \"selected\")")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("removeGroups: invalid count"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("removeGroups: invalid count"))
<< 4;
QTest::newRow("removeGroups index + count > length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.removeGroups(2, 4, \"selected\")")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("removeGroups: invalid count"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("removeGroups: invalid count"))
<< 4;
QTest::newRow("setGroups index < 0")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.setGroups(-2, 1, \"selected\")")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("setGroups: index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("setGroups: index out of range"))
<< 4;
QTest::newRow("setGroups index == length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.setGroups(4, 1, \"selected\")")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("setGroups: index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("setGroups: index out of range"))
<< 4;
QTest::newRow("setGroups index > length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.setGroups(9, 1, \"selected\")")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("setGroups: index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("setGroups: index out of range"))
<< 4;
QTest::newRow("setGroups count < 0")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.setGroups(1, -2, \"selected\")")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("setGroups: invalid count"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("setGroups: invalid count"))
<< 4;
QTest::newRow("setGroups index + count > length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.setGroups(2, 4, \"selected\")")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("setGroups: invalid count"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("setGroups: invalid count"))
<< 4;
QTest::newRow("move from < 0")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.move(-2, 1, 1)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("move: from index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("move: from index out of range"))
<< 4;
QTest::newRow("move from == length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.move(4, 1, 1)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("move: from index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("move: from index out of range"))
<< 4;
QTest::newRow("move from > length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.move(9, 1, 1)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("move: from index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("move: from index out of range"))
<< 4;
QTest::newRow("move invalid from")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.move(\"nine\", 1, 1)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("move: invalid from index"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("move: invalid from index"))
<< 4;
QTest::newRow("move to < 0")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.move(1, -2, 1)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("move: to index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("move: to index out of range"))
<< 4;
QTest::newRow("move to == length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.move(1, 4, 1)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("move: to index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("move: to index out of range"))
<< 4;
QTest::newRow("move to > length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.move(1, 9, 1)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("move: to index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("move: to index out of range"))
<< 4;
QTest::newRow("move invalid to")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.move(1, \"nine\", 1)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("move: invalid to index"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("move: invalid to index"))
<< 4;
QTest::newRow("move count < 0")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.move(1, 1, -2)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("move: invalid count"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("move: invalid count"))
<< 4;
QTest::newRow("move from + count > length")
<< testFileUrl("listmodelproperties.qml")
<< QString("items.move(2, 1, 4)")
<< ("<Unknown File>: QML VisualDataGroup: " + QQuickVisualDataGroup::tr("move: from index out of range"))
<< ("<Unknown File>: QML VisualDataGroup: " + QQmlDataGroup::tr("move: from index out of range"))
<< 4;
}
@ -3961,19 +3961,19 @@ void tst_qquickvisualdatamodel::invalidAttachment()
QCOMPARE(component.errors().count(), 0);
QVariant property = object->property("invalidVdm");
QCOMPARE(property.userType(), qMetaTypeId<QQuickVisualDataModel *>());
QVERIFY(!property.value<QQuickVisualDataModel *>());
QCOMPARE(property.userType(), qMetaTypeId<QQmlDelegateModel *>());
QVERIFY(!property.value<QQmlDelegateModel *>());
QQuickItem *item = findItem<QQuickItem>(static_cast<QQuickItem *>(object.data()), "delegate");
QVERIFY(item);
property = item->property("validVdm");
QCOMPARE(property.userType(), qMetaTypeId<QQuickVisualDataModel *>());
QVERIFY(property.value<QQuickVisualDataModel *>());
QCOMPARE(property.userType(), qMetaTypeId<QQmlDelegateModel *>());
QVERIFY(property.value<QQmlDelegateModel *>());
property = item->property("invalidVdm");
QCOMPARE(property.userType(), qMetaTypeId<QQuickVisualDataModel *>());
QVERIFY(!property.value<QQuickVisualDataModel *>());
QCOMPARE(property.userType(), qMetaTypeId<QQmlDelegateModel *>());
QVERIFY(!property.value<QQmlDelegateModel *>());
}
void tst_qquickvisualdatamodel::asynchronousInsert_data()
@ -4005,15 +4005,15 @@ void tst_qquickvisualdatamodel::asynchronousInsert()
engine.rootContext()->setContextProperty("myModel", &model);
QQuickVisualDataModel *visualModel = qobject_cast<QQuickVisualDataModel*>(c.create());
QQmlDelegateModel *visualModel = qobject_cast<QQmlDelegateModel*>(c.create());
QVERIFY(visualModel);
ItemRequester requester;
connect(visualModel, SIGNAL(initItem(int,QQuickItem*)), &requester, SLOT(initItem(int,QQuickItem*)));
connect(visualModel, SIGNAL(createdItem(int,QQuickItem*)), &requester, SLOT(createdItem(int,QQuickItem*)));
connect(visualModel, SIGNAL(destroyingItem(QQuickItem*)), &requester, SLOT(destroyingItem(QQuickItem*)));
connect(visualModel, SIGNAL(initItem(int,QObject*)), &requester, SLOT(initItem(int,QObject*)));
connect(visualModel, SIGNAL(createdItem(int,QObject*)), &requester, SLOT(createdItem(int,QObject*)));
connect(visualModel, SIGNAL(destroyingItem(QObject*)), &requester, SLOT(destroyingItem(QObject*)));
QQuickItem *item = visualModel->item(requestIndex, true);
QQuickItem *item = qobject_cast<QQuickItem*>(visualModel->object(requestIndex, true));
QVERIFY(!item);
QVERIFY(!requester.itemInitialized);
@ -4025,7 +4025,7 @@ void tst_qquickvisualdatamodel::asynchronousInsert()
newItems.append(qMakePair(QLatin1String("New item") + QString::number(i), QString(QLatin1String(""))));
model.insertItems(insertIndex, newItems);
item = visualModel->item(completeIndex, false);
item = qobject_cast<QQuickItem*>(visualModel->object(completeIndex, false));
QVERIFY(item);
QCOMPARE(requester.itemInitialized, item);
@ -4070,15 +4070,15 @@ void tst_qquickvisualdatamodel::asynchronousRemove()
engine.rootContext()->setContextProperty("myModel", &model);
QQuickVisualDataModel *visualModel = qobject_cast<QQuickVisualDataModel*>(c.create());
QQmlDelegateModel *visualModel = qobject_cast<QQmlDelegateModel*>(c.create());
QVERIFY(visualModel);
ItemRequester requester;
connect(visualModel, SIGNAL(initItem(int,QQuickItem*)), &requester, SLOT(initItem(int,QQuickItem*)));
connect(visualModel, SIGNAL(createdItem(int,QQuickItem*)), &requester, SLOT(createdItem(int,QQuickItem*)));
connect(visualModel, SIGNAL(destroyingItem(QQuickItem*)), &requester, SLOT(destroyingItem(QQuickItem*)));
connect(visualModel, SIGNAL(initItem(int,QObject*)), &requester, SLOT(initItem(int,QObject*)));
connect(visualModel, SIGNAL(createdItem(int,QObject*)), &requester, SLOT(createdItem(int,QObject*)));
connect(visualModel, SIGNAL(destroyingItem(QObject*)), &requester, SLOT(destroyingItem(QObject*)));
QQuickItem *item = visualModel->item(requestIndex, true);
QQuickItem *item = qobject_cast<QQuickItem*>(visualModel->object(requestIndex, true));
QVERIFY(!item);
QVERIFY(!requester.itemInitialized);
@ -4098,7 +4098,7 @@ void tst_qquickvisualdatamodel::asynchronousRemove()
QCOMPARE(requester.itemCreated, requester.itemInitialized);
QCOMPARE(requester.itemDestroyed, requester.itemInitialized);
} else {
item = visualModel->item(completeIndex, false);
item = qobject_cast<QQuickItem*>(visualModel->object(completeIndex, false));
QVERIFY(item);
QCOMPARE(requester.itemInitialized, item);
@ -4148,15 +4148,15 @@ void tst_qquickvisualdatamodel::asynchronousMove()
engine.rootContext()->setContextProperty("myModel", &model);
QQuickVisualDataModel *visualModel = qobject_cast<QQuickVisualDataModel*>(c.create());
QQmlDelegateModel *visualModel = qobject_cast<QQmlDelegateModel*>(c.create());
QVERIFY(visualModel);
ItemRequester requester;
connect(visualModel, SIGNAL(initItem(int,QQuickItem*)), &requester, SLOT(initItem(int,QQuickItem*)));
connect(visualModel, SIGNAL(createdItem(int,QQuickItem*)), &requester, SLOT(createdItem(int,QQuickItem*)));
connect(visualModel, SIGNAL(destroyingItem(QQuickItem*)), &requester, SLOT(destroyingItem(QQuickItem*)));
connect(visualModel, SIGNAL(initItem(int,QObject*)), &requester, SLOT(initItem(int,QObject*)));
connect(visualModel, SIGNAL(createdItem(int,QObject*)), &requester, SLOT(createdItem(int,QObject*)));
connect(visualModel, SIGNAL(destroyingItem(QObject*)), &requester, SLOT(destroyingItem(QObject*)));
QQuickItem *item = visualModel->item(requestIndex, true);
QQuickItem *item = qobject_cast<QQuickItem*>(visualModel->object(requestIndex, true));
QVERIFY(!item);
QVERIFY(!requester.itemInitialized);
@ -4165,7 +4165,7 @@ void tst_qquickvisualdatamodel::asynchronousMove()
model.moveItems(from, to, count);
item = visualModel->item(completeIndex, false);
item = qobject_cast<QQuickItem*>(visualModel->object(completeIndex, false));
QVERIFY(item);
@ -4196,10 +4196,10 @@ void tst_qquickvisualdatamodel::asynchronousCancel()
engine.rootContext()->setContextProperty("myModel", &model);
QQuickVisualDataModel *visualModel = qobject_cast<QQuickVisualDataModel*>(c.create());
QQmlDelegateModel *visualModel = qobject_cast<QQmlDelegateModel*>(c.create());
QVERIFY(visualModel);
QQuickItem *item = visualModel->item(requestIndex, true);
QQuickItem *item = qobject_cast<QQuickItem*>(visualModel->object(requestIndex, true));
QVERIFY(!item);
QCOMPARE(controller.incubatingObjectCount(), 1);
@ -4221,10 +4221,10 @@ void tst_qquickvisualdatamodel::invalidContext()
QQmlComponent c(&engine, testFileUrl("visualdatamodel.qml"));
QQuickVisualDataModel *visualModel = qobject_cast<QQuickVisualDataModel*>(c.create(context.data()));
QQmlDelegateModel *visualModel = qobject_cast<QQmlDelegateModel*>(c.create(context.data()));
QVERIFY(visualModel);
QQuickItem *item = visualModel->item(4, false);
QQuickItem *item = qobject_cast<QQuickItem*>(visualModel->object(4, false));
QVERIFY(item);
visualModel->release(item);
@ -4232,7 +4232,7 @@ void tst_qquickvisualdatamodel::invalidContext()
model.insertItem(4, "new item", "");
item = visualModel->item(4, false);
item = qobject_cast<QQuickItem*>(visualModel->object(4, false));
QVERIFY(!item);
}