**
****************************************************************************/
-#include "qsgvisualdatamodel_p.h"
-#include "qsgitem.h"
+#include "qquickvisualdatamodel_p.h"
+#include "qquickitem.h"
#include <QtCore/qcoreapplication.h>
#include <QtDeclarative/qdeclarativecontext.h>
#include <private/qdeclarativeglobal_p.h>
#include <private/qmetaobjectbuilder_p.h>
#include <private/qdeclarativeproperty_p.h>
-#include <private/qsgvisualadaptormodel_p.h>
+#include <private/qquickvisualadaptormodel_p.h>
#include <private/qdeclarativechangeset_p.h>
#include <private/qdeclarativelistcompositor_p.h>
#include <private/qdeclarativeengine_p.h>
typedef QDeclarativeListCompositor Compositor;
-class QSGVisualDataGroupEmitter
+class QQuickVisualDataGroupEmitter
{
public:
virtual void emitModelUpdated(const QDeclarativeChangeSet &changeSet, bool reset) = 0;
QIntrusiveListNode emitterNode;
};
-typedef QIntrusiveList<QSGVisualDataGroupEmitter, &QSGVisualDataGroupEmitter::emitterNode> QSGVisualDataGroupEmitterList;
+typedef QIntrusiveList<QQuickVisualDataGroupEmitter, &QQuickVisualDataGroupEmitter::emitterNode> QQuickVisualDataGroupEmitterList;
//---------------------------------------------------------------------------
-class QSGVisualDataGroupPrivate : public QObjectPrivate
+class QQuickVisualDataGroupPrivate : public QObjectPrivate
{
public:
- Q_DECLARE_PUBLIC(QSGVisualDataGroup)
+ Q_DECLARE_PUBLIC(QQuickVisualDataGroup)
- QSGVisualDataGroupPrivate() : group(Compositor::Cache), defaultInclude(false) {}
+ QQuickVisualDataGroupPrivate() : group(Compositor::Cache), defaultInclude(false) {}
- static QSGVisualDataGroupPrivate *get(QSGVisualDataGroup *group) {
- return static_cast<QSGVisualDataGroupPrivate *>(QObjectPrivate::get(group)); }
+ static QQuickVisualDataGroupPrivate *get(QQuickVisualDataGroup *group) {
+ return static_cast<QQuickVisualDataGroupPrivate *>(QObjectPrivate::get(group)); }
- void setModel(QSGVisualDataModel *model, Compositor::Group group);
+ void setModel(QQuickVisualDataModel *model, Compositor::Group group);
void emitChanges(QV8Engine *engine);
void emitModelUpdated(bool reset);
bool parseGroupArgs(QDeclarativeV8Function *args, int *index, int *count, int *groups) const;
Compositor::Group group;
- QDeclarativeGuard<QSGVisualDataModel> model;
- QSGVisualDataGroupEmitterList emitters;
+ QDeclarativeGuard<QQuickVisualDataModel> model;
+ QQuickVisualDataGroupEmitterList emitters;
QDeclarativeChangeSet changeSet;
QString name;
bool defaultInclude;
//---------------------------------------------------------------------------
-class QSGVisualDataModelCacheItem;
-class QSGVisualDataModelCacheMetaType;
-class QSGVisualDataModelParts;
+class QQuickVisualDataModelCacheItem;
+class QQuickVisualDataModelCacheMetaType;
+class QQuickVisualDataModelParts;
-class QSGVisualDataModelPrivate : public QObjectPrivate, public QSGVisualDataGroupEmitter
+class QQuickVisualDataModelPrivate : public QObjectPrivate, public QQuickVisualDataGroupEmitter
{
- Q_DECLARE_PUBLIC(QSGVisualDataModel)
+ Q_DECLARE_PUBLIC(QQuickVisualDataModel)
public:
- QSGVisualDataModelPrivate(QDeclarativeContext *);
+ QQuickVisualDataModelPrivate(QDeclarativeContext *);
- static QSGVisualDataModelPrivate *get(QSGVisualDataModel *m) {
- return static_cast<QSGVisualDataModelPrivate *>(QObjectPrivate::get(m));
+ static QQuickVisualDataModelPrivate *get(QQuickVisualDataModel *m) {
+ return static_cast<QQuickVisualDataModelPrivate *>(QObjectPrivate::get(m));
}
void init();
- void connectModel(QSGVisualAdaptorModel *model);
+ void connectModel(QQuickVisualAdaptorModel *model);
QObject *object(Compositor::Group group, int index, bool complete, bool reference);
void destroy(QObject *object);
- QSGVisualDataModel::ReleaseFlags release(QObject *object);
+ QQuickVisualDataModel::ReleaseFlags release(QObject *object);
QString stringValue(Compositor::Group group, int index, const QString &name);
int cacheIndexOf(QObject *object) const;
void emitCreatedPackage(Compositor::iterator at, QDeclarativePackage *package);
- void emitCreatedItem(Compositor::iterator at, QSGItem *item) {
+ void emitCreatedItem(Compositor::iterator at, QQuickItem *item) {
emit q_func()->createdItem(at.index[m_compositorGroup], item); }
void emitDestroyingPackage(QDeclarativePackage *package);
- void emitDestroyingItem(QSGItem *item) { emit q_func()->destroyingItem(item); }
+ void emitDestroyingItem(QQuickItem *item) { emit q_func()->destroyingItem(item); }
void updateFilterGroup();
void itemsInserted(
const QVector<Compositor::Insert> &inserts,
QVarLengthArray<QVector<QDeclarativeChangeSet::Insert>, Compositor::MaximumGroupCount> *translatedInserts,
- QHash<int, QList<QSGVisualDataModelCacheItem *> > *movedItems = 0);
+ QHash<int, QList<QQuickVisualDataModelCacheItem *> > *movedItems = 0);
void itemsInserted(const QVector<Compositor::Insert> &inserts);
void itemsRemoved(
const QVector<Compositor::Remove> &removes,
QVarLengthArray<QVector<QDeclarativeChangeSet::Remove>, Compositor::MaximumGroupCount> *translatedRemoves,
- QHash<int, QList<QSGVisualDataModelCacheItem *> > *movedItems = 0);
+ QHash<int, QList<QQuickVisualDataModelCacheItem *> > *movedItems = 0);
void itemsRemoved(const QVector<Compositor::Remove> &removes);
void itemsMoved(
const QVector<Compositor::Remove> &removes, const QVector<Compositor::Insert> &inserts);
void emitModelUpdated(const QDeclarativeChangeSet &changeSet, bool reset);
- static void group_append(QDeclarativeListProperty<QSGVisualDataGroup> *property, QSGVisualDataGroup *group);
- static int group_count(QDeclarativeListProperty<QSGVisualDataGroup> *property);
- static QSGVisualDataGroup *group_at(QDeclarativeListProperty<QSGVisualDataGroup> *property, int index);
+ static void group_append(QDeclarativeListProperty<QQuickVisualDataGroup> *property, QQuickVisualDataGroup *group);
+ static int group_count(QDeclarativeListProperty<QQuickVisualDataGroup> *property);
+ static QQuickVisualDataGroup *group_at(QDeclarativeListProperty<QQuickVisualDataGroup> *property, int index);
- QSGVisualAdaptorModel *m_adaptorModel;
+ QQuickVisualAdaptorModel *m_adaptorModel;
QDeclarativeComponent *m_delegate;
- QSGVisualDataModelCacheMetaType *m_cacheMetaType;
+ QQuickVisualDataModelCacheMetaType *m_cacheMetaType;
QDeclarativeGuard<QDeclarativeContext> m_context;
- QList<QSGVisualDataModelCacheItem *> m_cache;
- QSGVisualDataModelParts *m_parts;
- QSGVisualDataGroupEmitterList m_pendingParts;
+ QList<QQuickVisualDataModelCacheItem *> m_cache;
+ QQuickVisualDataModelParts *m_parts;
+ QQuickVisualDataGroupEmitterList m_pendingParts;
QDeclarativeListCompositor m_compositor;
QDeclarativeListCompositor::Group m_compositorGroup;
union {
struct {
- QSGVisualDataGroup *m_cacheItems;
- QSGVisualDataGroup *m_items;
- QSGVisualDataGroup *m_persistedItems;
+ QQuickVisualDataGroup *m_cacheItems;
+ QQuickVisualDataGroup *m_items;
+ QQuickVisualDataGroup *m_persistedItems;
};
- QSGVisualDataGroup *m_groups[Compositor::MaximumGroupCount];
+ QQuickVisualDataGroup *m_groups[Compositor::MaximumGroupCount];
};
int m_groupCount;
};
//---------------------------------------------------------------------------
-class QSGVisualPartsModel : public QSGVisualModel, public QSGVisualDataGroupEmitter
+class QQuickVisualPartsModel : public QQuickVisualModel, public QQuickVisualDataGroupEmitter
{
Q_OBJECT
Q_PROPERTY(QString filterOnGroup READ filterGroup WRITE setFilterGroup NOTIFY filterGroupChanged RESET resetFilterGroup)
public:
- QSGVisualPartsModel(QSGVisualDataModel *model, const QString &part, QObject *parent = 0);
- ~QSGVisualPartsModel();
+ QQuickVisualPartsModel(QQuickVisualDataModel *model, const QString &part, QObject *parent = 0);
+ ~QQuickVisualPartsModel();
QString filterGroup() const;
void setFilterGroup(const QString &group);
int count() const;
bool isValid() const;
- QSGItem *item(int index, bool complete=true);
- ReleaseFlags release(QSGItem *item);
+ QQuickItem *item(int index, bool complete=true);
+ ReleaseFlags release(QQuickItem *item);
bool completePending() const;
void completeItem();
QString stringValue(int index, const QString &role);
void setWatchedRoles(QList<QByteArray> roles);
- int indexOf(QSGItem *item, QObject *objectContext) const;
+ int indexOf(QQuickItem *item, QObject *objectContext) const;
void emitModelUpdated(const QDeclarativeChangeSet &changeSet, bool reset);
void filterGroupChanged();
private:
- QSGVisualDataModel *m_model;
+ QQuickVisualDataModel *m_model;
QHash<QObject *, QDeclarativePackage *> m_packaged;
QString m_part;
QString m_filterGroup;
bool m_inheritGroup;
};
-class QSGVisualDataModelPartsMetaObject : public QDeclarativeOpenMetaObject
+class QQuickVisualDataModelPartsMetaObject : public QDeclarativeOpenMetaObject
{
public:
- QSGVisualDataModelPartsMetaObject(QObject *parent)
+ QQuickVisualDataModelPartsMetaObject(QObject *parent)
: QDeclarativeOpenMetaObject(parent) {}
virtual void propertyCreated(int, QMetaPropertyBuilder &);
virtual QVariant initialValue(int);
};
-class QSGVisualDataModelParts : public QObject
+class QQuickVisualDataModelParts : public QObject
{
Q_OBJECT
public:
- QSGVisualDataModelParts(QSGVisualDataModel *parent);
+ QQuickVisualDataModelParts(QQuickVisualDataModel *parent);
- QSGVisualDataModel *model;
- QList<QSGVisualPartsModel *> models;
+ QQuickVisualDataModel *model;
+ QList<QQuickVisualPartsModel *> models;
};
-void QSGVisualDataModelPartsMetaObject::propertyCreated(int, QMetaPropertyBuilder &prop)
+void QQuickVisualDataModelPartsMetaObject::propertyCreated(int, QMetaPropertyBuilder &prop)
{
prop.setWritable(false);
}
-QVariant QSGVisualDataModelPartsMetaObject::initialValue(int id)
+QVariant QQuickVisualDataModelPartsMetaObject::initialValue(int id)
{
- QSGVisualDataModelParts *parts = static_cast<QSGVisualDataModelParts *>(object());
- QSGVisualPartsModel *m = new QSGVisualPartsModel(
+ QQuickVisualDataModelParts *parts = static_cast<QQuickVisualDataModelParts *>(object());
+ QQuickVisualPartsModel *m = new QQuickVisualPartsModel(
parts->model, QString::fromUtf8(name(id)), parts);
parts->models.append(m);
return QVariant::fromValue(static_cast<QObject *>(m));
}
-QSGVisualDataModelParts::QSGVisualDataModelParts(QSGVisualDataModel *parent)
+QQuickVisualDataModelParts::QQuickVisualDataModelParts(QQuickVisualDataModel *parent)
: QObject(parent), model(parent)
{
- new QSGVisualDataModelPartsMetaObject(this);
+ new QQuickVisualDataModelPartsMetaObject(this);
}
//---------------------------------------------------------------------------
-class QSGVisualDataModelCacheMetaType : public QDeclarativeRefCount
+class QQuickVisualDataModelCacheMetaType : public QDeclarativeRefCount
{
public:
- QSGVisualDataModelCacheMetaType(QV8Engine *engine, QSGVisualDataModel *model, const QStringList &groupNames);
- ~QSGVisualDataModelCacheMetaType();
+ QQuickVisualDataModelCacheMetaType(QV8Engine *engine, QQuickVisualDataModel *model, const QStringList &groupNames);
+ ~QQuickVisualDataModelCacheMetaType();
int parseGroups(const QStringList &groupNames) const;
int parseGroups(QV8Engine *engine, const v8::Local<v8::Value> &groupNames) const;
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);
- QDeclarativeGuard<QSGVisualDataModel> model;
+ QDeclarativeGuard<QQuickVisualDataModel> model;
const int groupCount;
const int memberPropertyOffset;
const int indexPropertyOffset;
v8::Persistent<v8::Function> constructor;
};
-class QSGVisualDataModelCacheItem : public QV8ObjectResource
+class QQuickVisualDataModelCacheItem : public QV8ObjectResource
{
V8_RESOURCE_TYPE(VisualDataItemType)
public:
- QSGVisualDataModelCacheItem(QSGVisualDataModelCacheMetaType *metaType)
+ QQuickVisualDataModelCacheItem(QQuickVisualDataModelCacheMetaType *metaType)
: QV8ObjectResource(metaType->v8Engine)
, metaType(metaType)
, object(0)
metaType->addref();
}
- ~QSGVisualDataModelCacheItem()
+ ~QQuickVisualDataModelCacheItem()
{
Q_ASSERT(scriptRef == 0);
Q_ASSERT(objectRef == 0);
void Dispose();
- QSGVisualDataModelCacheMetaType * const metaType;
+ QQuickVisualDataModelCacheMetaType * const metaType;
QDeclarativeGuard<QObject> object;
- QSGVisualDataModelAttached *attached;
+ QQuickVisualDataModelAttached *attached;
int objectRef;
int scriptRef;
int groups;
int index[Compositor::MaximumGroupCount];
};
-class QSGVisualDataModelAttachedMetaObject : public QAbstractDynamicMetaObject
+class QQuickVisualDataModelAttachedMetaObject : public QAbstractDynamicMetaObject
{
public:
- QSGVisualDataModelAttachedMetaObject(
- QSGVisualDataModelAttached *attached, QSGVisualDataModelCacheMetaType *metaType);
- ~QSGVisualDataModelAttachedMetaObject();
+ QQuickVisualDataModelAttachedMetaObject(
+ QQuickVisualDataModelAttached *attached, QQuickVisualDataModelCacheMetaType *metaType);
+ ~QQuickVisualDataModelAttachedMetaObject();
int metaCall(QMetaObject::Call, int _id, void **);
private:
- QSGVisualDataModelAttached *attached;
- QSGVisualDataModelCacheMetaType *metaType;
+ QQuickVisualDataModelAttached *attached;
+ QQuickVisualDataModelCacheMetaType *metaType;
};
//---------------------------------------------------------------------------
-QHash<QObject*, QSGVisualDataModelAttached*> QSGVisualDataModelAttached::attachedProperties;
+QHash<QObject*, QQuickVisualDataModelAttached*> QQuickVisualDataModelAttached::attachedProperties;
/*!
- \qmlclass VisualDataModel QSGVisualDataModel
+ \qmlclass VisualDataModel QQuickVisualDataModel
\inqmlmodule QtQuick 2
\ingroup qml-working-with-data
\brief The VisualDataModel encapsulates a model and delegate
\snippet doc/src/snippets/declarative/visualdatamodel.qml 0
*/
-QSGVisualDataModelPrivate::QSGVisualDataModelPrivate(QDeclarativeContext *ctxt)
+QQuickVisualDataModelPrivate::QQuickVisualDataModelPrivate(QDeclarativeContext *ctxt)
: m_adaptorModel(0)
, m_delegate(0)
, m_cacheMetaType(0)
{
}
-void QSGVisualDataModelPrivate::connectModel(QSGVisualAdaptorModel *model)
+void QQuickVisualDataModelPrivate::connectModel(QQuickVisualAdaptorModel *model)
{
- Q_Q(QSGVisualDataModel);
+ Q_Q(QQuickVisualDataModel);
QObject::connect(model, SIGNAL(itemsInserted(int,int)), q, SLOT(_q_itemsInserted(int,int)));
QObject::connect(model, SIGNAL(itemsRemoved(int,int)), q, SLOT(_q_itemsRemoved(int,int)));
QObject::connect(model, SIGNAL(modelReset(int,int)), q, SLOT(_q_modelReset(int,int)));
}
-void QSGVisualDataModelPrivate::init()
+void QQuickVisualDataModelPrivate::init()
{
- Q_Q(QSGVisualDataModel);
+ Q_Q(QQuickVisualDataModel);
m_compositor.setRemoveGroups(Compositor::GroupMask & ~Compositor::PersistedFlag);
- m_adaptorModel = new QSGVisualAdaptorModel;
+ m_adaptorModel = new QQuickVisualAdaptorModel;
QObject::connect(m_adaptorModel, SIGNAL(rootIndexChanged()), q, SIGNAL(rootIndexChanged()));
- m_items = new QSGVisualDataGroup(QStringLiteral("items"), q, Compositor::Default, q);
+ m_items = new QQuickVisualDataGroup(QStringLiteral("items"), q, Compositor::Default, q);
m_items->setDefaultInclude(true);
- m_persistedItems = new QSGVisualDataGroup(QStringLiteral("persistedItems"), q, Compositor::Persisted, q);
- QSGVisualDataGroupPrivate::get(m_items)->emitters.insert(this);
+ m_persistedItems = new QQuickVisualDataGroup(QStringLiteral("persistedItems"), q, Compositor::Persisted, q);
+ QQuickVisualDataGroupPrivate::get(m_items)->emitters.insert(this);
}
-QSGVisualDataModel::QSGVisualDataModel()
-: QSGVisualModel(*(new QSGVisualDataModelPrivate(0)))
+QQuickVisualDataModel::QQuickVisualDataModel()
+: QQuickVisualModel(*(new QQuickVisualDataModelPrivate(0)))
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
d->init();
}
-QSGVisualDataModel::QSGVisualDataModel(QDeclarativeContext *ctxt, QObject *parent)
-: QSGVisualModel(*(new QSGVisualDataModelPrivate(ctxt)), parent)
+QQuickVisualDataModel::QQuickVisualDataModel(QDeclarativeContext *ctxt, QObject *parent)
+: QQuickVisualModel(*(new QQuickVisualDataModelPrivate(ctxt)), parent)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
d->init();
}
-QSGVisualDataModel::~QSGVisualDataModel()
+QQuickVisualDataModel::~QQuickVisualDataModel()
{
- Q_D(QSGVisualDataModel);
- foreach (QSGVisualDataModelCacheItem *cacheItem, d->m_cache) {
+ Q_D(QQuickVisualDataModel);
+ foreach (QQuickVisualDataModelCacheItem *cacheItem, d->m_cache) {
cacheItem->object = 0;
cacheItem->objectRef = 0;
if (!cacheItem->isReferenced())
}
-void QSGVisualDataModel::classBegin()
+void QQuickVisualDataModel::classBegin()
{
}
-void QSGVisualDataModel::componentComplete()
+void QQuickVisualDataModel::componentComplete()
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
d->m_complete = true;
int defaultGroups = 0;
QStringList groupNames;
groupNames.append(QStringLiteral("items"));
groupNames.append(QStringLiteral("persistedItems"));
- if (QSGVisualDataGroupPrivate::get(d->m_items)->defaultInclude)
+ if (QQuickVisualDataGroupPrivate::get(d->m_items)->defaultInclude)
defaultGroups |= Compositor::DefaultFlag;
- if (QSGVisualDataGroupPrivate::get(d->m_persistedItems)->defaultInclude)
+ if (QQuickVisualDataGroupPrivate::get(d->m_persistedItems)->defaultInclude)
defaultGroups |= Compositor::PersistedFlag;
for (int i = 3; i < d->m_groupCount; ++i) {
QString name = d->m_groups[i]->name();
--d->m_groupCount;
--i;
} else if (name.at(0).isUpper()) {
- qmlInfo(d->m_groups[i]) << QSGVisualDataGroup::tr("Group names must start with a lower case letter");
+ qmlInfo(d->m_groups[i]) << QQuickVisualDataGroup::tr("Group names must start with a lower case letter");
d->m_groups[i] = d->m_groups[d->m_groupCount - 1];
--d->m_groupCount;
--i;
} else {
groupNames.append(name);
- QSGVisualDataGroupPrivate *group = QSGVisualDataGroupPrivate::get(d->m_groups[i]);
+ QQuickVisualDataGroupPrivate *group = QQuickVisualDataGroupPrivate::get(d->m_groups[i]);
group->setModel(this, Compositor::Group(i));
if (group->defaultInclude)
defaultGroups |= (1 << i);
if (!d->m_context)
d->m_context = qmlContext(this);
- d->m_cacheMetaType = new QSGVisualDataModelCacheMetaType(
+ d->m_cacheMetaType = new QQuickVisualDataModelCacheMetaType(
QDeclarativeEnginePrivate::getV8Engine(d->m_context->engine()), this, groupNames);
d->m_compositor.setGroupCount(d->m_groupCount);
d->updateFilterGroup();
while (!d->m_pendingParts.isEmpty())
- static_cast<QSGVisualPartsModel *>(d->m_pendingParts.first())->updateFilterGroup();
+ static_cast<QQuickVisualPartsModel *>(d->m_pendingParts.first())->updateFilterGroup();
d->connectModel(d->m_adaptorModel);
QVector<Compositor::Insert> inserts;
\sa {qmlmodels}{Data Models}
*/
-QVariant QSGVisualDataModel::model() const
+QVariant QQuickVisualDataModel::model() const
{
- Q_D(const QSGVisualDataModel);
+ Q_D(const QQuickVisualDataModel);
return d->m_adaptorModel->model();
}
-void QSGVisualDataModel::setModel(const QVariant &model)
+void QQuickVisualDataModel::setModel(const QVariant &model)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
d->m_adaptorModel->setModel(model, d->m_context ? d->m_context->engine() : qmlEngine(this));
if (d->m_complete && d->m_adaptorModel->canFetchMore())
QCoreApplication::postEvent(this, new QEvent(QEvent::UpdateRequest));
The index is exposed as an accessible \c index property. Properties of the
model are also available depending upon the type of \l {qmlmodels}{Data Model}.
*/
-QDeclarativeComponent *QSGVisualDataModel::delegate() const
+QDeclarativeComponent *QQuickVisualDataModel::delegate() const
{
- Q_D(const QSGVisualDataModel);
+ Q_D(const QQuickVisualDataModel);
return d->m_delegate;
}
-void QSGVisualDataModel::setDelegate(QDeclarativeComponent *delegate)
+void QQuickVisualDataModel::setDelegate(QDeclarativeComponent *delegate)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (d->m_transaction) {
qmlInfo(this) << tr("The delegate of a VisualDataModel cannot be changed within onUpdated.");
return;
d->m_delegateValidated = false;
if (wasValid && d->m_complete) {
for (int i = 1; i < d->m_groupCount; ++i) {
- QSGVisualDataGroupPrivate::get(d->m_groups[i])->changeSet.remove(
+ QQuickVisualDataGroupPrivate::get(d->m_groups[i])->changeSet.remove(
0, d->m_compositor.count(Compositor::Group(i)));
}
}
if (d->m_complete && d->m_delegate) {
for (int i = 1; i < d->m_groupCount; ++i) {
- QSGVisualDataGroupPrivate::get(d->m_groups[i])->changeSet.insert(
+ QQuickVisualDataGroupPrivate::get(d->m_groups[i])->changeSet.insert(
0, d->m_compositor.count(Compositor::Group(i)));
}
}
\sa modelIndex(), parentModelIndex()
*/
-QVariant QSGVisualDataModel::rootIndex() const
+QVariant QQuickVisualDataModel::rootIndex() const
{
- Q_D(const QSGVisualDataModel);
+ Q_D(const QQuickVisualDataModel);
return d->m_adaptorModel->rootIndex();
}
-void QSGVisualDataModel::setRootIndex(const QVariant &root)
+void QQuickVisualDataModel::setRootIndex(const QVariant &root)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
d->m_adaptorModel->setRootIndex(root);
}
\sa rootIndex
*/
-QVariant QSGVisualDataModel::modelIndex(int idx) const
+QVariant QQuickVisualDataModel::modelIndex(int idx) const
{
- Q_D(const QSGVisualDataModel);
+ Q_D(const QQuickVisualDataModel);
return d->m_adaptorModel->modelIndex(idx);
}
\sa rootIndex
*/
-QVariant QSGVisualDataModel::parentModelIndex() const
+QVariant QQuickVisualDataModel::parentModelIndex() const
{
- Q_D(const QSGVisualDataModel);
+ Q_D(const QQuickVisualDataModel);
return d->m_adaptorModel->parentModelIndex();
}
\qmlproperty int QtQuick2::VisualDataModel::count
*/
-int QSGVisualDataModel::count() const
+int QQuickVisualDataModel::count() const
{
- Q_D(const QSGVisualDataModel);
+ Q_D(const QQuickVisualDataModel);
if (!d->m_delegate)
return 0;
return d->m_compositor.count(d->m_compositorGroup);
}
-void QSGVisualDataModelPrivate::destroy(QObject *object)
+void QQuickVisualDataModelPrivate::destroy(QObject *object)
{
QObjectPrivate *p = QObjectPrivate::get(object);
Q_ASSERT(p->declarativeData);
object->deleteLater();
}
-QSGVisualDataModel::ReleaseFlags QSGVisualDataModelPrivate::release(QObject *object)
+QQuickVisualDataModel::ReleaseFlags QQuickVisualDataModelPrivate::release(QObject *object)
{
- QSGVisualDataModel::ReleaseFlags stat = 0;
+ QQuickVisualDataModel::ReleaseFlags stat = 0;
if (!object)
return stat;
int cacheIndex = cacheIndexOf(object);
if (cacheIndex != -1) {
- QSGVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
+ QQuickVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
if (cacheItem->releaseObject()) {
destroy(object);
cacheItem->object = 0;
- stat |= QSGVisualModel::Destroyed;
+ stat |= QQuickVisualModel::Destroyed;
if (!cacheItem->isReferenced()) {
m_compositor.clearFlags(Compositor::Cache, cacheIndex, 1, Compositor::CacheFlag);
m_cache.removeAt(cacheIndex);
Q_ASSERT(m_cache.count() == m_compositor.count(Compositor::Cache));
}
} else {
- stat |= QSGVisualDataModel::Referenced;
+ stat |= QQuickVisualDataModel::Referenced;
}
}
return stat;
Returns ReleaseStatus flags.
*/
-QSGVisualDataModel::ReleaseFlags QSGVisualDataModel::release(QSGItem *item)
+QQuickVisualDataModel::ReleaseFlags QQuickVisualDataModel::release(QQuickItem *item)
{
- Q_D(QSGVisualDataModel);
- QSGVisualModel::ReleaseFlags stat = d->release(item);
+ Q_D(QQuickVisualDataModel);
+ QQuickVisualModel::ReleaseFlags stat = d->release(item);
if (stat & Destroyed)
item->setParentItem(0);
return stat;
}
-void QSGVisualDataModelPrivate::group_append(
- QDeclarativeListProperty<QSGVisualDataGroup> *property, QSGVisualDataGroup *group)
+void QQuickVisualDataModelPrivate::group_append(
+ QDeclarativeListProperty<QQuickVisualDataGroup> *property, QQuickVisualDataGroup *group)
{
- QSGVisualDataModelPrivate *d = static_cast<QSGVisualDataModelPrivate *>(property->data);
+ QQuickVisualDataModelPrivate *d = static_cast<QQuickVisualDataModelPrivate *>(property->data);
if (d->m_complete)
return;
if (d->m_groupCount == 11) {
- qmlInfo(d->q_func()) << QSGVisualDataModel::tr("The maximum number of supported VisualDataGroups is 8");
+ qmlInfo(d->q_func()) << QQuickVisualDataModel::tr("The maximum number of supported VisualDataGroups is 8");
return;
}
d->m_groups[d->m_groupCount] = group;
d->m_groupCount += 1;
}
-int QSGVisualDataModelPrivate::group_count(
- QDeclarativeListProperty<QSGVisualDataGroup> *property)
+int QQuickVisualDataModelPrivate::group_count(
+ QDeclarativeListProperty<QQuickVisualDataGroup> *property)
{
- QSGVisualDataModelPrivate *d = static_cast<QSGVisualDataModelPrivate *>(property->data);
+ QQuickVisualDataModelPrivate *d = static_cast<QQuickVisualDataModelPrivate *>(property->data);
return d->m_groupCount - 1;
}
-QSGVisualDataGroup *QSGVisualDataModelPrivate::group_at(
- QDeclarativeListProperty<QSGVisualDataGroup> *property, int index)
+QQuickVisualDataGroup *QQuickVisualDataModelPrivate::group_at(
+ QDeclarativeListProperty<QQuickVisualDataGroup> *property, int index)
{
- QSGVisualDataModelPrivate *d = static_cast<QSGVisualDataModelPrivate *>(property->data);
+ QQuickVisualDataModelPrivate *d = static_cast<QQuickVisualDataModelPrivate *>(property->data);
return index >= 0 && index < d->m_groupCount - 1
? d->m_groups[index - 1]
: 0;
\snippet doc/src/snippets/declarative/visualdatagroup.qml 0
*/
-QDeclarativeListProperty<QSGVisualDataGroup> QSGVisualDataModel::groups()
+QDeclarativeListProperty<QQuickVisualDataGroup> QQuickVisualDataModel::groups()
{
- Q_D(QSGVisualDataModel);
- return QDeclarativeListProperty<QSGVisualDataGroup>(
+ Q_D(QQuickVisualDataModel);
+ return QDeclarativeListProperty<QQuickVisualDataGroup>(
this,
d,
- QSGVisualDataModelPrivate::group_append,
- QSGVisualDataModelPrivate::group_count,
- QSGVisualDataModelPrivate::group_at);
+ QQuickVisualDataModelPrivate::group_append,
+ QQuickVisualDataModelPrivate::group_count,
+ QQuickVisualDataModelPrivate::group_at);
}
/*!
This property holds visual data model's default group to which all new items are added.
*/
-QSGVisualDataGroup *QSGVisualDataModel::items()
+QQuickVisualDataGroup *QQuickVisualDataModel::items()
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
return d->m_items;
}
to this group.
*/
-QSGVisualDataGroup *QSGVisualDataModel::persistedItems()
+QQuickVisualDataGroup *QQuickVisualDataModel::persistedItems()
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
return d->m_persistedItems;
}
By default this is the \l items group.
*/
-QString QSGVisualDataModel::filterGroup() const
+QString QQuickVisualDataModel::filterGroup() const
{
- Q_D(const QSGVisualDataModel);
+ Q_D(const QQuickVisualDataModel);
return d->m_filterGroup;
}
-void QSGVisualDataModel::setFilterGroup(const QString &group)
+void QQuickVisualDataModel::setFilterGroup(const QString &group)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (d->m_transaction) {
qmlInfo(this) << tr("The group of a VisualDataModel cannot be changed within onChanged");
}
}
-void QSGVisualDataModel::resetFilterGroup()
+void QQuickVisualDataModel::resetFilterGroup()
{
setFilterGroup(QStringLiteral("items"));
}
-void QSGVisualDataModelPrivate::updateFilterGroup()
+void QQuickVisualDataModelPrivate::updateFilterGroup()
{
- Q_Q(QSGVisualDataModel);
+ Q_Q(QQuickVisualDataModel);
if (!m_cacheMetaType)
return;
}
}
- QSGVisualDataGroupPrivate::get(m_groups[m_compositorGroup])->emitters.insert(this);
+ QQuickVisualDataGroupPrivate::get(m_groups[m_compositorGroup])->emitters.insert(this);
if (m_compositorGroup != previousGroup) {
QVector<QDeclarativeChangeSet::Remove> removes;
QVector<QDeclarativeChangeSet::Insert> inserts;
emit q->countChanged();
if (m_parts) {
- foreach (QSGVisualPartsModel *model, m_parts->models)
+ foreach (QQuickVisualPartsModel *model, m_parts->models)
model->updateFilterGroup(m_compositorGroup, changeSet);
}
}
\sa Package
*/
-QObject *QSGVisualDataModel::parts()
+QObject *QQuickVisualDataModel::parts()
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (!d->m_parts)
- d->m_parts = new QSGVisualDataModelParts(this);
+ d->m_parts = new QQuickVisualDataModelParts(this);
return d->m_parts;
}
-void QSGVisualDataModelPrivate::emitCreatedPackage(Compositor::iterator at, QDeclarativePackage *package)
+void QQuickVisualDataModelPrivate::emitCreatedPackage(Compositor::iterator at, QDeclarativePackage *package)
{
for (int i = 1; i < m_groupCount; ++i)
- QSGVisualDataGroupPrivate::get(m_groups[i])->createdPackage(at.index[i], package);
+ QQuickVisualDataGroupPrivate::get(m_groups[i])->createdPackage(at.index[i], package);
}
-void QSGVisualDataModelPrivate::emitDestroyingPackage(QDeclarativePackage *package)
+void QQuickVisualDataModelPrivate::emitDestroyingPackage(QDeclarativePackage *package)
{
for (int i = 1; i < m_groupCount; ++i)
- QSGVisualDataGroupPrivate::get(m_groups[i])->destroyingPackage(package);
+ QQuickVisualDataGroupPrivate::get(m_groups[i])->destroyingPackage(package);
}
-QObject *QSGVisualDataModelPrivate::object(Compositor::Group group, int index, bool complete, bool reference)
+QObject *QQuickVisualDataModelPrivate::object(Compositor::Group group, int index, bool complete, bool reference)
{
- Q_Q(QSGVisualDataModel);
+ Q_Q(QQuickVisualDataModel);
Compositor::iterator it = m_compositor.find(group, index);
- QSGVisualDataModelCacheItem *cacheItem = it->inCache() ? m_cache.at(it.cacheIndex) : 0;
+ QQuickVisualDataModelCacheItem *cacheItem = it->inCache() ? m_cache.at(it.cacheIndex) : 0;
if (!cacheItem) {
- cacheItem = new QSGVisualDataModelCacheItem(m_cacheMetaType);
+ cacheItem = new QQuickVisualDataModelCacheItem(m_cacheMetaType);
for (int i = 0; i < m_groupCount; ++i)
cacheItem->index[i] = it.index[i];
cacheItem->groups = it->flags & Compositor::GroupMask;
QDeclarativeContext *rootContext = new QDeclarativeContext(
creationContext ? creationContext : m_context.data());
QDeclarativeContext *ctxt = rootContext;
- if (m_adaptorModel->flags() & QSGVisualAdaptorModel::ProxiedObject) {
- if (QSGVisualAdaptorModelProxyInterface *proxy = qobject_cast<QSGVisualAdaptorModelProxyInterface *>(data)) {
+ if (m_adaptorModel->flags() & QQuickVisualAdaptorModel::ProxiedObject) {
+ if (QQuickVisualAdaptorModelProxyInterface *proxy = qobject_cast<QQuickVisualAdaptorModelProxyInterface *>(data)) {
ctxt->setContextObject(proxy->proxiedObject());
ctxt = new QDeclarativeContext(ctxt, ctxt);
}
Q_ASSERT(m_cache.count() == m_compositor.count(Compositor::Cache));
}
- cacheItem->attached = QSGVisualDataModelAttached::properties(cacheItem->object);
+ cacheItem->attached = QQuickVisualDataModelAttached::properties(cacheItem->object);
cacheItem->attached->m_cacheItem = cacheItem;
- new QSGVisualDataModelAttachedMetaObject(cacheItem->attached, m_cacheMetaType);
+ new QQuickVisualDataModelAttachedMetaObject(cacheItem->attached, m_cacheMetaType);
cacheItem->attached->emitChanges();
if (QDeclarativePackage *package = qobject_cast<QDeclarativePackage *>(cacheItem->object)) {
emitCreatedPackage(it, package);
} else if (!reference) {
- if (QSGItem *item = qobject_cast<QSGItem *>(cacheItem->object))
+ if (QQuickItem *item = qobject_cast<QQuickItem *>(cacheItem->object))
emitCreatedItem(it, item);
}
return cacheItem->object;
}
-QSGItem *QSGVisualDataModel::item(int index, bool complete)
+QQuickItem *QQuickVisualDataModel::item(int index, bool complete)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (!d->m_delegate || index < 0 || index >= d->m_compositor.count(d->m_compositorGroup)) {
qWarning() << "VisualDataModel::item: index out range" << index << d->m_compositor.count(d->m_compositorGroup);
return 0;
}
QObject *object = d->object(d->m_compositorGroup, index, complete, true);
- if (QSGItem *item = qobject_cast<QSGItem *>(object))
+ if (QQuickItem *item = qobject_cast<QQuickItem *>(object))
return item;
if (d->m_completePending)
completeItem();
d->release(object);
if (!d->m_delegateValidated) {
if (object)
- qmlInfo(d->m_delegate) << QSGVisualDataModel::tr("Delegate component must be Item type.");
+ qmlInfo(d->m_delegate) << QQuickVisualDataModel::tr("Delegate component must be Item type.");
d->m_delegateValidated = true;
}
return 0;
}
-bool QSGVisualDataModel::completePending() const
+bool QQuickVisualDataModel::completePending() const
{
- Q_D(const QSGVisualDataModel);
+ Q_D(const QQuickVisualDataModel);
return d->m_completePending;
}
-void QSGVisualDataModel::completeItem()
+void QQuickVisualDataModel::completeItem()
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
d->m_delegate->completeCreate();
d->m_completePending = false;
}
-QString QSGVisualDataModelPrivate::stringValue(Compositor::Group group, int index, const QString &name)
+QString QQuickVisualDataModelPrivate::stringValue(Compositor::Group group, int index, const QString &name)
{
Compositor::iterator it = m_compositor.find(group, index);
- if (QSGVisualAdaptorModel *model = it.list<QSGVisualAdaptorModel>()) {
+ if (QQuickVisualAdaptorModel *model = it.list<QQuickVisualAdaptorModel>()) {
return model->stringValue(it.modelIndex(), name);
}
return QString();
}
-QString QSGVisualDataModel::stringValue(int index, const QString &name)
+QString QQuickVisualDataModel::stringValue(int index, const QString &name)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
return d->stringValue(d->m_compositorGroup, index, name);
}
-int QSGVisualDataModelPrivate::cacheIndexOf(QObject *object) const
+int QQuickVisualDataModelPrivate::cacheIndexOf(QObject *object) const
{
for (int cacheIndex = 0; cacheIndex < m_cache.count(); ++cacheIndex) {
if (m_cache.at(cacheIndex)->object == object)
return -1;
}
-int QSGVisualDataModel::indexOf(QSGItem *item, QObject *) const
+int QQuickVisualDataModel::indexOf(QQuickItem *item, QObject *) const
{
- Q_D(const QSGVisualDataModel);
+ Q_D(const QQuickVisualDataModel);
const int cacheIndex = d->cacheIndexOf(item);
return cacheIndex != -1
? d->m_cache.at(cacheIndex)->index[d->m_compositorGroup]
: -1;
}
-void QSGVisualDataModel::setWatchedRoles(QList<QByteArray> roles)
+void QQuickVisualDataModel::setWatchedRoles(QList<QByteArray> roles)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
d->m_adaptorModel->replaceWatchedRoles(d->watchedRoles, roles);
d->watchedRoles = roles;
}
-void QSGVisualDataModelPrivate::addGroups(Compositor::Group group, int index, int count, int groupFlags)
+void QQuickVisualDataModelPrivate::addGroups(Compositor::Group group, int index, int count, int groupFlags)
{
QVector<Compositor::Insert> inserts;
m_compositor.setFlags(group, index, count, groupFlags, &inserts);
emitChanges();
}
-void QSGVisualDataModelPrivate::removeGroups(Compositor::Group group, int index, int count, int groupFlags)
+void QQuickVisualDataModelPrivate::removeGroups(Compositor::Group group, int index, int count, int groupFlags)
{
QVector<Compositor::Remove> removes;
m_compositor.clearFlags(group, index, count, groupFlags, &removes);
emitChanges();
}
-void QSGVisualDataModelPrivate::setGroups(Compositor::Group group, int index, int count, int groupFlags)
+void QQuickVisualDataModelPrivate::setGroups(Compositor::Group group, int index, int count, int groupFlags)
{
QVector<Compositor::Insert> inserts;
m_compositor.setFlags(group, index, count, groupFlags, &inserts);
emitChanges();
}
-bool QSGVisualDataModel::event(QEvent *e)
+bool QQuickVisualDataModel::event(QEvent *e)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (e->type() == QEvent::UpdateRequest)
d->m_adaptorModel->fetchMore();
- return QSGVisualModel::event(e);
+ return QQuickVisualModel::event(e);
}
-void QSGVisualDataModelPrivate::itemsChanged(const QVector<Compositor::Change> &changes)
+void QQuickVisualDataModelPrivate::itemsChanged(const QVector<Compositor::Change> &changes)
{
if (!m_delegate)
return;
}
for (int i = 1; i < m_groupCount; ++i)
- QSGVisualDataGroupPrivate::get(m_groups[i])->changeSet.apply(translatedChanges.at(i));
+ QQuickVisualDataGroupPrivate::get(m_groups[i])->changeSet.apply(translatedChanges.at(i));
}
-void QSGVisualDataModel::_q_itemsChanged(int index, int count)
+void QQuickVisualDataModel::_q_itemsChanged(int index, int count)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (count <= 0)
return;
QVector<Compositor::Change> changes;
d->emitChanges();
}
-void QSGVisualDataModelPrivate::itemsInserted(
+void QQuickVisualDataModelPrivate::itemsInserted(
const QVector<Compositor::Insert> &inserts,
QVarLengthArray<QVector<QDeclarativeChangeSet::Insert>, Compositor::MaximumGroupCount> *translatedInserts,
- QHash<int, QList<QSGVisualDataModelCacheItem *> > *movedItems)
+ QHash<int, QList<QQuickVisualDataModelCacheItem *> > *movedItems)
{
int cacheIndex = 0;
foreach (const Compositor::Insert &insert, inserts) {
for (; cacheIndex < insert.cacheIndex; ++cacheIndex) {
- QSGVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
+ QQuickVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
if (!cacheItem->groups)
continue;
for (int i = 1; i < m_groupCount; ++i)
continue;
if (movedItems && insert.isMove()) {
- QList<QSGVisualDataModelCacheItem *> items = movedItems->take(insert.moveId);
+ QList<QQuickVisualDataModelCacheItem *> items = movedItems->take(insert.moveId);
Q_ASSERT(items.count() == insert.count);
m_cache = m_cache.mid(0, insert.cacheIndex) + items + m_cache.mid(insert.cacheIndex);
}
if (insert.inGroup()) {
for (int offset = 0; cacheIndex < insert.cacheIndex + insert.count; ++cacheIndex, ++offset) {
- QSGVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
+ QQuickVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
cacheItem->groups |= insert.flags & Compositor::GroupMask;
for (int i = 1; i < m_groupCount; ++i) {
cacheItem->index[i] = cacheItem->groups & (1 << i)
}
}
for (; cacheIndex < m_cache.count(); ++cacheIndex) {
- QSGVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
+ QQuickVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
if (!cacheItem->groups)
continue;
for (int i = 1; i < m_groupCount; ++i)
}
}
-void QSGVisualDataModelPrivate::itemsInserted(const QVector<Compositor::Insert> &inserts)
+void QQuickVisualDataModelPrivate::itemsInserted(const QVector<Compositor::Insert> &inserts)
{
QVarLengthArray<QVector<QDeclarativeChangeSet::Insert>, Compositor::MaximumGroupCount> translatedInserts(m_groupCount);
itemsInserted(inserts, &translatedInserts);
return;
for (int i = 1; i < m_groupCount; ++i)
- QSGVisualDataGroupPrivate::get(m_groups[i])->changeSet.apply(translatedInserts.at(i));
+ QQuickVisualDataGroupPrivate::get(m_groups[i])->changeSet.apply(translatedInserts.at(i));
}
-void QSGVisualDataModel::_q_itemsInserted(int index, int count)
+void QQuickVisualDataModel::_q_itemsInserted(int index, int count)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (count <= 0)
return;
QVector<Compositor::Insert> inserts;
d->emitChanges();
}
-void QSGVisualDataModelPrivate::itemsRemoved(
+void QQuickVisualDataModelPrivate::itemsRemoved(
const QVector<Compositor::Remove> &removes,
QVarLengthArray<QVector<QDeclarativeChangeSet::Remove>, Compositor::MaximumGroupCount> *translatedRemoves,
- QHash<int, QList<QSGVisualDataModelCacheItem *> > *movedItems)
+ QHash<int, QList<QQuickVisualDataModelCacheItem *> > *movedItems)
{
int cacheIndex = 0;
int removedCache = 0;
foreach (const Compositor::Remove &remove, removes) {
for (; cacheIndex < remove.cacheIndex; ++cacheIndex) {
- QSGVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
+ QQuickVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
if (!cacheItem->groups)
continue;
for (int i = 1; i < m_groupCount; ++i)
if (movedItems && remove.isMove()) {
movedItems->insert(remove.moveId, m_cache.mid(remove.cacheIndex, remove.count));
- QList<QSGVisualDataModelCacheItem *>::iterator begin = m_cache.begin() + remove.cacheIndex;
- QList<QSGVisualDataModelCacheItem *>::iterator end = begin + remove.count;
+ QList<QQuickVisualDataModelCacheItem *>::iterator begin = m_cache.begin() + remove.cacheIndex;
+ QList<QQuickVisualDataModelCacheItem *>::iterator end = begin + remove.count;
m_cache.erase(begin, end);
} else {
for (; cacheIndex < remove.cacheIndex + remove.count - removedCache; ++cacheIndex) {
- QSGVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
+ QQuickVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
if (remove.inGroup(Compositor::Persisted) && cacheItem->objectRef == 0) {
destroy(cacheItem->object);
if (QDeclarativePackage *package = qobject_cast<QDeclarativePackage *>(cacheItem->object))
emitDestroyingPackage(package);
- else if (QSGItem *item = qobject_cast<QSGItem *>(cacheItem->object))
+ else if (QQuickItem *item = qobject_cast<QQuickItem *>(cacheItem->object))
emitDestroyingItem(item);
cacheItem->object = 0;
}
}
for (; cacheIndex < m_cache.count(); ++cacheIndex) {
- QSGVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
+ QQuickVisualDataModelCacheItem *cacheItem = m_cache.at(cacheIndex);
if (!cacheItem->groups)
continue;
for (int i = 1; i < m_groupCount; ++i)
}
}
-void QSGVisualDataModelPrivate::itemsRemoved(const QVector<Compositor::Remove> &removes)
+void QQuickVisualDataModelPrivate::itemsRemoved(const QVector<Compositor::Remove> &removes)
{
QVarLengthArray<QVector<QDeclarativeChangeSet::Remove>, Compositor::MaximumGroupCount> translatedRemoves(m_groupCount);
itemsRemoved(removes, &translatedRemoves);
return;
for (int i = 1; i < m_groupCount; ++i)
- QSGVisualDataGroupPrivate::get(m_groups[i])->changeSet.apply(translatedRemoves.at(i));
+ QQuickVisualDataGroupPrivate::get(m_groups[i])->changeSet.apply(translatedRemoves.at(i));
}
-void QSGVisualDataModel::_q_itemsRemoved(int index, int count)
+void QQuickVisualDataModel::_q_itemsRemoved(int index, int count)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (count <= 0)
return;
d->emitChanges();
}
-void QSGVisualDataModelPrivate::itemsMoved(
+void QQuickVisualDataModelPrivate::itemsMoved(
const QVector<Compositor::Remove> &removes, const QVector<Compositor::Insert> &inserts)
{
- QHash<int, QList<QSGVisualDataModelCacheItem *> > movedItems;
+ QHash<int, QList<QQuickVisualDataModelCacheItem *> > movedItems;
QVarLengthArray<QVector<QDeclarativeChangeSet::Remove>, Compositor::MaximumGroupCount> translatedRemoves(m_groupCount);
itemsRemoved(removes, &translatedRemoves, &movedItems);
return;
for (int i = 1; i < m_groupCount; ++i) {
- QSGVisualDataGroupPrivate::get(m_groups[i])->changeSet.apply(
+ QQuickVisualDataGroupPrivate::get(m_groups[i])->changeSet.apply(
translatedRemoves.at(i),
translatedInserts.at(i));
}
}
-void QSGVisualDataModel::_q_itemsMoved(int from, int to, int count)
+void QQuickVisualDataModel::_q_itemsMoved(int from, int to, int count)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (count <= 0)
return;
}
template <typename T> v8::Local<v8::Array>
-QSGVisualDataModelPrivate::buildChangeList(const QVector<T> &changes)
+QQuickVisualDataModelPrivate::buildChangeList(const QVector<T> &changes)
{
v8::Local<v8::Array> indexes = v8::Array::New(changes.count());
v8::Local<v8::String> indexKey = v8::String::New("index");
return indexes;
}
-void QSGVisualDataModelPrivate::emitModelUpdated(const QDeclarativeChangeSet &changeSet, bool reset)
+void QQuickVisualDataModelPrivate::emitModelUpdated(const QDeclarativeChangeSet &changeSet, bool reset)
{
- Q_Q(QSGVisualDataModel);
+ Q_Q(QQuickVisualDataModel);
emit q->modelUpdated(changeSet, reset);
if (changeSet.difference() != 0)
emit q->countChanged();
}
-void QSGVisualDataModelPrivate::emitChanges()
+void QQuickVisualDataModelPrivate::emitChanges()
{
if (m_transaction || !m_complete)
return;
m_transaction = true;
QV8Engine *engine = QDeclarativeEnginePrivate::getV8Engine(m_context->engine());
for (int i = 1; i < m_groupCount; ++i)
- QSGVisualDataGroupPrivate::get(m_groups[i])->emitChanges(engine);
+ QQuickVisualDataGroupPrivate::get(m_groups[i])->emitChanges(engine);
m_transaction = false;
const bool reset = m_reset;
m_reset = false;
for (int i = 1; i < m_groupCount; ++i)
- QSGVisualDataGroupPrivate::get(m_groups[i])->emitModelUpdated(reset);
+ QQuickVisualDataGroupPrivate::get(m_groups[i])->emitModelUpdated(reset);
- foreach (QSGVisualDataModelCacheItem *cacheItem, m_cache) {
+ foreach (QQuickVisualDataModelCacheItem *cacheItem, m_cache) {
if (cacheItem->object)
cacheItem->attached->emitChanges();
}
}
-void QSGVisualDataModel::_q_modelReset(int oldCount, int newCount)
+void QQuickVisualDataModel::_q_modelReset(int oldCount, int newCount)
{
- Q_D(QSGVisualDataModel);
+ Q_D(QQuickVisualDataModel);
if (!d->m_delegate)
return;
d->emitChanges();
}
-QSGVisualDataModelAttached *QSGVisualDataModel::qmlAttachedProperties(QObject *obj)
+QQuickVisualDataModelAttached *QQuickVisualDataModel::qmlAttachedProperties(QObject *obj)
{
- return QSGVisualDataModelAttached::properties(obj);
+ return QQuickVisualDataModelAttached::properties(obj);
}
//============================================================================
-QSGVisualDataModelCacheMetaType::QSGVisualDataModelCacheMetaType(
- QV8Engine *engine, QSGVisualDataModel *model, const QStringList &groupNames)
+QQuickVisualDataModelCacheMetaType::QQuickVisualDataModelCacheMetaType(
+ QV8Engine *engine, QQuickVisualDataModel *model, const QStringList &groupNames)
: model(model)
, groupCount(groupNames.count() + 1)
- , memberPropertyOffset(QSGVisualDataModelAttached::staticMetaObject.propertyCount())
- , indexPropertyOffset(QSGVisualDataModelAttached::staticMetaObject.propertyCount() + groupNames.count())
+ , memberPropertyOffset(QQuickVisualDataModelAttached::staticMetaObject.propertyCount())
+ , indexPropertyOffset(QQuickVisualDataModelAttached::staticMetaObject.propertyCount() + groupNames.count())
, v8Engine(engine)
, metaObject(0)
, groupNames(groupNames)
{
QMetaObjectBuilder builder;
builder.setFlags(QMetaObjectBuilder::DynamicMetaObject);
- builder.setClassName(QSGVisualDataModelAttached::staticMetaObject.className());
- builder.setSuperClass(&QSGVisualDataModelAttached::staticMetaObject);
+ builder.setClassName(QQuickVisualDataModelAttached::staticMetaObject.className());
+ builder.setSuperClass(&QQuickVisualDataModelAttached::staticMetaObject);
v8::HandleScope handleScope;
v8::Context::Scope contextScope(engine->context());
constructor = qPersistentNew<v8::Function>(ft->GetFunction());
}
-QSGVisualDataModelCacheMetaType::~QSGVisualDataModelCacheMetaType()
+QQuickVisualDataModelCacheMetaType::~QQuickVisualDataModelCacheMetaType()
{
qFree(metaObject);
qPersistentDispose(constructor);
}
-int QSGVisualDataModelCacheMetaType::parseGroups(const QStringList &groups) const
+int QQuickVisualDataModelCacheMetaType::parseGroups(const QStringList &groups) const
{
int groupFlags = 0;
foreach (const QString &groupName, groups) {
return groupFlags;
}
-int QSGVisualDataModelCacheMetaType::parseGroups(QV8Engine *engine, const v8::Local<v8::Value> &groups) const
+int QQuickVisualDataModelCacheMetaType::parseGroups(QV8Engine *engine, const v8::Local<v8::Value> &groups) const
{
int groupFlags = 0;
if (groups->IsString()) {
return groupFlags;
}
-v8::Handle<v8::Value> QSGVisualDataModelCacheMetaType::get_model(
+v8::Handle<v8::Value> QQuickVisualDataModelCacheMetaType::get_model(
v8::Local<v8::String>, const v8::AccessorInfo &info)
{
- QSGVisualDataModelCacheItem *cacheItem = v8_resource_cast<QSGVisualDataModelCacheItem>(info.This());
+ QQuickVisualDataModelCacheItem *cacheItem = v8_resource_cast<QQuickVisualDataModelCacheItem>(info.This());
if (!cacheItem)
V8THROW_ERROR("Not a valid VisualData object");
if (!cacheItem->metaType->model)
return v8::Undefined();
QObject *data = 0;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(cacheItem->metaType->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(cacheItem->metaType->model);
for (int i = 1; i < cacheItem->metaType->groupCount; ++i) {
if (cacheItem->groups & (1 << i)) {
Compositor::iterator it = model->m_compositor.find(
Compositor::Group(i), cacheItem->index[i]);
- if (QSGVisualAdaptorModel *list = it.list<QSGVisualAdaptorModel>())
+ if (QQuickVisualAdaptorModel *list = it.list<QQuickVisualAdaptorModel>())
data = list->data(it.modelIndex());
break;
}
return cacheItem->engine->newQObject(data);
}
-v8::Handle<v8::Value> QSGVisualDataModelCacheMetaType::get_groups(
+v8::Handle<v8::Value> QQuickVisualDataModelCacheMetaType::get_groups(
v8::Local<v8::String>, const v8::AccessorInfo &info)
{
- QSGVisualDataModelCacheItem *cacheItem = v8_resource_cast<QSGVisualDataModelCacheItem>(info.This());
+ QQuickVisualDataModelCacheItem *cacheItem = v8_resource_cast<QQuickVisualDataModelCacheItem>(info.This());
if (!cacheItem)
V8THROW_ERROR("Not a valid VisualData object");
return cacheItem->engine->fromVariant(groups);
}
-void QSGVisualDataModelCacheMetaType::set_groups(
+void QQuickVisualDataModelCacheMetaType::set_groups(
v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
{
- QSGVisualDataModelCacheItem *cacheItem = v8_resource_cast<QSGVisualDataModelCacheItem>(info.This());
+ QQuickVisualDataModelCacheItem *cacheItem = v8_resource_cast<QQuickVisualDataModelCacheItem>(info.This());
if (!cacheItem)
V8THROW_ERROR_SETTER("Not a valid VisualData object");
if (!cacheItem->metaType->model)
return;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(cacheItem->metaType->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(cacheItem->metaType->model);
const int groupFlags = model->m_cacheMetaType->parseGroups(cacheItem->engine, value);
for (int i = 1; i < cacheItem->metaType->groupCount; ++i) {
}
}
-v8::Handle<v8::Value> QSGVisualDataModelCacheMetaType::get_member(
+v8::Handle<v8::Value> QQuickVisualDataModelCacheMetaType::get_member(
v8::Local<v8::String>, const v8::AccessorInfo &info)
{
- QSGVisualDataModelCacheItem *cacheItem = v8_resource_cast<QSGVisualDataModelCacheItem>(info.This());
+ QQuickVisualDataModelCacheItem *cacheItem = v8_resource_cast<QQuickVisualDataModelCacheItem>(info.This());
if (!cacheItem)
V8THROW_ERROR("Not a valid VisualData object");
return v8::Boolean::New(cacheItem->groups & (1 << info.Data()->Int32Value()));
}
-void QSGVisualDataModelCacheMetaType::set_member(
+void QQuickVisualDataModelCacheMetaType::set_member(
v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
{
- QSGVisualDataModelCacheItem *cacheItem = v8_resource_cast<QSGVisualDataModelCacheItem>(info.This());
+ QQuickVisualDataModelCacheItem *cacheItem = v8_resource_cast<QQuickVisualDataModelCacheItem>(info.This());
if (!cacheItem)
V8THROW_ERROR_SETTER("Not a valid VisualData object");
if (!cacheItem->metaType->model)
return;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(cacheItem->metaType->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(cacheItem->metaType->model);
Compositor::Group group = Compositor::Group(info.Data()->Int32Value());
const bool member = value->BooleanValue();
}
}
-v8::Handle<v8::Value> QSGVisualDataModelCacheMetaType::get_index(
+v8::Handle<v8::Value> QQuickVisualDataModelCacheMetaType::get_index(
v8::Local<v8::String>, const v8::AccessorInfo &info)
{
- QSGVisualDataModelCacheItem *cacheItem = v8_resource_cast<QSGVisualDataModelCacheItem>(info.This());
+ QQuickVisualDataModelCacheItem *cacheItem = v8_resource_cast<QQuickVisualDataModelCacheItem>(info.This());
if (!cacheItem)
V8THROW_ERROR("Not a valid VisualData object");
//---------------------------------------------------------------------------
-void QSGVisualDataModelCacheItem::Dispose()
+void QQuickVisualDataModelCacheItem::Dispose()
{
--scriptRef;
if (isReferenced())
return;
if (metaType->model) {
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(metaType->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(metaType->model);
const int cacheIndex = model->m_cache.indexOf(this);
if (cacheIndex != -1) {
model->m_compositor.clearFlags(Compositor::Cache, cacheIndex, 1, Compositor::CacheFlag);
//---------------------------------------------------------------------------
-QSGVisualDataModelAttachedMetaObject::QSGVisualDataModelAttachedMetaObject(
- QSGVisualDataModelAttached *attached, QSGVisualDataModelCacheMetaType *metaType)
+QQuickVisualDataModelAttachedMetaObject::QQuickVisualDataModelAttachedMetaObject(
+ QQuickVisualDataModelAttached *attached, QQuickVisualDataModelCacheMetaType *metaType)
: attached(attached)
, metaType(metaType)
{
QObjectPrivate::get(attached)->metaObject = this;
}
-QSGVisualDataModelAttachedMetaObject::~QSGVisualDataModelAttachedMetaObject()
+QQuickVisualDataModelAttachedMetaObject::~QQuickVisualDataModelAttachedMetaObject()
{
metaType->release();
}
-int QSGVisualDataModelAttachedMetaObject::metaCall(QMetaObject::Call call, int _id, void **arguments)
+int QQuickVisualDataModelAttachedMetaObject::metaCall(QMetaObject::Call call, int _id, void **arguments)
{
if (call == QMetaObject::ReadProperty) {
if (_id >= metaType->indexPropertyOffset) {
Compositor::Group group = Compositor::Group(_id - metaType->memberPropertyOffset + 1);
const bool member = attached->m_cacheItem->groups & (1 << group);
if (member != *static_cast<bool *>(arguments[0])) {
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(metaType->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(metaType->model);
const int cacheIndex = model->m_cache.indexOf(attached->m_cacheItem);
if (member)
model->removeGroups(Compositor::Cache, cacheIndex, 1, (1 << group));
It is attached to each instance of the delegate.
*/
-QSGVisualDataModel *QSGVisualDataModelAttached::model() const
+QQuickVisualDataModel *QQuickVisualDataModelAttached::model() const
{
return m_cacheItem ? m_cacheItem->metaType->model : 0;
}
It is attached to each instance of the delegate.
*/
-QStringList QSGVisualDataModelAttached::groups() const
+QStringList QQuickVisualDataModelAttached::groups() const
{
QStringList groups;
return groups;
}
-void QSGVisualDataModelAttached::setGroups(const QStringList &groups)
+void QQuickVisualDataModelAttached::setGroups(const QStringList &groups)
{
if (!m_cacheItem)
return;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(m_cacheItem->metaType->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(m_cacheItem->metaType->model);
const int cacheIndex = model->m_cache.indexOf(m_cacheItem);
const int groupFlags = model->m_cacheMetaType->parseGroups(groups);
It is attached to each instance of the delegate.
*/
-void QSGVisualDataModelAttached::emitChanges()
+void QQuickVisualDataModelAttached::emitChanges()
{
if (m_modelChanged) {
m_modelChanged = false;
//============================================================================
-void QSGVisualDataGroupPrivate::setModel(QSGVisualDataModel *m, Compositor::Group g)
+void QQuickVisualDataGroupPrivate::setModel(QQuickVisualDataModel *m, Compositor::Group g)
{
Q_ASSERT(!model);
model = m;
group = g;
}
-void QSGVisualDataGroupPrivate::emitChanges(QV8Engine *engine)
+void QQuickVisualDataGroupPrivate::emitChanges(QV8Engine *engine)
{
- Q_Q(QSGVisualDataGroup);
+ Q_Q(QQuickVisualDataGroup);
static int idx = signalIndex("changed(QDeclarativeV8Handle,QDeclarativeV8Handle)");
if (isSignalConnected(idx)) {
v8::HandleScope handleScope;
v8::Context::Scope contextScope(engine->context());
- v8::Local<v8::Array> removed = QSGVisualDataModelPrivate::buildChangeList(changeSet.removes());
- v8::Local<v8::Array> inserted = QSGVisualDataModelPrivate::buildChangeList(changeSet.inserts());
+ v8::Local<v8::Array> removed = QQuickVisualDataModelPrivate::buildChangeList(changeSet.removes());
+ v8::Local<v8::Array> inserted = QQuickVisualDataModelPrivate::buildChangeList(changeSet.inserts());
emit q->changed(
QDeclarativeV8Handle::fromHandle(removed), QDeclarativeV8Handle::fromHandle(inserted));
}
emit q->countChanged();
}
-void QSGVisualDataGroupPrivate::emitModelUpdated(bool reset)
+void QQuickVisualDataGroupPrivate::emitModelUpdated(bool reset)
{
- for (QSGVisualDataGroupEmitterList::iterator it = emitters.begin(); it != emitters.end(); ++it)
+ for (QQuickVisualDataGroupEmitterList::iterator it = emitters.begin(); it != emitters.end(); ++it)
it->emitModelUpdated(changeSet, reset);
changeSet.clear();
}
-void QSGVisualDataGroupPrivate::createdPackage(int index, QDeclarativePackage *package)
+void QQuickVisualDataGroupPrivate::createdPackage(int index, QDeclarativePackage *package)
{
- for (QSGVisualDataGroupEmitterList::iterator it = emitters.begin(); it != emitters.end(); ++it)
+ for (QQuickVisualDataGroupEmitterList::iterator it = emitters.begin(); it != emitters.end(); ++it)
it->createdPackage(index, package);
}
-void QSGVisualDataGroupPrivate::destroyingPackage(QDeclarativePackage *package)
+void QQuickVisualDataGroupPrivate::destroyingPackage(QDeclarativePackage *package)
{
- for (QSGVisualDataGroupEmitterList::iterator it = emitters.begin(); it != emitters.end(); ++it)
+ for (QQuickVisualDataGroupEmitterList::iterator it = emitters.begin(); it != emitters.end(); ++it)
it->destroyingPackage(package);
}
/*!
- \qmlclass VisualDataGroup QSGVisualDataGroup
+ \qmlclass VisualDataGroup QQuickVisualDataGroup
\inqmlmodule QtQuick 2
\ingroup qml-working-with-data
\brief The VisualDataGroup encapsulates a filtered set of visual data items.
*/
-QSGVisualDataGroup::QSGVisualDataGroup(QObject *parent)
- : QObject(*new QSGVisualDataGroupPrivate, parent)
+QQuickVisualDataGroup::QQuickVisualDataGroup(QObject *parent)
+ : QObject(*new QQuickVisualDataGroupPrivate, parent)
{
}
-QSGVisualDataGroup::QSGVisualDataGroup(
- const QString &name, QSGVisualDataModel *model, int index, QObject *parent)
- : QObject(*new QSGVisualDataGroupPrivate, parent)
+QQuickVisualDataGroup::QQuickVisualDataGroup(
+ const QString &name, QQuickVisualDataModel *model, int index, QObject *parent)
+ : QObject(*new QQuickVisualDataGroupPrivate, parent)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
d->name = name;
d->setModel(model, Compositor::Group(index));
}
-QSGVisualDataGroup::~QSGVisualDataGroup()
+QQuickVisualDataGroup::~QQuickVisualDataGroup()
{
}
Each group in a model must have a unique name starting with a lower case letter.
*/
-QString QSGVisualDataGroup::name() const
+QString QQuickVisualDataGroup::name() const
{
- Q_D(const QSGVisualDataGroup);
+ Q_D(const QQuickVisualDataGroup);
return d->name;
}
-void QSGVisualDataGroup::setName(const QString &name)
+void QQuickVisualDataGroup::setName(const QString &name)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
if (d->model)
return;
if (d->name != name) {
This property holds the number of items in the group.
*/
-int QSGVisualDataGroup::count() const
+int QQuickVisualDataGroup::count() const
{
- Q_D(const QSGVisualDataGroup);
+ Q_D(const QQuickVisualDataGroup);
if (!d->model)
return 0;
- return QSGVisualDataModelPrivate::get(d->model)->m_compositor.count(d->group);
+ return QQuickVisualDataModelPrivate::get(d->model)->m_compositor.count(d->group);
}
/*!
This property holds whether new items are assigned to this group by default.
*/
-bool QSGVisualDataGroup::defaultInclude() const
+bool QQuickVisualDataGroup::defaultInclude() const
{
- Q_D(const QSGVisualDataGroup);
+ Q_D(const QQuickVisualDataGroup);
return d->defaultInclude;
}
-void QSGVisualDataGroup::setDefaultInclude(bool include)
+void QQuickVisualDataGroup::setDefaultInclude(bool include)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
if (d->defaultInclude != include) {
d->defaultInclude = include;
if (d->model) {
if (include)
- QSGVisualDataModelPrivate::get(d->model)->m_compositor.setDefaultGroup(d->group);
+ QQuickVisualDataModelPrivate::get(d->model)->m_compositor.setDefaultGroup(d->group);
else
- QSGVisualDataModelPrivate::get(d->model)->m_compositor.clearDefaultGroup(d->group);
+ QQuickVisualDataModelPrivate::get(d->model)->m_compositor.clearDefaultGroup(d->group);
}
emit defaultIncludeChanged();
}
\endlist
*/
-QDeclarativeV8Handle QSGVisualDataGroup::get(int index)
+QDeclarativeV8Handle QQuickVisualDataGroup::get(int index)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
if (!d->model)
return QDeclarativeV8Handle::fromHandle(v8::Undefined());;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(d->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(d->model);
if (index < 0 || index >= model->m_compositor.count(d->group)) {
qmlInfo(this) << tr("get: index out of range");
return QDeclarativeV8Handle::fromHandle(v8::Undefined());
}
Compositor::iterator it = model->m_compositor.find(d->group, index);
- QSGVisualDataModelCacheItem *cacheItem = it->inCache()
+ QQuickVisualDataModelCacheItem *cacheItem = it->inCache()
? model->m_cache.at(it.cacheIndex)
: 0;
if (!cacheItem) {
- cacheItem = new QSGVisualDataModelCacheItem(model->m_cacheMetaType);
+ cacheItem = new QQuickVisualDataModelCacheItem(model->m_cacheMetaType);
for (int i = 0; i < model->m_groupCount; ++i)
cacheItem->index[i] = it.index[i];
cacheItem->groups = it->flags & Compositor::GroupMask;
group remain instantiated when not referenced by any view.
*/
-QObject *QSGVisualDataGroup::create(int index)
+QObject *QQuickVisualDataGroup::create(int index)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
if (!d->model)
return 0;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(d->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(d->model);
if (index < 0 || index >= model->m_compositor.count(d->group)) {
qmlInfo(this) << tr("create: index out of range");
return 0;
Removes \a count items starting at \a index from the group.
*/
-void QSGVisualDataGroup::remove(QDeclarativeV8Function *args)
+void QQuickVisualDataGroup::remove(QDeclarativeV8Function *args)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
if (!d->model)
return;
int index = -1;
count = v->Int32Value();
}
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(d->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(d->model);
if (count < 0) {
qmlInfo(this) << tr("remove: invalid count");
} else if (index < 0 || index + count > model->m_compositor.count(d->group)) {
}
}
-bool QSGVisualDataGroupPrivate::parseGroupArgs(
+bool QQuickVisualDataGroupPrivate::parseGroupArgs(
QDeclarativeV8Function *args, int *index, int *count, int *groups) const
{
if (!model)
v = (*args)[i];
}
- *groups = QSGVisualDataModelPrivate::get(model)->m_cacheMetaType->parseGroups(args->engine(), v);
+ *groups = QQuickVisualDataModelPrivate::get(model)->m_cacheMetaType->parseGroups(args->engine(), v);
return true;
}
Adds \a count items starting at \a index to \a groups.
*/
-void QSGVisualDataGroup::addGroups(QDeclarativeV8Function *args)
+void QQuickVisualDataGroup::addGroups(QDeclarativeV8Function *args)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
int index = -1;
int count = 1;
int groups = 0;
if (!d->parseGroupArgs(args, &index, &count, &groups))
return;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(d->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(d->model);
if (count < 0) {
qmlInfo(this) << tr("addGroups: invalid count");
} else if (index < 0 || index + count > model->m_compositor.count(d->group)) {
Removes \a count items starting at \a index from \a groups.
*/
-void QSGVisualDataGroup::removeGroups(QDeclarativeV8Function *args)
+void QQuickVisualDataGroup::removeGroups(QDeclarativeV8Function *args)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
int index = -1;
int count = 1;
int groups = 0;
if (!d->parseGroupArgs(args, &index, &count, &groups))
return;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(d->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(d->model);
if (count < 0) {
qmlInfo(this) << tr("removeGroups: invalid count");
} else if (index < 0 || index + count > model->m_compositor.count(d->group)) {
Sets the \a groups \a count items starting at \a index belong to.
*/
-void QSGVisualDataGroup::setGroups(QDeclarativeV8Function *args)
+void QQuickVisualDataGroup::setGroups(QDeclarativeV8Function *args)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
int index = -1;
int count = 1;
int groups = 0;
if (!d->parseGroupArgs(args, &index, &count, &groups))
return;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(d->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(d->model);
if (count < 0) {
qmlInfo(this) << tr("setGroups: invalid count");
} else if (index < 0 || index + count > model->m_compositor.count(d->group)) {
Moves \a count at \a from in a group \a to a new position.
*/
-void QSGVisualDataGroup::move(QDeclarativeV8Function *args)
+void QQuickVisualDataGroup::move(QDeclarativeV8Function *args)
{
- Q_D(QSGVisualDataGroup);
+ Q_D(QQuickVisualDataGroup);
if (args->Length() < 2)
return;
int i = 0;
v8::Local<v8::Value> v = (*args)[i];
- if (QSGVisualDataGroup *group = qobject_cast<QSGVisualDataGroup *>(args->engine()->toQObject(v))) {
- QSGVisualDataGroupPrivate *g_d = QSGVisualDataGroupPrivate::get(group);
+ if (QQuickVisualDataGroup *group = qobject_cast<QQuickVisualDataGroup *>(args->engine()->toQObject(v))) {
+ QQuickVisualDataGroupPrivate *g_d = QQuickVisualDataGroupPrivate::get(group);
if (g_d->model != d->model)
return;
fromGroup = g_d->group;
return;
v = (*args)[i];
- if (QSGVisualDataGroup *group = qobject_cast<QSGVisualDataGroup *>(args->engine()->toQObject(v))) {
- QSGVisualDataGroupPrivate *g_d = QSGVisualDataGroupPrivate::get(group);
+ if (QQuickVisualDataGroup *group = qobject_cast<QQuickVisualDataGroup *>(args->engine()->toQObject(v))) {
+ QQuickVisualDataGroupPrivate *g_d = QQuickVisualDataGroupPrivate::get(group);
if (g_d->model != d->model)
return;
toGroup = g_d->group;
count = v->Int32Value();
}
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(d->model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(d->model);
if (count < 0) {
qmlInfo(this) << tr("move: invalid count");
//============================================================================
-QSGVisualPartsModel::QSGVisualPartsModel(QSGVisualDataModel *model, const QString &part, QObject *parent)
- : QSGVisualModel(*new QObjectPrivate, parent)
+QQuickVisualPartsModel::QQuickVisualPartsModel(QQuickVisualDataModel *model, const QString &part, QObject *parent)
+ : QQuickVisualModel(*new QObjectPrivate, parent)
, m_model(model)
, m_part(part)
, m_compositorGroup(Compositor::Cache)
, m_inheritGroup(true)
{
- QSGVisualDataModelPrivate *d = QSGVisualDataModelPrivate::get(m_model);
+ QQuickVisualDataModelPrivate *d = QQuickVisualDataModelPrivate::get(m_model);
if (d->m_cacheMetaType) {
- QSGVisualDataGroupPrivate::get(d->m_groups[1])->emitters.insert(this);
+ QQuickVisualDataGroupPrivate::get(d->m_groups[1])->emitters.insert(this);
m_compositorGroup = Compositor::Default;
} else {
d->m_pendingParts.insert(this);
}
}
-QSGVisualPartsModel::~QSGVisualPartsModel()
+QQuickVisualPartsModel::~QQuickVisualPartsModel()
{
}
-QString QSGVisualPartsModel::filterGroup() const
+QString QQuickVisualPartsModel::filterGroup() const
{
if (m_inheritGroup)
return m_model->filterGroup();
return m_filterGroup;
}
-void QSGVisualPartsModel::setFilterGroup(const QString &group)
+void QQuickVisualPartsModel::setFilterGroup(const QString &group)
{
- if (QSGVisualDataModelPrivate::get(m_model)->m_transaction) {
+ if (QQuickVisualDataModelPrivate::get(m_model)->m_transaction) {
qmlInfo(this) << tr("The group of a VisualDataModel cannot be changed within onChanged");
return;
}
}
}
-void QSGVisualPartsModel::resetFilterGroup()
+void QQuickVisualPartsModel::resetFilterGroup()
{
if (!m_inheritGroup) {
m_inheritGroup = true;
}
}
-void QSGVisualPartsModel::updateFilterGroup()
+void QQuickVisualPartsModel::updateFilterGroup()
{
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(m_model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(m_model);
if (!model->m_cacheMetaType)
return;
QDeclarativeListCompositor::Group previousGroup = model->m_compositorGroup;
m_compositorGroup = Compositor::Default;
- QSGVisualDataGroupPrivate::get(model->m_groups[Compositor::Default])->emitters.insert(this);
+ QQuickVisualDataGroupPrivate::get(model->m_groups[Compositor::Default])->emitters.insert(this);
for (int i = 1; i < model->m_groupCount; ++i) {
if (m_filterGroup == model->m_cacheMetaType->groupNames.at(i - 1)) {
m_compositorGroup = Compositor::Group(i);
}
}
- QSGVisualDataGroupPrivate::get(model->m_groups[m_compositorGroup])->emitters.insert(this);
+ QQuickVisualDataGroupPrivate::get(model->m_groups[m_compositorGroup])->emitters.insert(this);
if (m_compositorGroup != previousGroup) {
QVector<QDeclarativeChangeSet::Remove> removes;
QVector<QDeclarativeChangeSet::Insert> inserts;
}
}
-void QSGVisualPartsModel::updateFilterGroup(
+void QQuickVisualPartsModel::updateFilterGroup(
Compositor::Group group, const QDeclarativeChangeSet &changeSet)
{
if (!m_inheritGroup)
return;
m_compositorGroup = group;
- QSGVisualDataGroupPrivate::get(QSGVisualDataModelPrivate::get(m_model)->m_groups[m_compositorGroup])->emitters.insert(this);
+ QQuickVisualDataGroupPrivate::get(QQuickVisualDataModelPrivate::get(m_model)->m_groups[m_compositorGroup])->emitters.insert(this);
if (!changeSet.isEmpty())
emit modelUpdated(changeSet, false);
emit filterGroupChanged();
}
-int QSGVisualPartsModel::count() const
+int QQuickVisualPartsModel::count() const
{
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(m_model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(m_model);
return model->m_delegate
? model->m_compositor.count(m_compositorGroup)
: 0;
}
-bool QSGVisualPartsModel::isValid() const
+bool QQuickVisualPartsModel::isValid() const
{
return m_model->isValid();
}
-QSGItem *QSGVisualPartsModel::item(int index, bool complete)
+QQuickItem *QQuickVisualPartsModel::item(int index, bool complete)
{
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(m_model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(m_model);
if (!model->m_delegate || index < 0 || index >= model->m_compositor.count(m_compositorGroup)) {
qWarning() << "VisualDataModel::item: index out range" << index << model->m_compositor.count(m_compositorGroup);
QObject *part = package->part(m_part);
if (!part)
return 0;
- if (QSGItem *item = qobject_cast<QSGItem *>(part)) {
+ if (QQuickItem *item = qobject_cast<QQuickItem *>(part)) {
m_packaged.insertMulti(item, package);
return item;
}
return 0;
}
-QSGVisualModel::ReleaseFlags QSGVisualPartsModel::release(QSGItem *item)
+QQuickVisualModel::ReleaseFlags QQuickVisualPartsModel::release(QQuickItem *item)
{
- QSGVisualModel::ReleaseFlags flags = 0;
+ QQuickVisualModel::ReleaseFlags flags = 0;
QHash<QObject *, QDeclarativePackage *>::iterator it = m_packaged.find(item);
if (it != m_packaged.end()) {
QDeclarativePackage *package = *it;
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(m_model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(m_model);
flags = model->release(package);
m_packaged.erase(it);
if (!m_packaged.contains(item))
flags &= ~Referenced;
if (flags & Destroyed)
- QSGVisualDataModelPrivate::get(m_model)->emitDestroyingPackage(package);
+ QQuickVisualDataModelPrivate::get(m_model)->emitDestroyingPackage(package);
}
return flags;
}
-bool QSGVisualPartsModel::completePending() const
+bool QQuickVisualPartsModel::completePending() const
{
return m_model->completePending();
}
-void QSGVisualPartsModel::completeItem()
+void QQuickVisualPartsModel::completeItem()
{
m_model->completeItem();
}
-QString QSGVisualPartsModel::stringValue(int index, const QString &role)
+QString QQuickVisualPartsModel::stringValue(int index, const QString &role)
{
- return QSGVisualDataModelPrivate::get(m_model)->stringValue(m_compositorGroup, index, role);
+ return QQuickVisualDataModelPrivate::get(m_model)->stringValue(m_compositorGroup, index, role);
}
-void QSGVisualPartsModel::setWatchedRoles(QList<QByteArray> roles)
+void QQuickVisualPartsModel::setWatchedRoles(QList<QByteArray> roles)
{
- QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(m_model);
+ QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(m_model);
model->m_adaptorModel->replaceWatchedRoles(m_watchedRoles, roles);
m_watchedRoles = roles;
}
-int QSGVisualPartsModel::indexOf(QSGItem *item, QObject *) const
+int QQuickVisualPartsModel::indexOf(QQuickItem *item, QObject *) const
{
QHash<QObject *, QDeclarativePackage *>::const_iterator it = m_packaged.find(item);
if (it != m_packaged.end()) {
- const QSGVisualDataModelPrivate *model = QSGVisualDataModelPrivate::get(m_model);
+ const QQuickVisualDataModelPrivate *model = QQuickVisualDataModelPrivate::get(m_model);
const int cacheIndex = model->cacheIndexOf(*it);
return cacheIndex != -1
? model->m_cache.at(cacheIndex)->index[m_compositorGroup]
return -1;
}
-void QSGVisualPartsModel::createdPackage(int index, QDeclarativePackage *package)
+void QQuickVisualPartsModel::createdPackage(int index, QDeclarativePackage *package)
{
- if (QSGItem *item = qobject_cast<QSGItem *>(package->part(m_part)))
+ if (QQuickItem *item = qobject_cast<QQuickItem *>(package->part(m_part)))
emit createdItem(index, item);
}
-void QSGVisualPartsModel::destroyingPackage(QDeclarativePackage *package)
+void QQuickVisualPartsModel::destroyingPackage(QDeclarativePackage *package)
{
- if (QSGItem *item = qobject_cast<QSGItem *>(package->part(m_part))) {
+ if (QQuickItem *item = qobject_cast<QQuickItem *>(package->part(m_part))) {
Q_ASSERT(!m_packaged.contains(item));
emit destroyingItem(item);
}
}
-void QSGVisualPartsModel::emitModelUpdated(const QDeclarativeChangeSet &changeSet, bool reset)
+void QQuickVisualPartsModel::emitModelUpdated(const QDeclarativeChangeSet &changeSet, bool reset)
{
emit modelUpdated(changeSet, reset);
if (changeSet.difference() != 0)
QT_END_NAMESPACE
-#include <qsgvisualdatamodel.moc>
+#include <qquickvisualdatamodel.moc>
projects / profile / ivi / qtdeclarative.git / blobdiff