formeditorview.cpp 19.1 KB
Newer Older
hjk's avatar
hjk committed
1
/****************************************************************************
2
**
3
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
hjk's avatar
hjk committed
4
** Contact: http://www.qt-project.org/legal
5
**
hjk's avatar
hjk committed
6
** This file is part of Qt Creator.
7
**
hjk's avatar
hjk committed
8 9 10 11 12 13 14
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.  For licensing terms and
** conditions see http://qt.digia.com/licensing.  For further information
** use the contact form at http://qt.digia.com/contact-us.
15 16
**
** GNU Lesser General Public License Usage
hjk's avatar
hjk committed
17 18 19 20 21 22 23 24 25
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights.  These rights are described in the Digia Qt LGPL Exception
con's avatar
con committed
26 27
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
hjk's avatar
hjk committed
28
****************************************************************************/
29 30 31 32 33 34 35 36 37 38

#include "selectiontool.h"
#include "movetool.h"
#include "resizetool.h"
#include "dragtool.h"
#include "formeditorview.h"
#include "formeditorwidget.h"
#include "formeditornodeinstanceview.h"
#include "formeditoritem.h"
#include "formeditorscene.h"
Thomas Hartmann's avatar
Thomas Hartmann committed
39
#include "toolbox.h"
40 41 42 43 44 45
#include <rewritertransaction.h>
#include <modelnode.h>
#include <itemlibraryinfo.h>
#include <metainfo.h>
#include <model.h>
#include <QApplication>
hjk's avatar
hjk committed
46
#include <QDebug>
47 48 49 50
#include <QPair>
#include <QString>
#include <QDir>
#include <QAction>
51
#include <QTimer>
52
#include <zoomaction.h>
53 54
#include <nodeabstractproperty.h>
#include <nodelistproperty.h>
55
#include <commondefines.h>
56

57 58 59 60 61 62 63 64 65 66 67

