static ModelNode resolveBinding(const QString &binding, ModelNode currentNode, AbstractView* view)
{
int i = 0;
QString element = binding.split(QLatin1Char('.')).at(0);
while (!element.isEmpty())
{
if (element == "parent") {
if (currentNode.hasParentProperty())
currentNode = currentNode.parentProperty().toNodeAbstractProperty().parentModelNode();
else
return ModelNode(); //binding not valid
} else if (currentNode.hasProperty(element)) {
if (currentNode.property(element).isNodeProperty()) {
currentNode = currentNode.nodeProperty(element).modelNode();
} else {
currentNode = view->modelNodeForId(element); //id
if (!currentNode.isValid())
return ModelNode(); //binding not valid
}
} else {
currentNode = view->modelNodeForId(element); //id
}
i++;
if (i < binding.split(QLatin1Char('.')).count())
element = binding.split(QLatin1Char('.')).at(i);
else
element.clear();
}
return currentNode;
}
ModelNode AbstractView::singleSelectedModelNode() const
{
if (hasSingleSelectedModelNode())
return ModelNode(model()->d->selectedNodes().first(), model(), this);
return ModelNode();
}
ModelNode AbstractView::currentStateNode() const
{
if (model())
return ModelNode(m_model.data()->d->currentStateNode(), m_model.data(), const_cast<AbstractView*>(this));
return ModelNode();
}
ModelNode AnchorLine::modelNode() const
{
if (m_internalNode.isNull() || m_internalNodeState.isNull() || m_model.isNull()) {
return ModelNode();
}
return ModelNode(m_internalNode, m_model.data());
}
ModelNode NodeProperty::modelNode() const
{
if (!isValid())
throw InvalidModelNodeException(__LINE__, __FUNCTION__, __FILE__);
if (internalNode()->hasProperty(name())) { //check if oldValue != value
Internal::InternalProperty::Pointer internalProperty = internalNode()->property(name());
if (internalProperty->isNodeProperty())
return ModelNode(internalProperty->toNodeProperty()->node(), model(), view());
}
return ModelNode();
}
void PropertyEditorView::resetView()
{
if (model() == 0)
return;
m_locked = true;
if (debug)
qDebug() << "________________ RELOADING PROPERTY EDITOR QML _______________________";
if (m_timerId)
killTimer(m_timerId);
if (m_selectedNode.isValid() && model() != m_selectedNode.model())
m_selectedNode = ModelNode();
setupQmlBackend();
if (m_qmlBackEndForCurrentType)
m_qmlBackEndForCurrentType->emitSelectionChanged();
m_locked = false;
if (m_timerId)
m_timerId = 0;
updateSize();
}
ModelNode NodeInstance::modelNode() const
{
if (d)
return d->modelNode;
else
return ModelNode();
}
ModelNode QmlModelStateOperation::target() const
{
if (modelNode().property("target").isBindingProperty())
return modelNode().bindingProperty("target").resolveToModelNode();
else
return ModelNode(); //exception?
}
QList<ModelNode> toModelNodeList(const QList<Internal::InternalNode::Pointer> &nodeList, AbstractView *view)
{
QList<ModelNode> newNodeList;
foreach (const Internal::InternalNode::Pointer &node, nodeList)
newNodeList.append(ModelNode(node, view->model(), view));
return newNodeList;
}
ModelNode ComponentView::modelNode(int index) const
{
if (m_standardItemModel->hasIndex(index, 0)) {
QStandardItem *item = m_standardItemModel->item(index, 0);
return item->data(ModelNodeRole).value<ModelNode>();
}
return ModelNode();
}
ModelNode ComponentView::modelNode(int index) const
{
if (m_standardItemModel->hasIndex(index, 0)) {
QStandardItem *item = m_standardItemModel->item(index, 0);
return modelNodeForInternalId(qint32(item->data(ModelNodeRole).toInt()));
}
return ModelNode();
}
ModelNode AbstractView::createModelNode(const TypeName &typeName,
int majorVersion,
int minorVersion,
const QList<QPair<PropertyName, QVariant> > &propertyList,
const QList<QPair<PropertyName, QVariant> > &auxPropertyList,
const QString &nodeSource,
ModelNode::NodeSourceType nodeSourceType)
{
return ModelNode(model()->d->createNode(typeName, majorVersion, minorVersion, propertyList, auxPropertyList, nodeSource, nodeSourceType), model(), this);
}
void TreeGeneratorCanvas::Setup()
{
SceneManager* sceneMgr = gEngine->GetSceneManager();
D3DVIEWPORT9 viewPort = gEngine->GetDriver()->GetViewPort(swapChainIndex);
sceneMgr->CreateExtraCamera(Vector3(0, 0, -10.0f), Vector3::Zero,
PI/3, (float)viewPort.Width / (float)viewPort.Height, 0.1f, 1000.0f);
Camera* extraCamera = sceneMgr->GetExtraCamera();
HoverCameraController* hoverCameraController = New HoverCameraController(5.0f, 20.0f, -4*PI/9, 4*PI/9, 2.0f, 100.0f);
extraCamera->SetCameraController(hoverCameraController);
Cube* cubeGeo = New Cube(L"cubeGeo1");
gEngine->GetGeometryManager()->AddGeometry(cubeGeo);
cubeGeo->CalculateTBN();
cubeGeo->BuildGeometry(XYZ_UV_TBN);
mCube = New ModelNode(L"cube", NULL, cubeGeo, gEngine->GetMaterialManager()->GetDefaultFlatMtl());
mTree = New Tree();
}
QmlModelNodeFacade::QmlModelNodeFacade() : m_modelNode(ModelNode())
{}
ModelNode AbstractView::rootModelNode()
{
Q_ASSERT(model());
return ModelNode(model()->d->rootNode(), model(), this);
}
void NodeInstance::makeInvalid()
{
if (d)
d->modelNode = ModelNode();
}
ModelNode AbstractView::modelNodeForId(const QString &id)
{
return ModelNode(model()->d->nodeForId(id), model(), this);
}
static QList<ModelNode> internalNodesToModelNodes(const QList<Internal::InternalNode::Pointer> &inputList, Model* model, AbstractView *view)
{
QList<ModelNode> modelNodeList;
foreach (const Internal::InternalNode::Pointer &internalNode, inputList) {
modelNodeList.append(ModelNode(internalNode, model, view));
}
ModelNode AbstractView::modelNodeForInternalId(qint32 internalId)
{
return ModelNode(model()->d->nodeForInternalId(internalId), model(), this);
}
/*!
\brief returns the ModelNode to which the property belongs
\return node to which the property belongs
*/
ModelNode AbstractProperty::parentModelNode() const
{
return ModelNode(m_internalNode, m_model.data(), view());
}
/*!
\brief returns whether the property is the default property for the model node.
*/
bool AbstractProperty::isDefaultProperty() const
{
return ModelNode(m_internalNode, m_model.data(), view()).metaInfo().defaultPropertyName() == m_propertyName;
}
const ModelNode AbstractView::rootModelNode() const
{
Q_ASSERT(model());
return ModelNode(model()->d->rootNode(), model(), const_cast<AbstractView*>(this));
}