#include <qdeclarativelistmodel_p_p.h>

Public Functions
void	changedProperty (const QString &name) const

void	clear ()

QDeclarativeListModel *	model (const NestedListModel *model)

	ModelNode (NestedListModel *model)

ModelObject *	object (const NestedListModel *model)

void	setListValue (const QScriptValue &valuelist)

bool	setObjectValue (const QScriptValue &valuemap, bool writeToCache=true)

bool	setProperty (const QString &prop, const QVariant &val)

void	updateListIndexes ()

	~ModelNode ()

Static Public Functions
static void	dump (ModelNode *node, int ind)

Public Variables
bool	isArray

int	listIndex

NestedListModel *	m_model

QDeclarativeListModel *	modelCache

ModelObject *	objectCache

QHash< QString, ModelNode * >	properties

QList< QVariant >	values

Detailed Description

Definition at line 245 of file qdeclarativelistmodel_p_p.h.

Constructors and Destructors

◆ ModelNode()

ModelNode::ModelNode ( NestedListModel * model )

Definition at line 1474 of file qdeclarativelistmodel.cpp.

Referenced by setListValue(), setObjectValue(), and setProperty().

 : modelCache(0), objectCache(0), isArray(false), m_model(model), listIndex(-1)
 {
 }

◆ ~ModelNode()

ModelNode::~ModelNode ( )

Definition at line 1479 of file qdeclarativelistmodel.cpp.

 {
     clear();
     if (modelCache) { modelCache->m_nested->_root = 0/* ==this */; delete modelCache; modelCache = 0; }
     if (objectCache) { delete objectCache; objectCache = 0; }
 }

Functions

◆ changedProperty()

void ModelNode::changedProperty ( const QString & name ) const

Definition at line 1588 of file qdeclarativelistmodel.cpp.

Referenced by ModelNodeMetaObject::propertyWritten().

 {
     if (listIndex < 0)
         return;
 
     m_model->checkRoles();
     QList<int> roles;
     int role = m_model->roleStrings.indexOf(name);
     if (role < 0)
         roles = m_model->roles();
     else
         roles << role;
     emit m_model->m_listModel->itemsChanged(listIndex, 1, roles);
 }

◆ clear()

void ModelNode::clear ( )

Definition at line 1486 of file qdeclarativelistmodel.cpp.

Referenced by NestedListModel::clear(), and ~ModelNode().

 {
     ModelNode *node;
     for (int ii = 0; ii < values.count(); ++ii) {
         node = qvariant_cast<ModelNode *>(values.at(ii));
         if (node) { delete node; node = 0; }
     }
     values.clear();
 
     qDeleteAll(properties.values());
     properties.clear();
 }

◆ dump()

void ModelNode::dump	(	ModelNode *	node,
		int	ind
	)

static

Definition at line 1603 of file qdeclarativelistmodel.cpp.

 {
     QByteArray indentBa(ind * 4, ' ');
     const char *indent = indentBa.constData();
 
     for (int ii = 0; ii < node->values.count(); ++ii) {
         ModelNode *subNode = qvariant_cast<ModelNode *>(node->values.at(ii));
         if (subNode) {
             qWarning().nospace() << indent << "Sub-node " << ii;
             dump(subNode, ind + 1);
         } else {
             qWarning().nospace() << indent << "Sub-node " << ii << ": " << node->values.at(ii).toString();
         }
     }
 
     for (QHash<QString, ModelNode *>::ConstIterator iter = node->properties.begin(); iter != node->properties.end(); ++iter) {
         qWarning().nospace() << indent << "Property " << iter.key() << ':';
         dump(iter.value(), ind + 1);
     }
 }

◆ model()

QDeclarativeListModel * ModelNode::model ( const NestedListModel * model )

Definition at line 360 of file qdeclarativelistmodel.cpp.

Referenced by setObjectValue(), and NestedListModel::valueForNode().

 {
     if (!modelCache) { 
         modelCache = new QDeclarativeListModel;
         QDeclarativeEngine::setContextForObject(modelCache,QDeclarativeEngine::contextForObject(model->m_listModel));
         modelCache->m_nested->_root = this;  // ListModel defaults to nestable model
 
         for (int i=0; i<values.count(); ++i) {
             ModelNode *subNode = qvariant_cast<ModelNode *>(values.at(i));
             if (subNode)
                 subNode->m_model = modelCache->m_nested;
         }
     }
     return modelCache;
 }