namespace QmlDesigner {

FormEditorView::FormEditorView(QObject *parent)
    : QmlModelView(parent),
      m_formEditorWidget(new FormEditorWidget(this)),
      m_scene(new FormEditorScene(m_formEditorWidget.data(), this)),
      m_moveTool(new MoveTool(this)),
      m_selectionTool(new SelectionTool(this)),
      m_resizeTool(new ResizeTool(this)),
      m_dragTool(new DragTool(this)),
68 69
      m_currentTool(m_selectionTool),
      m_transactionCounter(0)
70
{
Marco Bubke's avatar
Marco Bubke committed
71 72 73
    connect(formEditorWidget()->zoomAction(), SIGNAL(zoomLevelChanged(double)), SLOT(updateGraphicsIndicators()));
    connect(formEditorWidget()->showBoundingRectAction(), SIGNAL(toggled(bool)), scene(), SLOT(setShowBoundingRects(bool)));
    connect(formEditorWidget()->selectOnlyContentItemsAction(), SIGNAL(toggled(bool)), this, SLOT(setSelectOnlyContentItemsAction(bool)));
74

75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
}

FormEditorScene* FormEditorView::scene() const
{
    return m_scene.data();
}

FormEditorView::~FormEditorView()
{
    delete m_selectionTool;
    m_selectionTool = 0;
    delete m_moveTool;
    m_moveTool = 0;
    delete m_resizeTool;
    m_resizeTool = 0;
    delete m_dragTool;
    m_dragTool = 0;


    // delete scene after tools to prevent double deletion
    // of items
    delete m_scene.data();
    delete m_formEditorWidget.data();
}

void FormEditorView::modelAttached(Model *model)
{
    Q_ASSERT(model);

    QmlModelView::modelAttached(model);

    Q_ASSERT(m_scene->formLayerItem());

    if (rootQmlObjectNode().toQmlItemNode().isValid())
        setupFormEditorItemTree(rootQmlObjectNode().toQmlItemNode());
110 111

    m_formEditorWidget->updateActions();
112 113 114
}


Tobias Hunger's avatar
Tobias Hunger committed
115
//This method does the setup of the initial FormEditorItem tree in the scene
116 117 118 119
void FormEditorView::setupFormEditorItemTree(const QmlItemNode &qmlItemNode)
{
    m_scene->addFormEditorItem(qmlItemNode);

120
    foreach (const QmlObjectNode &nextNode, qmlItemNode.allDirectSubNodes()) //TODO instance children
121 122
        //If the node has source for components/custom parsers we ignore it.
        if (QmlItemNode(nextNode).isValid() && nextNode.modelNode().nodeSourceType() == ModelNode::NodeWithoutSource)
123
            setupFormEditorItemTree(nextNode.toQmlItemNode());
124 125
}

126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
void FormEditorView::removeNodeFromScene(const QmlItemNode &qmlItemNode)
{
    if (qmlItemNode.isValid()) {
        QList<QmlItemNode> nodeList;
        nodeList.append(qmlItemNode.allSubModelNodes());
        nodeList.append(qmlItemNode);

        QList<FormEditorItem*> removedItemList;
        removedItemList.append(scene()->itemsForQmlItemNodes(nodeList));
        m_currentTool->itemsAboutToRemoved(removedItemList);

        qDeleteAll(removedItemList);
    }
}

void FormEditorView::hideNodeFromScene(const QmlItemNode &qmlItemNode)
{
    if (qmlItemNode.isValid()) {

        FormEditorItem *item = m_scene->itemForQmlItemNode(qmlItemNode);

        QList<QmlItemNode> nodeList;
        nodeList.append(qmlItemNode.allSubModelNodes());
        nodeList.append(qmlItemNode);

        QList<FormEditorItem*> removedItemList;
        removedItemList.append(scene()->itemsForQmlItemNodes(nodeList));
        m_currentTool->itemsAboutToRemoved(removedItemList);
        item->setFormEditorVisible(false);
    }
}

158 159 160 161
void FormEditorView::nodeCreated(const ModelNode &createdNode)
{
    QmlModelView::nodeCreated(createdNode);
    ModelNode node(createdNode);
162
    //If the node has source for components/custom parsers we ignore it.
Thomas Hartmann's avatar
Thomas Hartmann committed
163
    if (QmlItemNode(node).isValid() && node.nodeSourceType() == ModelNode::NodeWithoutSource) //only setup QmlItems
164 165 166 167 168 169 170 171 172 173
        setupFormEditorItemTree(QmlItemNode(node));
}

void FormEditorView::modelAboutToBeDetached(Model *model)
{
    m_selectionTool->clear();
    m_moveTool->clear();
    m_resizeTool->clear();
    m_dragTool->clear();
    m_scene->clearFormEditorItems();
174
    m_formEditorWidget->updateActions();
Marco Bubke's avatar
Marco Bubke committed
175 176
    m_formEditorWidget->resetView();
    scene()->resetScene();
177 178 179 180

    QmlModelView::modelAboutToBeDetached(model);
}

181
void FormEditorView::importsChanged(const QList<Import> &/*addedImports*/, const QList<Import> &/*removedImports*/)
182 183 184 185
{
    reset();
}

186 187 188 189
void FormEditorView::nodeAboutToBeRemoved(const ModelNode &removedNode)
{
    QmlItemNode qmlItemNode(removedNode);

190
    removeNodeFromScene(qmlItemNode);
191 192 193 194

    QmlModelView::nodeAboutToBeRemoved(removedNode);
}

195
 void FormEditorView::rootNodeTypeChanged(const QString &type, int majorVersion, int minorVersion)
196
 {
197 198 199 200
     foreach (FormEditorItem *item, m_scene->allFormEditorItems()) {
         item->setParentItem(0);
         item->setParent(0);
     }
201

202 203
     foreach (FormEditorItem *item, m_scene->allFormEditorItems()) {
         m_scene->removeItemFromHash(item);
204
         delete item;
205 206
     }

207
     QmlModelView::rootNodeTypeChanged(type, majorVersion, minorVersion);
208

209
     QmlItemNode newItemNode(rootModelNode());
210 211
     if (newItemNode.isValid()) //only setup QmlItems
         setupFormEditorItemTree(newItemNode);
212 213

     m_currentTool->setItems(scene()->itemsForQmlItemNodes(selectedQmlItemNodes()));
214 215 216 217
 }

void FormEditorView::propertiesAboutToBeRemoved(const QList<AbstractProperty>& propertyList)
{
218
    foreach (const AbstractProperty &property, propertyList) {
219 220 221 222
        if (property.isNodeAbstractProperty()) {
            NodeAbstractProperty nodeAbstractProperty = property.toNodeAbstractProperty();
            QList<FormEditorItem*> removedItemList;

223
            foreach (const ModelNode &modelNode, nodeAbstractProperty.allSubNodes()) {
224 225
                QmlItemNode qmlItemNode(modelNode);

226
                if (qmlItemNode.isValid() && m_scene->hasItemForQmlItemNode(qmlItemNode)) {
227 228 229 230 231 232 233 234 235 236 237
                    FormEditorItem *item = m_scene->itemForQmlItemNode(qmlItemNode);
                    removedItemList.append(item);

                    delete item;
                }
            }

            m_currentTool->itemsAboutToRemoved(removedItemList);
        }
    }

238 239
    QmlModelView::propertiesAboutToBeRemoved(propertyList);
}
240 241 242 243 244 245 246 247 248 249 250 251

static inline bool hasNodeSourceParent(const ModelNode &node)
{
    if (node.parentProperty().isValid() && node.parentProperty().parentModelNode().isValid()) {
        ModelNode parent = node.parentProperty().parentModelNode();
        if (parent.nodeSourceType() != ModelNode::NodeWithoutSource)
            return true;
        return hasNodeSourceParent(parent);
    }
    return false;
}

252 253
void FormEditorView::nodeReparented(const ModelNode &node, const NodeAbstractProperty &newPropertyParent, const NodeAbstractProperty &oldPropertyParent, AbstractView::PropertyChangeFlags propertyChange)
{
254 255 256
    if (hasNodeSourceParent(node))
        hideNodeFromScene(node);

257 258 259 260 261 262 263 264 265 266 267 268 269
    QmlModelView::nodeReparented(node, newPropertyParent, oldPropertyParent, propertyChange);
}

void FormEditorView::variantPropertiesChanged(const QList<VariantProperty>& propertyList, PropertyChangeFlags propertyChange)
{
    QmlModelView::variantPropertiesChanged(propertyList, propertyChange);
}

void FormEditorView::bindingPropertiesChanged(const QList<BindingProperty>& propertyList, PropertyChangeFlags propertyChange)
{
    QmlModelView::bindingPropertiesChanged(propertyList, propertyChange);
}

Marco Bubke's avatar
Marco Bubke committed
270 271 272 273 274 275
QWidget *FormEditorView::widget()
{
    return m_formEditorWidget.data();
}

FormEditorWidget *FormEditorView::formEditorWidget()
276 277 278 279 280 281
{
    return m_formEditorWidget.data();
}

void FormEditorView::nodeIdChanged(const ModelNode& node, const QString& newId, const QString& oldId)
{
Marco Bubke's avatar
Marco Bubke committed
282
    QmlModelView::nodeIdChanged(node, newId, oldId);
283 284
    QmlItemNode itemNode(node);

Thomas Hartmann's avatar
Thomas Hartmann committed
285
    if (itemNode.isValid() && node.nodeSourceType() == ModelNode::NodeWithoutSource) {
286 287 288
        FormEditorItem *item = m_scene->itemForQmlItemNode(itemNode);
        item->update();
    }
289 290 291 292 293 294 295 296 297 298 299 300
}

void FormEditorView::selectedNodesChanged(const QList<ModelNode> &selectedNodeList,
                                          const QList<ModelNode> &lastSelectedNodeList)
{
    QmlModelView::selectedNodesChanged(selectedNodeList, lastSelectedNodeList);

    m_currentTool->setItems(scene()->itemsForQmlItemNodes(toQmlItemNodeList(selectedNodeList)));

    m_scene->update();
}

Marco Bubke's avatar
Marco Bubke committed
301 302 303 304 305
void FormEditorView::scriptFunctionsChanged(const ModelNode &node, const QStringList &scriptFunctionList)
{
    QmlModelView::scriptFunctionsChanged(node, scriptFunctionList);
}

306 307 308
void FormEditorView::propertiesRemoved(const QList<AbstractProperty> &/*propertyList*/)
{
}
Marco Bubke's avatar
Marco Bubke committed
309

310 311 312 313 314
AbstractFormEditorTool* FormEditorView::currentTool() const
{
    return m_currentTool;
}

315
bool FormEditorView::changeToMoveTool()
316 317
{
    if (m_currentTool == m_moveTool)
318
        return true;
319

320
    if (!isMoveToolAvailable())
321
        return false;
322

323 324 325 326 327
    m_scene->updateAllFormEditorItems();
    m_currentTool->clear();
    m_currentTool = m_moveTool;
    m_currentTool->clear();
    m_currentTool->setItems(scene()->itemsForQmlItemNodes(selectedQmlItemNodes()));
328
    return true;
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
}

void FormEditorView::changeToDragTool()
{
    if (m_currentTool == m_dragTool)
        return;

    m_scene->updateAllFormEditorItems();
    m_currentTool->clear();
    m_currentTool = m_dragTool;
    m_currentTool->clear();
    m_currentTool->setItems(scene()->itemsForQmlItemNodes(selectedQmlItemNodes()));
}


344
bool FormEditorView::changeToMoveTool(const QPointF &beginPoint)
345 346
{
    if (m_currentTool == m_moveTool)
347
        return true;
348

349
    if (!isMoveToolAvailable())
350
        return false;
351

352 353 354 355 356 357
    m_scene->updateAllFormEditorItems();
    m_currentTool->clear();
    m_currentTool = m_moveTool;
    m_currentTool->clear();
    m_currentTool->setItems(scene()->itemsForQmlItemNodes(selectedQmlItemNodes()));
    m_moveTool->beginWithPoint(beginPoint);
358
    return true;
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
}

void FormEditorView::changeToSelectionTool()
{
    if (m_currentTool == m_selectionTool)
        return;

    m_scene->updateAllFormEditorItems();
    m_currentTool->clear();
    m_currentTool = m_selectionTool;
    m_currentTool->clear();
    m_currentTool->setItems(scene()->itemsForQmlItemNodes(selectedQmlItemNodes()));
}

void FormEditorView::changeToSelectionTool(QGraphicsSceneMouseEvent *event)
{
    if (m_currentTool == m_selectionTool)
        return;

    m_scene->updateAllFormEditorItems();
    m_currentTool->clear();
    m_currentTool = m_selectionTool;
    m_currentTool->clear();
    m_currentTool->setItems(scene()->itemsForQmlItemNodes(selectedQmlItemNodes()));

    m_selectionTool->selectUnderPoint(event);
}

void FormEditorView::changeToResizeTool()
{
    if (m_currentTool == m_resizeTool)
        return;

    m_scene->updateAllFormEditorItems();
    m_currentTool->clear();
    m_currentTool = m_resizeTool;
    m_currentTool->clear();
    m_currentTool->setItems(scene()->itemsForQmlItemNodes(selectedQmlItemNodes()));
}

void FormEditorView::changeToTransformTools()
{
    if (m_currentTool == m_moveTool ||
       m_currentTool == m_resizeTool ||
       m_currentTool == m_selectionTool)
        return;

    changeToSelectionTool();
}

void FormEditorView::nodeSlidedToIndex(const NodeListProperty &listProperty, int /*newIndex*/, int /*oldIndex*/)
{
    QList<ModelNode> newOrderModelNodeList = listProperty.toModelNodeList();
412
    foreach (const ModelNode &node, newOrderModelNodeList) {
413 414 415 416 417 418 419 420 421 422 423
        FormEditorItem *item = m_scene->itemForQmlItemNode(QmlItemNode(node));
        if (item) {
            FormEditorItem *oldParentItem = item->parentItem();
            item->setParentItem(0);
            item->setParentItem(oldParentItem);
        }
    }

    m_currentTool->formEditorItemsChanged(scene()->allFormEditorItems());
}

424
void FormEditorView::auxiliaryDataChanged(const ModelNode &node, const PropertyName &name, const QVariant &data)
425 426
{
    QmlModelView::auxiliaryDataChanged(node, name, data);
427
    if (name == "invisible" && m_scene->hasItemForQmlItemNode(QmlItemNode(node))) {
428 429
        FormEditorItem *item(m_scene->itemForQmlItemNode(QmlItemNode(node)));
        bool isInvisible = data.toBool();
430 431
        if (item->isFormEditorVisible())
            item->setVisible(!isInvisible);
432 433 434 435 436 437
        ModelNode newNode(node);
        if (isInvisible)
            newNode.deselectNode();
    }
}

438 439
void FormEditorView::instancesCompleted(const QVector<ModelNode> &completedNodeList)
{
440 441 442 443 444 445 446 447 448
    QList<FormEditorItem*> itemNodeList;
    foreach (const ModelNode &node, completedNodeList) {
        QmlItemNode qmlItemNode(node);
        if (qmlItemNode.isValid() && scene()->hasItemForQmlItemNode(qmlItemNode)) {
            scene()->synchronizeParent(qmlItemNode);
            itemNodeList.append(scene()->itemForQmlItemNode(qmlItemNode));
        }
    }
    currentTool()->instancesCompleted(itemNodeList);
449 450
}

451
void FormEditorView::instanceInformationsChange(const QMultiHash<ModelNode, InformationName> &informationChangeHash)
452
{
453
    QList<FormEditorItem*> itemNodeList;
454

455
    foreach (const ModelNode &node, informationChangeHash.keys()) {
456 457 458
        QmlItemNode qmlItemNode(node);
        if (qmlItemNode.isValid() && scene()->hasItemForQmlItemNode(qmlItemNode)) {
            scene()->synchronizeTransformation(qmlItemNode);
459
            if (qmlItemNode.isRootModelNode() && informationChangeHash.values(node).contains(Size)) {
Marco Bubke's avatar
Marco Bubke committed
460 461
                formEditorWidget()->setRootItemRect(qmlItemNode.instanceBoundingRect());
                formEditorWidget()->centerScene();
462
            }
463

464
            itemNodeList.append(scene()->itemForQmlItemNode(qmlItemNode));
465 466 467
        }
    }

468 469
    m_currentTool->formEditorItemsChanged(itemNodeList);
}
470

471 472 473 474
void FormEditorView::instancesRenderImageChanged(const QVector<ModelNode> &nodeList)
{
    foreach (const ModelNode &node, nodeList) {
        QmlItemNode qmlItemNode(node);
475
        if (qmlItemNode.isValid() && scene()->hasItemForQmlItemNode(qmlItemNode))
476
           scene()->itemForQmlItemNode(qmlItemNode)->update();
477
    }
478
}
479

480 481
void FormEditorView::instancesPreviewImageChanged(const QVector<ModelNode> &/*nodeList*/)
{
482

483
}
484

Marco Bubke's avatar
Marco Bubke committed
485
void FormEditorView::instancesToken(const QString &/*tokenName*/, int /*tokenNumber*/, const QVector<ModelNode> &/*nodeVector*/)
486 487 488
{
}

489 490 491 492 493 494 495 496 497 498
void FormEditorView::instancesChildrenChanged(const QVector<ModelNode> &nodeList)
{
    QList<FormEditorItem*> itemNodeList;

    foreach (const ModelNode &node, nodeList) {
        QmlItemNode qmlItemNode(node);
        if (qmlItemNode.isValid() && scene()->hasItemForQmlItemNode(qmlItemNode)) {
            scene()->synchronizeParent(qmlItemNode);
            itemNodeList.append(scene()->itemForQmlItemNode(qmlItemNode));
        }
499 500
    }

501
    m_currentTool->formEditorItemsChanged(itemNodeList);
502
    m_currentTool->instancesParentChanged(itemNodeList);
503 504
}

505 506 507 508 509 510 511 512 513
void FormEditorView::rewriterBeginTransaction()
{
    m_transactionCounter++;
}

void FormEditorView::rewriterEndTransaction()
{
    m_transactionCounter--;
}
514

515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550
double FormEditorView::margins() const
{
    return m_formEditorWidget->margins();
}

double FormEditorView::spacing() const
{
    return m_formEditorWidget->spacing();
}

QList<ModelNode> FormEditorView::adjustStatesForModelNodes(const QList<ModelNode> &nodeList) const
{
    QList<ModelNode> adjustedNodeList;
    foreach (const ModelNode &node, nodeList)
        adjustedNodeList.append(node);

    return adjustedNodeList;
}

QmlItemNode findRecursiveQmlItemNode(const QmlObjectNode &firstQmlObjectNode)
{
    QmlObjectNode qmlObjectNode = firstQmlObjectNode;

    while (true)  {
        QmlItemNode itemNode = qmlObjectNode.toQmlItemNode();
        if (itemNode.isValid())
            return itemNode;
        if (qmlObjectNode.hasInstanceParent())
            qmlObjectNode = qmlObjectNode.instanceParent();
        else
            break;
    }

    return QmlItemNode();
}

551
void FormEditorView::instancePropertyChange(const QList<QPair<ModelNode, PropertyName> > &propertyList)
552
{
553
    typedef QPair<ModelNode, PropertyName> NodePropertyPair;
554 555
    foreach (const NodePropertyPair &nodePropertyPair, propertyList) {
        const QmlItemNode itemNode(nodePropertyPair.first);
556
        const PropertyName propertyName = nodePropertyPair.second;
557
        if (itemNode.isValid() && scene()->hasItemForQmlItemNode(itemNode)) {
558
            static PropertyNameList skipList = PropertyNameList() << "x" << "y" << "width" << "height";
559 560 561 562 563
            if (!skipList.contains(propertyName)) {
                m_scene->synchronizeOtherProperty(itemNode, propertyName);
                m_currentTool->formEditorItemsChanged(QList<FormEditorItem*>() << m_scene->itemForQmlItemNode(itemNode));
            }
        }
564
    }
565 566

    QmlModelView::instancePropertyChange(propertyList);
567 568 569 570 571 572 573
}

void FormEditorView::updateGraphicsIndicators()
{
    m_currentTool->formEditorItemsChanged(scene()->allFormEditorItems());
}

574 575 576 577 578

void FormEditorView::setSelectOnlyContentItemsAction(bool selectOnlyContentItems)
{
    m_selectionTool->setSelectOnlyContentItems(selectOnlyContentItems);
}
579 580 581 582 583 584 585 586

bool FormEditorView::isMoveToolAvailable() const
{
    if (selectedQmlItemNodes().count() == 1)
        return selectedQmlItemNodes().first().instanceIsMovable() &&
               !selectedQmlItemNodes().first().instanceIsInPositioner();
    return true;
}
587

Thomas Hartmann's avatar
Thomas Hartmann committed
588
void FormEditorView::actualStateChanged(const ModelNode &node)
589
{
Thomas Hartmann's avatar
Thomas Hartmann committed
590 591 592
    QmlModelView::actualStateChanged(node);

    QmlModelState newQmlModelState(node);
593 594
}

595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610
void FormEditorView::reset()
{
   QTimer::singleShot(200, this, SLOT(delayedReset()));
}

void FormEditorView::delayedReset()
{
    m_selectionTool->clear();
    m_moveTool->clear();
    m_resizeTool->clear();
    m_dragTool->clear();
    m_scene->clearFormEditorItems();
    if (rootQmlObjectNode().toQmlItemNode().isValid())
        setupFormEditorItemTree(rootQmlObjectNode().toQmlItemNode());
}

611 612 613

}