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