◆ object()

ModelObject * ModelNode::object ( const NestedListModel * model )

Definition at line 376 of file qdeclarativelistmodel.cpp.

Referenced by NestedListModel::get(), and NestedListModel::valueForNode().

 {
     if (!objectCache) {
         objectCache = new ModelObject(this, 
                 const_cast<NestedListModel*>(model), 
                 QDeclarativeEnginePrivate::getScriptEngine(qmlEngine(model->m_listModel)));
         QHash<QString, ModelNode *>::iterator it;
         for (it = properties.begin(); it != properties.end(); ++it) {
             objectCache->setValue(it.key().toUtf8(), model->valueForNode(*it));
         }
         objectCache->setNodeUpdatesEnabled(true);
     }
     return objectCache;
 }

◆ setListValue()

void ModelNode::setListValue ( const QScriptValue & valuelist )

Definition at line 1532 of file qdeclarativelistmodel.cpp.

Referenced by setListValue(), and setObjectValue().

                                                           {
     values.clear();
     int size = valuelist.property(QLatin1String("length")).toInt32();
     for (int i=0; i<size; i++) {
         ModelNode *value = new ModelNode(m_model);
         QScriptValue v = valuelist.property(i);
         if (v.isArray()) {
             value->isArray = true;
             value->setListValue(v);
         } else if (v.isObject()) {
             value->listIndex = i;
             value->setObjectValue(v);
         } else {
             value->listIndex = i;
             value->values << v.toVariant();
         }
         values.append(QVariant::fromValue(value));
     }
 }

◆ setObjectValue()

bool ModelNode::setObjectValue	(	const QScriptValue &	valuemap,
		bool	writeToCache = `true`
	)

Definition at line 1499 of file qdeclarativelistmodel.cpp.

Referenced by NestedListModel::insert(), ModelNodeMetaObject::propertyWritten(), NestedListModel::set(), and setListValue().

 {
     bool emitItemsChanged = false;
 
     QScriptValueIterator it(valuemap);
     while (it.hasNext()) {
         it.next();
         ModelNode *prev = properties.value(it.name());
         ModelNode *value = new ModelNode(m_model);
         QScriptValue v = it.value();
 
         if (v.isArray()) {
             value->isArray = true;
             value->setListValue(v);
             if (writeToCache && objectCache)
                 objectCache->setValue(it.name().toUtf8(), QVariant::fromValue(value->model(m_model)));
             emitItemsChanged = true;    // for now, too inefficient to check whether list and sublists have changed
         } else {
             value->values << v.toVariant();
             if (writeToCache && objectCache)
                 objectCache->setValue(it.name().toUtf8(), value->values.last());
             if (!emitItemsChanged && prev && prev->values.count() == 1
                     && prev->values[0] != value->values.last()) {
                 emitItemsChanged = true;
             }
         }
         if (properties.contains(it.name()))
             delete properties[it.name()];
         properties.insert(it.name(), value);
     }
     return emitItemsChanged;
 }

◆ setProperty()

bool ModelNode::setProperty	(	const QString &	prop,
		const QVariant &	val
	)

Definition at line 1552 of file qdeclarativelistmodel.cpp.

Referenced by NestedListModel::setProperty().

                                                                     {
     QHash<QString, ModelNode *>::const_iterator it = properties.find(prop);
     bool emitItemsChanged = false;
     if (it != properties.end()) {
         if (val != (*it)->values[0])
             emitItemsChanged = true;
         (*it)->values[0] = val;
     } else {
         ModelNode *n = new ModelNode(m_model);
         n->values << val;
         properties.insert(prop,n);
     }
     if (objectCache)
         objectCache->setValue(prop.toUtf8(), val);
     return emitItemsChanged;
 }

◆ updateListIndexes()

void ModelNode::updateListIndexes ( )

Definition at line 1569 of file qdeclarativelistmodel.cpp.

Referenced by QDeclarativeListModelParser::setCustomData(), and updateListIndexes().

 {
     for (QHash<QString, ModelNode *>::ConstIterator iter = properties.begin(); iter != properties.end(); ++iter) {
         ModelNode *node = iter.value();
         if (node->isArray) {
             for (int i=0; i<node->values.count(); ++i) {
                 ModelNode *subNode = qvariant_cast<ModelNode *>(node->values.at(i));
                 if (subNode)
                     subNode->listIndex = i;
             }
         }
         node->updateListIndexes();
     }
 }