From 58e280de2cd61597fd1ab0e05b2a54afa0d6feb2 Mon Sep 17 00:00:00 2001 From: Thomas Hartmann Date: Thu, 18 Apr 2013 11:56:23 +0200 Subject: [PATCH] QmlDesigner:Instances: Adding instance for QQuickWindow This allows QuickWindowNodeInstance to return the content item instead. The function parentObject() in ObjectNodeInstance now knows QQuickRootItem, because the parent of the root item should is the windows (which is just a QObject but treated as item from us). Change-Id: Ibaa7ccc8dd9346689cc4443ce0b594056feaa0cf Reviewed-by: Marco Bubke Reviewed-by: Thomas Hartmann --- .../qml2puppet/instances/instances.pri | 2 + .../instances/objectnodeinstance.cpp | 8 +- .../instances/quickwindownodeinstance.cpp | 592 ++++++++++++++++++ .../instances/quickwindownodeinstance.h | 140 +++++ .../instances/servernodeinstance.cpp | 3 + 5 files changed, 744 insertions(+), 1 deletion(-) create mode 100644 share/qtcreator/qml/qmlpuppet/qml2puppet/instances/quickwindownodeinstance.cpp create mode 100644 share/qtcreator/qml/qmlpuppet/qml2puppet/instances/quickwindownodeinstance.h diff --git a/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/instances.pri b/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/instances.pri index 28a733cf669..3da4843c07e 100644 --- a/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/instances.pri +++ b/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/instances.pri @@ -21,6 +21,7 @@ HEADERS += $$PWD/qmltransitionnodeinstance.h HEADERS += $$PWD/servernodeinstance.h HEADERS += $$PWD/anchorchangesnodeinstance.h HEADERS += $$PWD/positionernodeinstance.h +HEADERS += $$PWD/quickwindownodeinstance.h SOURCES += $$PWD/qt5nodeinstanceserver.cpp SOURCES += $$PWD/qt5informationnodeinstanceserver.cpp @@ -43,3 +44,4 @@ SOURCES += $$PWD/qmltransitionnodeinstance.cpp SOURCES += $$PWD/servernodeinstance.cpp SOURCES += $$PWD/anchorchangesnodeinstance.cpp SOURCES += $$PWD/positionernodeinstance.cpp +SOURCES += $$PWD/quickwindownodeinstance.cpp diff --git a/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/objectnodeinstance.cpp b/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/objectnodeinstance.cpp index ad5f357635a..71b8544e938 100644 --- a/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/objectnodeinstance.cpp +++ b/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/objectnodeinstance.cpp @@ -1124,8 +1124,14 @@ QObject *ObjectNodeInstance::parent() const QObject *parentObject(QObject *object) { QQuickItem *quickItem = qobject_cast(object); - if (quickItem) + if (quickItem && quickItem->parentItem()) { + + //QQuickRootItem is used by Window and we want to return the Window as parent + if (strcmp(quickItem->metaObject()->className(), "QQuickRootItem")) + return object->parent(); + return quickItem->parentItem(); + } return object->parent(); } diff --git a/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/quickwindownodeinstance.cpp b/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/quickwindownodeinstance.cpp new file mode 100644 index 00000000000..f4f86e0b5b6 --- /dev/null +++ b/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/quickwindownodeinstance.cpp @@ -0,0 +1,592 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of Qt Creator. +** +** 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. +** +** GNU Lesser General Public License Usage +** 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 +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +****************************************************************************/ + +#include "quickwindownodeinstance.h" + +#include "qt5nodeinstanceserver.h" + +#include +#include +#include + +#include + +#include + +#include + +#include + +namespace QmlDesigner { +namespace Internal { + +bool QuickWindowNodeInstance::s_createEffectItem = false; + +QuickWindowNodeInstance::QuickWindowNodeInstance(QQuickWindow *item) + : ObjectNodeInstance(item), + m_hasHeight(false), + m_hasWidth(false), + m_hasContent(true), + m_x(0.0), + m_y(0.0), + m_width(0.0), + m_height(0.0) +{ +} + +QuickWindowNodeInstance::~QuickWindowNodeInstance() +{ + if (quickItem()) + designerSupport()->derefFromEffectItem(quickItem()); +} + +bool QuickWindowNodeInstance::hasContent() const +{ + if (m_hasContent) + return true; + + return childItemsHaveContent(quickItem()); +} + +QList QuickWindowNodeInstance::childItems() const +{ + QList instanceList; + + foreach (QQuickItem *childItem, quickItem()->childItems()) + { + if (childItem && nodeInstanceServer()->hasInstanceForObject(childItem)) { + instanceList.append(nodeInstanceServer()->instanceForObject(childItem)); + } else { //there might be an item in between the parent instance + //and the child instance. + //Popular example is flickable which has a viewport item between + //the flickable item and the flickable children + instanceList.append(childItemsForChild(childItem)); //In such a case we go deeper inside the item and + //search for child items with instances. + } + } + + return instanceList; +} + +QList QuickWindowNodeInstance::childItemsForChild(QQuickItem *childItem) const +{ + QList instanceList; + + if (childItem) { + foreach (QQuickItem *childItem, childItem->childItems()) + { + if (childItem && nodeInstanceServer()->hasInstanceForObject(childItem)) { + instanceList.append(nodeInstanceServer()->instanceForObject(childItem)); + } else { + instanceList.append(childItemsForChild(childItem)); + } + } + } + return instanceList; +} + +void QuickWindowNodeInstance::setHasContent(bool hasContent) +{ + m_hasContent = hasContent; +} + + +bool QuickWindowNodeInstance::anyItemHasContent(QQuickItem *quickItem) +{ + if (quickItem->flags().testFlag(QQuickItem::ItemHasContents)) + return true; + + foreach (QQuickItem *childItem, quickItem->childItems()) { + if (anyItemHasContent(childItem)) + return true; + } + + return false; +} + +bool QuickWindowNodeInstance::childItemsHaveContent(QQuickItem *quickItem) +{ + foreach (QQuickItem *childItem, quickItem->childItems()) { + if (anyItemHasContent(childItem)) + return true; + } + + return false; +} + +QPointF QuickWindowNodeInstance::position() const +{ + return quickItem()->position(); +} + +QTransform QuickWindowNodeInstance::transform() const +{ + return DesignerSupport::parentTransform(quickItem()); +} + +QTransform QuickWindowNodeInstance::customTransform() const +{ + return QTransform(); +} + +QTransform QuickWindowNodeInstance::sceneTransform() const +{ + return DesignerSupport::windowTransform(quickItem()); +} + +double QuickWindowNodeInstance::rotation() const +{ + return quickItem()->rotation(); +} + +double QuickWindowNodeInstance::scale() const +{ + return quickItem()->scale(); +} + +QPointF QuickWindowNodeInstance::transformOriginPoint() const +{ + return quickItem()->transformOriginPoint(); +} + +double QuickWindowNodeInstance::zValue() const +{ + return quickItem()->z(); +} + +double QuickWindowNodeInstance::opacity() const +{ + return quickItem()->opacity(); +} + +QObject *QuickWindowNodeInstance::parent() const +{ + return 0; +} + +bool QuickWindowNodeInstance::equalQuickItem(QQuickItem *item) const +{ + return item == quickItem(); +} + +void QuickWindowNodeInstance::updateDirtyNodeRecursive(QQuickItem *parentItem) const +{ + foreach (QQuickItem *childItem, parentItem->childItems()) { + if (!nodeInstanceServer()->hasInstanceForObject(childItem)) + updateDirtyNodeRecursive(childItem); + } + + DesignerSupport::updateDirtyNode(parentItem); +} + +QImage QuickWindowNodeInstance::renderImage() const +{ + updateDirtyNodeRecursive(quickItem()); + + QRectF boundingRect = boundingRectWithStepChilds(quickItem()); + + QImage renderImage = designerSupport()->renderImageForItem(quickItem(), boundingRect, boundingRect.size().toSize()); + + renderImage = renderImage.convertToFormat(QImage::Format_ARGB32_Premultiplied); + + return renderImage; +} + +QImage QuickWindowNodeInstance::renderPreviewImage(const QSize &previewImageSize) const +{ + QRectF previewItemBoundingRect = boundingRect(); + + if (previewItemBoundingRect.isValid() && quickItem()) + return designerSupport()->renderImageForItem(quickItem(), previewItemBoundingRect, previewImageSize); + + return QImage(); +} + +bool QuickWindowNodeInstance::isMovable() const +{ + return false; +} + +QuickWindowNodeInstance::Pointer QuickWindowNodeInstance::create(QObject *object) +{ + QQuickWindow *quickWindow = qobject_cast(object); + + Q_ASSERT(quickWindow); + + Pointer instance(new QuickWindowNodeInstance(quickWindow)); + + instance->setHasContent(anyItemHasContent(quickWindow->contentItem())); + quickWindow->contentItem()->setFlag(QQuickItem::ItemHasContents, true); + + static_cast(quickWindow->contentItem())->classBegin(); + + instance->populateResetHashes(); + + QQuickItemPrivate *privateItem = static_cast(QObjectPrivate::get(quickWindow->contentItem())); + + if (privateItem->window) { + qDebug() << "removing from window"; + if (!privateItem->parentItem) + QQuickWindowPrivate::get(privateItem->window)->parentlessItems.remove(quickWindow->contentItem()); + privateItem->derefWindow(); + privateItem->window = 0; + } + + return instance; +} + +void QuickWindowNodeInstance::initialize(const ObjectNodeInstance::Pointer &objectNodeInstance) +{ + if (instanceId() == 0) { + DesignerSupport::setRootItem(nodeInstanceServer()->quickView(), quickItem()); + } else { + quickItem()->setParentItem(qobject_cast(nodeInstanceServer()->quickView()->rootObject())); + } + + if (s_createEffectItem || instanceId() == 0) + designerSupport()->refFromEffectItem(quickItem()); + + ObjectNodeInstance::initialize(objectNodeInstance); + quickItem()->update(); +} + +bool QuickWindowNodeInstance::isQuickItem() const +{ + return true; +} + +QSizeF QuickWindowNodeInstance::size() const +{ + double width; + + if (DesignerSupport::isValidWidth(quickItem())) { + width = quickItem()->width(); + } else { + width = quickItem()->implicitWidth(); + } + + double height; + + if (DesignerSupport::isValidHeight(quickItem())) { + height = quickItem()->height(); + } else { + height = quickItem()->implicitHeight(); + } + + + return QSizeF(width, height); +} + +static inline bool isRectangleSane(const QRectF &rect) +{ + return rect.isValid() && (rect.width() < 10000) && (rect.height() < 10000); +} + +QRectF QuickWindowNodeInstance::boundingRectWithStepChilds(QQuickItem *parentItem) const +{ + QRectF boundingRect = parentItem->boundingRect(); + + foreach (QQuickItem *childItem, parentItem->childItems()) { + if (!nodeInstanceServer()->hasInstanceForObject(childItem)) { + QRectF transformedRect = childItem->mapRectToItem(parentItem, boundingRectWithStepChilds(childItem)); + if (isRectangleSane(transformedRect)) + boundingRect = boundingRect.united(transformedRect); + } + } + + return boundingRect; +} + +QRectF QuickWindowNodeInstance::boundingRect() const +{ + if (quickItem()) { + if (quickItem()->clip()) { + return quickItem()->boundingRect(); + } else { + return boundingRectWithStepChilds(quickItem()); + } + } + + return QRectF(); +} + +void QuickWindowNodeInstance::setPropertyVariant(const PropertyName &name, const QVariant &value) +{ + if (name == "state") + return; // states are only set by us + + if (name == "height") { + m_height = value.toDouble(); + if (value.isValid()) + m_hasHeight = true; + else + m_hasHeight = false; + } + + if (name == "width") { + m_width = value.toDouble(); + if (value.isValid()) + m_hasWidth = true; + else + m_hasWidth = false; + } + + if (name == "x") + m_x = value.toDouble(); + + if (name == "y") + m_y = value.toDouble(); + + ObjectNodeInstance::setPropertyVariant(name, value); + + quickItem()->update(); +} + +void QuickWindowNodeInstance::setPropertyBinding(const PropertyName &name, const QString &expression) +{ + if (name == "state") + return; // states are only set by us + + ObjectNodeInstance::setPropertyBinding(name, expression); + + quickItem()->update(); +} + +QVariant QuickWindowNodeInstance::property(const PropertyName &name) const +{ + if (name == "visible") + return quickItem()->isVisible(); + return ObjectNodeInstance::property(name); +} + +void QuickWindowNodeInstance::resetHorizontal() + { + setPropertyVariant("x", m_x); + if (m_width > 0.0) { + setPropertyVariant("width", m_width); + } else { + setPropertyVariant("width", quickItem()->implicitWidth()); + } +} + +void QuickWindowNodeInstance::resetVertical() + { + setPropertyVariant("y", m_y); + if (m_height > 0.0) { + setPropertyVariant("height", m_height); + } else { + setPropertyVariant("height", quickItem()->implicitWidth()); + } +} + +static void doComponentCompleteRecursive(QQuickItem *item) +{ + if (item) { + if (DesignerSupport::isComponentComplete(item)) + return; + + foreach (QQuickItem *childItem, item->childItems()) + doComponentCompleteRecursive(childItem); + + static_cast(item)->componentComplete(); + } +} + +void QuickWindowNodeInstance::doComponentComplete() +{ + doComponentCompleteRecursive(quickItem()); + + quickItem()->update(); +} + +bool QuickWindowNodeInstance::isResizable() const +{ + return false; +} + +int QuickWindowNodeInstance::penWidth() const +{ + return DesignerSupport::borderWidth(quickItem()); +} + +void QuickWindowNodeInstance::resetProperty(const PropertyName &name) +{ + if (name == "height") { + m_hasHeight = false; + m_height = 0.0; + } + + if (name == "width") { + m_hasWidth = false; + m_width = 0.0; + } + + if (name == "x") + m_x = 0.0; + + if (name == "y") + m_y = 0.0; + + DesignerSupport::resetAnchor(quickItem(), name); + + if (name == "anchors.fill") { + resetHorizontal(); + resetVertical(); + } else if (name == "anchors.centerIn") { + resetHorizontal(); + resetVertical(); + } else if (name == "anchors.top") { + resetVertical(); + } else if (name == "anchors.left") { + resetHorizontal(); + } else if (name == "anchors.right") { + resetHorizontal(); + } else if (name == "anchors.bottom") { + resetVertical(); + } else if (name == "anchors.horizontalCenter") { + resetHorizontal(); + } else if (name == "anchors.verticalCenter") { + resetVertical(); + } else if (name == "anchors.baseline") { + resetVertical(); + } + + ObjectNodeInstance::resetProperty(name); + + quickItem()->update(); + + if (isInPositioner()) + parentInstance()->refreshPositioner(); +} + +void QuickWindowNodeInstance::reparent(const ObjectNodeInstance::Pointer &oldParentInstance, const PropertyName &oldParentProperty, const ObjectNodeInstance::Pointer &newParentInstance, const PropertyName &newParentProperty) +{ + ObjectNodeInstance::reparent(oldParentInstance, oldParentProperty, newParentInstance, newParentProperty); + + DesignerSupport::updateDirtyNode(quickItem()); +} + +static bool isValidAnchorName(const PropertyName &name) +{ + static PropertyNameList anchorNameList(PropertyNameList() << "anchors.top" + << "anchors.left" + << "anchors.right" + << "anchors.bottom" + << "anchors.verticalCenter" + << "anchors.horizontalCenter" + << "anchors.fill" + << "anchors.centerIn" + << "anchors.baseline"); + + return anchorNameList.contains(name); +} + +bool QuickWindowNodeInstance::hasAnchor(const PropertyName &name) const +{ + return DesignerSupport::hasAnchor(quickItem(), name); +} + +QPair QuickWindowNodeInstance::anchor(const PropertyName &name) const +{ + if (!isValidAnchorName(name) || !DesignerSupport::hasAnchor(quickItem(), name)) + return ObjectNodeInstance::anchor(name); + + QPair nameObjectPair = DesignerSupport::anchorLineTarget(quickItem(), name, context()); + + QObject *targetObject = nameObjectPair.second; + PropertyName targetName = nameObjectPair.first.toUtf8(); + + if (targetObject && nodeInstanceServer()->hasInstanceForObject(targetObject)) { + return qMakePair(targetName, nodeInstanceServer()->instanceForObject(targetObject)); + } else { + return ObjectNodeInstance::anchor(name); + } +} + +QList QuickWindowNodeInstance::stateInstances() const +{ + QList instanceList; + QList stateList = DesignerSupport::statesForItem(quickItem()); + foreach (QObject *state, stateList) + { + if (state && nodeInstanceServer()->hasInstanceForObject(state)) + instanceList.append(nodeInstanceServer()->instanceForObject(state)); + } + + return instanceList; +} + +bool QuickWindowNodeInstance::isAnchoredBySibling() const +{ + return false; +} + +bool QuickWindowNodeInstance::isAnchoredByChildren() const +{ + if (DesignerSupport::areChildrenAnchoredTo(quickItem(), quickItem())) // search in children for a anchor to this item + return true; + + return false; +} + +QQuickItem *QuickWindowNodeInstance::quickItem() const +{ + if (object() == 0) + return 0; + + Q_ASSERT(qobject_cast(object())); + return static_cast(object())->contentItem(); +} + +DesignerSupport *QuickWindowNodeInstance::designerSupport() const +{ + return qt5NodeInstanceServer()->designerSupport(); +} + +Qt5NodeInstanceServer *QuickWindowNodeInstance::qt5NodeInstanceServer() const +{ + return qobject_cast(nodeInstanceServer()); +} + +void QuickWindowNodeInstance::createEffectItem(bool createEffectItem) +{ + s_createEffectItem = createEffectItem; +} + +void QuickWindowNodeInstance::updateDirtyNodeRecursive() +{ + foreach (QQuickItem *childItem, quickItem()->childItems()) + updateDirtyNodeRecursive(childItem); + + DesignerSupport::updateDirtyNode(quickItem()); +} + +} // namespace Internal +} // namespace QmlDesigner + diff --git a/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/quickwindownodeinstance.h b/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/quickwindownodeinstance.h new file mode 100644 index 00000000000..31d2a1fdfa9 --- /dev/null +++ b/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/quickwindownodeinstance.h @@ -0,0 +1,140 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of Qt Creator. +** +** 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. +** +** GNU Lesser General Public License Usage +** 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 +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +****************************************************************************/ + +#ifndef QUICKWINDOWNODEINSTANCE_H +#define QUICKWINDOWNODEINSTANCE_H + +#include + +#include "objectnodeinstance.h" + +#include +#include + +namespace QmlDesigner { +namespace Internal { + +class QuickWindowNodeInstance : public ObjectNodeInstance +{ +public: + typedef QSharedPointer Pointer; + typedef QWeakPointer WeakPointer; + + ~QuickWindowNodeInstance(); + + static Pointer create(QObject *objectToBeWrapped); + void initialize(const ObjectNodeInstance::Pointer &objectNodeInstance); + + bool isQuickItem() const Q_DECL_OVERRIDE; + + QRectF boundingRect() const Q_DECL_OVERRIDE; + QPointF position() const Q_DECL_OVERRIDE; + QSizeF size() const Q_DECL_OVERRIDE; + QTransform transform() const Q_DECL_OVERRIDE; + QTransform customTransform() const Q_DECL_OVERRIDE; + QTransform sceneTransform() const Q_DECL_OVERRIDE; + double opacity() const Q_DECL_OVERRIDE; + + QObject *parent() const Q_DECL_OVERRIDE; + + double rotation() const Q_DECL_OVERRIDE; + double scale() const Q_DECL_OVERRIDE; + QPointF transformOriginPoint() const Q_DECL_OVERRIDE; + double zValue() const Q_DECL_OVERRIDE; + + bool equalQuickItem(QQuickItem *item) const; + + bool hasContent() const Q_DECL_OVERRIDE; + + QList childItems() const Q_DECL_OVERRIDE; + QList childItemsForChild(QQuickItem *childItem) const Q_DECL_OVERRIDE; + + bool isMovable() const Q_DECL_OVERRIDE; + + void setPropertyVariant(const PropertyName &name, const QVariant &value) Q_DECL_OVERRIDE; + void setPropertyBinding(const PropertyName &name, const QString &expression) Q_DECL_OVERRIDE; + + QVariant property(const PropertyName &name) const Q_DECL_OVERRIDE; + void resetProperty(const PropertyName &name) Q_DECL_OVERRIDE; + + void reparent(const ObjectNodeInstance::Pointer &oldParentInstance, + const PropertyName &oldParentProperty, + const ObjectNodeInstance::Pointer &newParentInstance, + const PropertyName &newParentProperty) Q_DECL_OVERRIDE; + + int penWidth() const Q_DECL_OVERRIDE; + + bool hasAnchor(const PropertyName &name) const Q_DECL_OVERRIDE; + QPair anchor(const PropertyName &name) const Q_DECL_OVERRIDE; + bool isAnchoredBySibling() const Q_DECL_OVERRIDE; + bool isAnchoredByChildren() const Q_DECL_OVERRIDE; + void doComponentComplete() Q_DECL_OVERRIDE; + + bool isResizable() const Q_DECL_OVERRIDE; + + void setHasContent(bool hasContent); + + QList stateInstances() const Q_DECL_OVERRIDE; + + QImage renderImage() const Q_DECL_OVERRIDE; + QImage renderPreviewImage(const QSize &previewImageSize) const Q_DECL_OVERRIDE; + + DesignerSupport *designerSupport() const; + Qt5NodeInstanceServer *qt5NodeInstanceServer() const; + + static void createEffectItem(bool createEffectItem); + + void updateDirtyNodeRecursive() Q_DECL_OVERRIDE; + +protected: + QuickWindowNodeInstance(QQuickWindow*); + QQuickItem *quickItem() const; + void resetHorizontal(); + void resetVertical(); + QRectF boundingRectWithStepChilds(QQuickItem *parentItem) const; + void updateDirtyNodeRecursive(QQuickItem *parentItem) const; + static bool anyItemHasContent(QQuickItem *graphicsItem); + static bool childItemsHaveContent(QQuickItem *graphicsItem); + +private: //variables + bool m_hasHeight; + bool m_hasWidth; + bool m_hasContent; + double m_x; + double m_y; + double m_width; + double m_height; + static bool s_createEffectItem; +}; + +} // namespace Internal +} // namespace QmlDesigner + +#endif // QUICKWINDOWNODEINSTANCE_H + diff --git a/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/servernodeinstance.cpp b/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/servernodeinstance.cpp index b4bbf5cfc28..4bddcf1a8cb 100644 --- a/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/servernodeinstance.cpp +++ b/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/servernodeinstance.cpp @@ -40,6 +40,7 @@ #include "debugoutputcommand.h" #include "quickitemnodeinstance.h" +#include "quickwindownodeinstance.h" #include "nodeinstanceserver.h" #include "instancecontainer.h" @@ -194,6 +195,8 @@ Internal::ObjectNodeInstance::Pointer ServerNodeInstance::createInstance(QObject instance = Internal::QmlTransitionNodeInstance::create(objectToBeWrapped); else if (isSubclassOf(objectToBeWrapped, "QQuickBehavior")) instance = Internal::BehaviorNodeInstance::create(objectToBeWrapped); + else if (isSubclassOf(objectToBeWrapped, "QQuickWindow")) + instance = Internal::QuickWindowNodeInstance::create(objectToBeWrapped); else if (isSubclassOf(objectToBeWrapped, "QObject")) instance = Internal::ObjectNodeInstance::create(objectToBeWrapped); else