This notifies the views if the instance has be really instanced.
}
}
+void FormEditorView::instancesCompleted(const QVector<ModelNode> &completedNodeList)
+{
+}
+
+
void FormEditorView::customNotification(const AbstractView *view, const QString &identifier, const QList<ModelNode> &nodeList, const QList<QVariant> &data)
{
if (identifier == "__start rewriter transaction__") {
void auxiliaryDataChanged(const ModelNode &node, const QString &name, const QVariant &data);
void customNotification(const AbstractView *view, const QString &identifier, const QList<ModelNode> &nodeList, const QList<QVariant> &data);
+ void instancesCompleted(const QVector<ModelNode> &completedNodeList);
+
double margins() const;
double spacing() const;
void deActivateItemCreator();
void ComponentView::rootNodeTypeChanged(const QString &/*type*/, int /*majorVersion*/, int /*minorVersion*/) {}
void ComponentView::scriptFunctionsChanged(const ModelNode &/*node*/, const QStringList &/*scriptFunctionList*/) {}
void ComponentView::instancePropertyChange(const QList<QPair<ModelNode, QString> > &/*propertyList*/) {};
+void ComponentView::instancesCompleted(const QVector<ModelNode> &/*completedNodeList*/) {}
void ComponentView::selectedNodesChanged(const QList<ModelNode> &/*selectedNodeList*/,
void ComponentView::nodeOrderChanged(const NodeListProperty &/*listProperty*/, const ModelNode & /*movedNode*/, int /*oldIndex*/) {}
-void ComponentView::importsChanged() {}
void ComponentView::auxiliaryDataChanged(const ModelNode &/*node*/, const QString &/*name*/, const QVariant &/*data*/) {}
void rootNodeTypeChanged(const QString &type, int majorVersion, int minorVersion);
void scriptFunctionsChanged(const ModelNode &node, const QStringList &scriptFunctionList);
void instancePropertyChange(const QList<QPair<ModelNode, QString> > &propertyList);
+ void instancesCompleted(const QVector<ModelNode> &completedNodeList);
void selectedNodesChanged(const QList<ModelNode> &selectedNodeList,
const QList<ModelNode> &lastSelectedNodeList);
void nodeOrderChanged(const NodeListProperty &listProperty, const ModelNode &movedNode, int oldIndex);
- void importsChanged();
-
void auxiliaryDataChanged(const ModelNode &node, const QString &name, const QVariant &data);
void customNotification(const AbstractView *view, const QString &identifier, const QList<ModelNode> &nodeList, const QList<QVariant> &data);
{
}
+void DesignDocumentControllerView::instancesCompleted(const QVector<ModelNode> &/*completedNodeList*/)
+{
+
+}
+
static QStringList arrayToStringList(const QByteArray &byteArray)
{
QString str(QString::fromLatin1(byteArray));
virtual void nodeOrderChanged(const NodeListProperty &listProperty, const ModelNode &movedNode, int oldIndex);
virtual void scriptFunctionsChanged(const ModelNode &node, const QStringList &scriptFunctionList);
void instancePropertyChange(const QList<QPair<ModelNode, QString> > &propertyList);
-
+ void instancesCompleted(const QVector<ModelNode> &completedNodeList);
ModelNode insertModel(const ModelNode &modelNode)
{ return m_modelMerger.insertModel(modelNode); }
{
}
+void NavigatorView::instancesCompleted(const QVector<ModelNode> &/*completedNodeList*/)
+{
+}
+
void NavigatorView::nodeOrderChanged(const NodeListProperty &listProperty, const ModelNode &node, int oldIndex)
{
if (m_treeModel->isInTree(node))
void auxiliaryDataChanged(const ModelNode &node, const QString &name, const QVariant &data);
void scriptFunctionsChanged(const ModelNode &node, const QStringList &scriptFunctionList);
void instancePropertyChange(const QList<QPair<ModelNode, QString> > &propertyList);
+ void instancesCompleted(const QVector<ModelNode> &completedNodeList);
private slots:
// void handleChangedItem(QStandardItem * item);
$$PWD/instances/addimportcommand.cpp \
$$PWD/instances/childrenchangedcommand.cpp \
$$PWD/instances/statepreviewimagechangedcommand.cpp \
- $$PWD/instances/imagecontainer.cpp
+ $$PWD/instances/imagecontainer.cpp \
+ $$PWD/instances/completecomponentcommand.cpp \
+ $$PWD/instances/componentcompletedcommand.cpp
HEADERS += $$PWD/include/corelib_global.h \
$$PWD/include/abstractview.h \
$$PWD/include/nodeinstanceview.h \
$$PWD/instances/addimportcommand.h \
$$PWD/instances/childrenchangedcommand.h \
$$PWD/instances/statepreviewimagechangedcommand.h \
- $$PWD/instances/imagecontainer.h
+ $$PWD/instances/imagecontainer.h \
+ $$PWD/instances/completecomponentcommand.h \
+ $$PWD/instances/componentcompletedcommand.h
contains(CONFIG, plugin) {
# If core.pri has been included in the qmldesigner plugin
SOURCES += $$PWD/model/basetexteditmodifier.cpp
void emitCustomNotification(const QString &identifier, const QList<ModelNode> &nodeList, const QList<QVariant> &data);
void emitInstancePropertyChange(const QList<QPair<ModelNode, QString> > &propertyList);
+ void emitInstancesCompleted(const QVector<ModelNode> &nodeList);
virtual void modelAttached(Model *model);
virtual void modelAboutToBeDetached(Model *model);
virtual void rootNodeTypeChanged(const QString &type, int majorVersion, int minorVersion) = 0;
virtual void instancePropertyChange(const QList<QPair<ModelNode, QString> > &propertyList) = 0;
+ virtual void instancesCompleted(const QVector<ModelNode> &completedNodeList) = 0;
+
virtual void selectedNodesChanged(const QList<ModelNode> &selectedNodeList,
const QList<ModelNode> &lastSelectedNodeList) = 0;
class InformationChangedCommand;
class ChildrenChangedCommand;
class StatePreviewImageChangedCommand;
+class ComponentCompletedCommand;
class NodeInstanceClientInterface
{
virtual void pixmapChanged(const PixmapChangedCommand &command) = 0;
virtual void childrenChanged(const ChildrenChangedCommand &command) = 0;
virtual void statePreviewImagesChanged(const StatePreviewImageChangedCommand &command) = 0;
+ virtual void componentCompleted(const ComponentCompletedCommand &command) = 0;
virtual void flush() {};
virtual qint64 bytesToWrite() const {return 0;}
class RemovePropertiesCommand;
class ChangeStateCommand;
class AddImportCommand;
+class CompleteComponentCommand;
class NodeInstanceServerInterface : public QObject
{
virtual void changeIds(const ChangeIdsCommand &command) = 0;
virtual void changeState(const ChangeStateCommand &command) = 0;
virtual void addImport(const AddImportCommand &command) = 0;
+ virtual void completeComponent(const CompleteComponentCommand &command) = 0;
virtual void setBlockUpdates(bool /*block*/) {}
class RemoveInstancesCommand;
class RemovePropertiesCommand;
class AddImportCommand;
+class CompleteComponentCommand;
class CORESHARED_EXPORT NodeInstanceView : public AbstractView, public NodeInstanceClientInterface
{
void selectedNodesChanged(const QList<ModelNode> &selectedNodeList, const QList<ModelNode> &lastSelectedNodeList);
void scriptFunctionsChanged(const ModelNode &node, const QStringList &scriptFunctionList);
void instancePropertyChange(const QList<QPair<ModelNode, QString> > &propertyList);
+ void instancesCompleted(const QVector<ModelNode> &completedNodeList);
void importAdded(const Import &import);
void importRemoved(const Import &import);
void informationChanged(const InformationChangedCommand &command);
void childrenChanged(const ChildrenChangedCommand &command);
void statePreviewImagesChanged(const StatePreviewImageChangedCommand &command);
+ void componentCompleted(const ComponentCompletedCommand &command);
private: // functions
NodeInstance rootNodeInstance() const;
CreateSceneCommand createCreateSceneCommand() const;
ClearSceneCommand createClearSceneCommand() const;
CreateInstancesCommand createCreateInstancesCommand(const QList<NodeInstance> &instanceList) const;
+ CompleteComponentCommand createComponentCompleteCommand(const QList<NodeInstance> &instanceList) const;
+ ComponentCompletedCommand createComponentCompletedCommand(const QList<NodeInstance> &instanceList) const;
ReparentInstancesCommand createReparentInstancesCommand(const QList<NodeInstance> &instanceList) const;
ReparentInstancesCommand createReparentInstancesCommand(const ModelNode &node, const NodeAbstractProperty &newPropertyParent, const NodeAbstractProperty &oldPropertyParent) const;
ChangeFileUrlCommand createChangeFileUrlCommand(const QUrl &fileUrl) const;
virtual void nodeInstancePropertyChanged(const ModelNode &node, const QString &propertyName);
void instancePropertyChange(const QList<QPair<ModelNode, QString> > &propertyList);
+ void instancesCompleted(const QVector<ModelNode> &completedNodeList);
void nodeCreated(const ModelNode &createdNode);
void nodeRemoved(const ModelNode &removedNode, const NodeAbstractProperty &parentProperty, PropertyChangeFlags propertyChange);
void scriptFunctionsChanged(const ModelNode &node, const QStringList &scriptFunctionList);
void instancePropertyChange(const QList<QPair<ModelNode, QString> > &propertyList);
+ void instancesCompleted(const QVector<ModelNode> &completedNodeList);
void importAdded(const Import &import);
void importRemoved(const Import &import);
--- /dev/null
+#include "completecomponentcommand.h"
+
+namespace QmlDesigner {
+
+CompleteComponentCommand::CompleteComponentCommand()
+{
+}
+
+CompleteComponentCommand::CompleteComponentCommand(const QVector<qint32> &container)
+ : m_instanceVector(container)
+{
+}
+
+QVector<qint32> CompleteComponentCommand::instances() const
+{
+ return m_instanceVector;
+}
+
+QDataStream &operator<<(QDataStream &out, const CompleteComponentCommand &command)
+{
+ out << command.instances();
+
+ return out;
+}
+
+QDataStream &operator>>(QDataStream &in, CompleteComponentCommand &command)
+{
+ in >> command.m_instanceVector;
+
+ return in;
+}
+
+} // namespace QmlDesigner
--- /dev/null
+#ifndef COMPLETECOMPONENT_H
+#define COMPLETECOMPONENT_H
+
+#include <QMetaType>
+#include <QVector>
+
+namespace QmlDesigner {
+
+class CompleteComponentCommand
+{
+ friend QDataStream &operator>>(QDataStream &in, CompleteComponentCommand &command);
+
+public:
+ CompleteComponentCommand();
+ CompleteComponentCommand(const QVector<qint32> &container);
+
+ QVector<qint32> instances() const;
+
+private:
+ QVector<qint32> m_instanceVector;
+};
+
+QDataStream &operator<<(QDataStream &out, const CompleteComponentCommand &command);
+QDataStream &operator>>(QDataStream &in, CompleteComponentCommand &command);
+
+} // namespace QmlDesigner
+
+Q_DECLARE_METATYPE(QmlDesigner::CompleteComponentCommand);
+
+#endif // COMPLETECOMPONENT_H
--- /dev/null
+#include "componentcompletedcommand.h"
+
+namespace QmlDesigner {
+
+ComponentCompletedCommand::ComponentCompletedCommand()
+{
+}
+
+ComponentCompletedCommand::ComponentCompletedCommand(const QVector<qint32> &container)
+ : m_instanceVector(container)
+{
+}
+
+QVector<qint32> ComponentCompletedCommand::instances() const
+{
+ return m_instanceVector;
+}
+
+QDataStream &operator<<(QDataStream &out, const ComponentCompletedCommand &command)
+{
+ out << command.instances();
+
+ return out;
+}
+
+QDataStream &operator>>(QDataStream &in, ComponentCompletedCommand &command)
+{
+ in >> command.m_instanceVector;
+
+ return in;
+}
+
+} // namespace QmlDesigner
+
--- /dev/null
+#ifndef COMPONENTCOMPLETEDCOMMAND_H
+#define COMPONENTCOMPLETEDCOMMAND_H
+#include <QMetaType>
+#include <QVector>
+
+namespace QmlDesigner {
+
+class ComponentCompletedCommand
+{
+ friend QDataStream &operator>>(QDataStream &in, ComponentCompletedCommand &command);
+
+public:
+ ComponentCompletedCommand();
+ ComponentCompletedCommand(const QVector<qint32> &container);
+
+ QVector<qint32> instances() const;
+
+private:
+ QVector<qint32> m_instanceVector;
+};
+
+QDataStream &operator<<(QDataStream &out, const ComponentCompletedCommand &command);
+QDataStream &operator>>(QDataStream &in, ComponentCompletedCommand &command);
+
+} // namespace QmlDesigner
+
+Q_DECLARE_METATYPE(QmlDesigner::ComponentCompletedCommand);
+
+#endif // COMPONENTCOMPLETEDCOMMAND_H
HEADERS += $$PWD/behaviornodeinstance.h
+HEADERS += $$PWD/componentcompletedcommand.h
+HEADERS += $$PWD//completecomponentcommand.h
HEADERS += $$PWDstatepreviewimagechangedcommand.h
HEADERS += $$PWD//imagecontainer.h
HEADERS += $$PWD/childrenchangedcommand.h
SOURCES += $$PWD/behaviornodeinstance.cpp
+SOURCES += $$PWD/componentcompletedcommand.cpp
+SOURCES += $$PWD/completecomponentcommand.cpp
SOURCES += $$PWD/statepreviewimagechangedcommand.cpp
SOURCES += $$PWD/imagecontainer.cpp
SOURCES += $$PWD/childrenchangedcommand.cpp
#include "changeidscommand.h"
#include "changestatecommand.h"
#include "addimportcommand.h"
+#include "completecomponentcommand.h"
#include "informationchangedcommand.h"
#include "pixmapchangedcommand.h"
#include "childrenchangedcommand.h"
#include "imagecontainer.h"
#include "statepreviewimagechangedcommand.h"
+#include "componentcompletedcommand.h"
namespace QmlDesigner {
writeCommand(QVariant::fromValue(command));
}
+void NodeInstanceClientProxy::componentCompleted(const ComponentCompletedCommand &command)
+{
+ writeCommand(QVariant::fromValue(command));
+}
+
void NodeInstanceClientProxy::flush()
{
}
static const int changeIdsCommandType = QMetaType::type("ChangeIdsCommand");
static const int changeStateCommandType = QMetaType::type("ChangeStateCommand");
static const int addImportCommandType = QMetaType::type("AddImportCommand");
+ static const int completeComponentCommandType = QMetaType::type("CompleteComponentCommand");
if (command.userType() == createInstancesCommandType)
nodeInstanceServer()->createInstances(command.value<CreateInstancesCommand>());
nodeInstanceServer()->changeState(command.value<ChangeStateCommand>());
else if (command.userType() == addImportCommandType)
nodeInstanceServer()->addImport(command.value<AddImportCommand>());
+ else if (command.userType() == completeComponentCommandType)
+ nodeInstanceServer()->completeComponent(command.value<CompleteComponentCommand>());
else
Q_ASSERT(false);
}
void pixmapChanged(const PixmapChangedCommand &command);
void childrenChanged(const ChildrenChangedCommand &command);
void statePreviewImagesChanged(const StatePreviewImageChangedCommand &command);
+ void componentCompleted(const ComponentCompletedCommand &command);
+
void flush();
qint64 bytesToWrite() const;
#include "changestatecommand.h"
#include "addimportcommand.h"
#include "childrenchangedcommand.h"
+#include "completecomponentcommand.h"
+#include "componentcompletedcommand.h"
#include <iostream>
#include <stdio.h>
}
}
-
- instance.doComponentComplete();
}
nodeInstanceClient()->valuesChanged(createValuesChangedCommand(instanceList));
startRenderTimer();
}
+void NodeInstanceServer::completeComponent(const CompleteComponentCommand &command)
+{
+ foreach(qint32 instanceId, command.instances()) {
+ if (hasInstanceForId(instanceId)) {
+ ServerNodeInstance instance = instanceForId(instanceId);
+ instance.doComponentComplete();
+ m_componentCompletedVector.append(instanceId);
+ }
+ }
+}
+
void NodeInstanceServer::addImport(const AddImportCommand &command)
{
QString importStatement = QString("import ");
if (!parentChangedSet.isEmpty())
sendChildrenChangedCommand(parentChangedSet.toList());
+ if (!m_componentCompletedVector.isEmpty())
+ nodeInstanceClient()->componentCompleted(ComponentCompletedCommand(m_componentCompletedVector));
+ m_componentCompletedVector.clear();
+
if (!dirtyInstanceSet.isEmpty())
nodeInstanceClient()->pixmapChanged(createPixmapChangedCommand(dirtyInstanceSet.toList()));
void reparentInstances(const ReparentInstancesCommand &command);
void changeState(const ChangeStateCommand &command);
void addImport(const AddImportCommand &command);
+ void completeComponent(const CompleteComponentCommand &command);
ServerNodeInstance instanceForId(qint32 id) const;
bool hasInstanceForId(qint32 id) const;
int m_timer;
bool m_slowRenderTimer;
QVector<InstancePropertyPair> m_changedPropertyList;
+ QVector<qint32> m_componentCompletedVector;
QStringList m_importList;
};
#include "reparentinstancescommand.h"
#include "changeidscommand.h"
#include "changestatecommand.h"
+#include "completecomponentcommand.h"
#include "informationchangedcommand.h"
#include "pixmapchangedcommand.h"
#include "childrenchangedcommand.h"
#include "imagecontainer.h"
#include "statepreviewimagechangedcommand.h"
+#include "componentcompletedcommand.h"
namespace QmlDesigner {
qRegisterMetaType<StatePreviewImageChangedCommand>("StatePreviewImageChangedCommand");
qRegisterMetaTypeStreamOperators<StatePreviewImageChangedCommand>("StatePreviewImageChangedCommand");
+
+ qRegisterMetaType<CompleteComponentCommand>("CompleteComponentCommand");
+ qRegisterMetaTypeStreamOperators<CompleteComponentCommand>("CompleteComponentCommand");
+
+ qRegisterMetaType<ComponentCompletedCommand>("ComponentCompletedCommand");
+ qRegisterMetaTypeStreamOperators<ComponentCompletedCommand>("ComponentCompletedCommand");
}
}
#include "changeidscommand.h"
#include "changestatecommand.h"
#include "addimportcommand.h"
+#include "completecomponentcommand.h"
#include "informationchangedcommand.h"
#include "pixmapchangedcommand.h"
#include "childrenchangedcommand.h"
#include "imagecontainer.h"
#include "statepreviewimagechangedcommand.h"
+#include "componentcompletedcommand.h"
#include "nodeinstanceview.h"
#include "nodeinstanceclientproxy.h"
static const int pixmapChangedCommandType = QMetaType::type("PixmapChangedCommand");
static const int childrenChangedCommandType = QMetaType::type("ChildrenChangedCommand");
static const int statePreviewImageChangedCommandType = QMetaType::type("StatePreviewImageChangedCommand");
+ static const int componentCompletedCommandType = QMetaType::type("ComponentCompletedCommand");
if (command.userType() == informationChangedCommandType)
nodeInstanceClient()->informationChanged(command.value<InformationChangedCommand>());
nodeInstanceClient()->childrenChanged(command.value<ChildrenChangedCommand>());
else if (command.userType() == statePreviewImageChangedCommandType)
nodeInstanceClient()->statePreviewImagesChanged(command.value<StatePreviewImageChangedCommand>());
+ else if (command.userType() == componentCompletedCommandType)
+ nodeInstanceClient()->componentCompleted(command.value<ComponentCompletedCommand>());
else
Q_ASSERT(false);
}
{
writeCommand(QVariant::fromValue(command));
}
+
+void NodeInstanceServerProxy::completeComponent(const CompleteComponentCommand &command)
+{
+ writeCommand(QVariant::fromValue(command));
+}
} // namespace QmlDesigner
void changeIds(const ChangeIdsCommand &command);
void changeState(const ChangeStateCommand &command);
void addImport(const AddImportCommand &command);
+ void completeComponent(const CompleteComponentCommand &command);
void setBlockUpdates(bool block);
#include "childrenchangedcommand.h"
#include "imagecontainer.h"
#include "statepreviewimagechangedcommand.h"
+#include "completecomponentcommand.h"
+#include "componentcompletedcommand.h"
#include "nodeinstanceserverproxy.h"
nodeInstanceServer()->addImport(createImportCommand(import));
loadNodes(allModelNodes());
+
setBlockUpdates(false);
}
NodeInstance instance = loadNode(createdNode);
nodeInstanceServer()->createInstances(createCreateInstancesCommand(QList<NodeInstance>() << instance));
nodeInstanceServer()->changePropertyValues(createChangeValueCommand(createdNode.variantProperties()));
+ nodeInstanceServer()->completeComponent(createComponentCompleteCommand(QList<NodeInstance>() << instance));
}
/*! \brief Notifing the view that a node was created.
}
+void NodeInstanceView::instancesCompleted(const QVector<ModelNode> &/*completedNodeList*/)
+{
+}
+
void NodeInstanceView::importAdded(const Import &import)
{
nodeInstanceServer()->addImport(createImportCommand(import));
bindingPropertyList.append(node.bindingProperties());
}
-// QListIterator<ModelNode> listIterator(nodeList);
-// listIterator.toBack();
-
-// while (listIterator.hasPrevious())
-// instanceForNode(listIterator.previous()).doComponentComplete();
-
nodeInstanceServer()->createInstances(createCreateInstancesCommand(instanceList));
nodeInstanceServer()->reparentInstances(createReparentInstancesCommand(instanceList));
nodeInstanceServer()->changeIds(createChangeIdsCommand(instanceList));
nodeInstanceServer()->changePropertyValues(createChangeValueCommand(variantPropertyList));
nodeInstanceServer()->changePropertyBindings(createChangeBindingCommand(bindingPropertyList));
+ nodeInstanceServer()->completeComponent(createComponentCompleteCommand(instanceList));
}
void NodeInstanceView::removeAllInstanceNodeRelationships()
return ClearSceneCommand();
}
+CompleteComponentCommand NodeInstanceView::createComponentCompleteCommand(const QList<NodeInstance> &instanceList) const
+{
+ QVector<qint32> containerList;
+ foreach(const NodeInstance &instance, instanceList) {
+ if (instance.instanceId() >= 0)
+ containerList.append(instance.instanceId());
+ }
+
+ return CompleteComponentCommand(containerList);
+}
+
+ComponentCompletedCommand NodeInstanceView::createComponentCompletedCommand(const QList<NodeInstance> &instanceList) const
+{
+ QVector<qint32> containerList;
+ foreach(const NodeInstance &instance, instanceList) {
+ if (instance.instanceId() >= 0)
+ containerList.append(instance.instanceId());
+ }
+
+ return ComponentCompletedCommand(containerList);
+}
+
CreateInstancesCommand NodeInstanceView::createCreateInstancesCommand(const QList<NodeInstance> &instanceList) const
{
QVector<InstanceContainer> containerList;
}
+void NodeInstanceView::componentCompleted(const ComponentCompletedCommand &command)
+{
+ if (!model())
+ return;
+
+ QVector<ModelNode> nodeVector;
+
+ foreach(const qint32 &instanceId, command.instances()) {
+ if (hasModelNodeForInternalId(instanceId)) {
+ nodeVector.append(modelNodeForInternalId(instanceId));
+ }
+ }
+
+ if (!nodeVector.isEmpty())
+ emitInstancesCompleted(nodeVector);
+}
+
void NodeInstanceView::childrenChanged(const ChildrenChangedCommand &command)
{
if (!model())
model()->m_d->notifyInstancePropertyChange(propertyList);
}
+void AbstractView::emitInstancesCompleted(const QVector<ModelNode> &nodeVector)
+{
+ if (model() && nodeInstanceView() == this)
+ model()->m_d->notifyInstancesCompleted(nodeVector);
+}
+
void AbstractView::changeRootNodeType(const QString &type, int majorVersion, int minorVersion)
{
Internal::WriteLocker locker(m_model.data());
}
}
+void ModelPrivate::notifyInstancesCompleted(const QVector<ModelNode> &nodeVector)
+{
+ bool resetModel = false;
+ QString description;
+
+ QVector<Internal::InternalNode::Pointer> internalVector(toInternalNodeVector(nodeVector));
+
+ try {
+ if (rewriterView())
+ rewriterView()->instancesCompleted(toModelNodeVector(internalVector, rewriterView()));
+ } catch (RewritingException &e) {
+ description = e.description();
+ resetModel = true;
+ }
+
+ foreach (const QWeakPointer<AbstractView> &view, m_viewList) {
+ Q_ASSERT(view != 0);
+ view->instancesCompleted(toModelNodeVector(internalVector, view.data()));
+ }
+
+ if (nodeInstanceView()) {
+ nodeInstanceView()->instancesCompleted(toModelNodeVector(internalVector, nodeInstanceView()));
+ }
+
+ if (resetModel) {
+ resetModelByRewriter(description);
+ }
+}
+
void ModelPrivate::notifyCustomNotification(const AbstractView *senderView, const QString &identifier, const QList<ModelNode> &nodeList, const QList<QVariant> &data)
{
bool resetModel = false;
return newNodeList;
}
+QVector<ModelNode> ModelPrivate::toModelNodeVector(const QVector<InternalNode::Pointer> &nodeVector, AbstractView *view) const
+{
+ QVector<ModelNode> newNodeVector;
+ foreach (const Internal::InternalNode::Pointer &node, nodeVector)
+ newNodeVector.append(ModelNode(node, model(), view));
+
+ return newNodeVector;
+}
+
QList<Internal::InternalNode::Pointer> ModelPrivate::toInternalNodeList(const QList<ModelNode> &nodeList) const
{
QList<Internal::InternalNode::Pointer> newNodeList;
return newNodeList;
}
+QVector<Internal::InternalNode::Pointer> ModelPrivate::toInternalNodeVector(const QVector<ModelNode> &nodeVector) const
+{
+ QVector<Internal::InternalNode::Pointer> newNodeVector;
+ foreach (const ModelNode &node, nodeVector)
+ newNodeVector.append(node.internalNode());
+
+ return newNodeVector;
+}
+
void ModelPrivate::changeSelectedNodes(const QList<InternalNode::Pointer> &newSelectedNodeList,
const QList<InternalNode::Pointer> &oldSelectedNodeList)
{
void notifyCustomNotification(const AbstractView *senderView, const QString &identifier, const QList<ModelNode> &nodeList, const QList<QVariant> &data);
void notifyInstancePropertyChange(const QList<QPair<ModelNode, QString> > &propertyList);
-
+ void notifyInstancesCompleted(const QVector<ModelNode> &nodeList);
void setSelectedNodes(const QList<InternalNodePointer> &selectedNodeList);
void removeNodeFromModel(const InternalNodePointer &node);
QList<InternalNodePointer> toInternalNodeList(const QList<ModelNode> &nodeList) const;
QList<ModelNode> toModelNodeList(const QList<InternalNodePointer> &nodeList, AbstractView *view) const;
+ QVector<ModelNode> toModelNodeVector(const QVector<InternalNodePointer> &nodeVector, AbstractView *view) const;
+ QVector<InternalNodePointer> toInternalNodeVector(const QVector<ModelNode> &nodeVector) const;
private:
Model *m_q;
nodeInstancePropertyChanged(propertyPair.first, propertyPair.second);
}
}
+void QmlModelView::instancesCompleted(const QVector<ModelNode> &/*completedNodeList*/)
+{
+}
void QmlModelView::nodeInstancePropertyChanged(const ModelNode &node, const QString &propertyName)
{
{
}
-void QmlModelView::stateChanged(const QmlModelState &newQmlModelState, const QmlModelState &oldQmlModelState)
+void QmlModelView::stateChanged(const QmlModelState &/*newQmlModelState*/, const QmlModelState &/*oldQmlModelState*/)
{
}
{
}
+void RewriterView::instancesCompleted(const QVector<ModelNode> &/*completedNodeList*/)
+{
+}
+
void RewriterView::selectedNodesChanged(const QList<ModelNode> & /* selectedNodeList, */, const QList<ModelNode> & /*lastSelectedNodeList */)
{
m_output << time() << indent("property: ") << propertyPair.first << propertyPair.second << endl;
}
+void ViewLogger::instancesCompleted(const QVector<ModelNode> &completedNodeList)
+{
+ m_output << time() << indent("instancesCompleted:") << endl;
+
+ foreach(const ModelNode &node, completedNodeList)
+ m_output << time() << indent("node: ") << node << endl;
+
+}
} // namespace Internal
} // namespace QmlDesigner
void customNotification(const AbstractView *view, const QString &identifier, const QList<ModelNode> &nodeList, const QList<QVariant> &data);
void scriptFunctionsChanged(const ModelNode &node, const QStringList &scriptFunctionList);
void instancePropertyChange(const QList<QPair<ModelNode, QString> > &propertyList);
-
+ void instancesCompleted(const QVector<ModelNode> &completedNodeList);
protected:
QString time() const;