feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

QmlDesigner: Add navigator tooltip for 2D components

Browse Source 
This enables showing preview tooltip for 2D (Item based) components.

We render the component from scratch for this purpose instead of using
existing renders done for form editor to ensure preview doesn't
include any local changes to component.

Also cache tooltips as QPixmaps in NodeInstanceView instead of QImages
to avoid unnecessary image to pixmap conversions when using cached
data.

Change-Id: I3082c5c846f605a765a81408767266d1ff7a12d7
Fixes: QDS-2762
Reviewed-by: Thomas Hartmann <thomas.hartmann@qt.io>
Reviewed-by: Mahmoud Badri <mahmoud.badri@qt.io>
This commit is contained in:
Miikka Heikkinen
2020-09-24 10:56:02 +03:00
parent 47955ed4fa
commit 36a8b8ad99
20 changed files with 262 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
share/qtcreator/qml/qmlpuppet/mockfiles/ModelNode2DImageView.qml Normal file
View File

@@ -0,0 +1,39 @@
/****************************************************************************
**
** Copyright (C) 2020 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** 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 The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/
import QtQuick 2.15
Item {
id: root
width: 150
height: 150
property alias contentItem: contentItem
Item {
id: contentItem
anchors.fill: parent
}
}

224
share/qtcreator/qml/qmlpuppet/qml2puppet/instances/qt5informationnodeinstanceserver.cpp
View File

@@ -101,6 +101,26 @@ static QVariant objectToVariant(QObject *object)
return QVariant::fromValue(object);
}
QQuickView *Qt5InformationNodeInstanceServer::createAuxiliaryQuickView(const QUrl &url,
QQuickItem *&rootItem)
{
auto view = new QQuickView(quickView()->engine(), quickView());
view->setFormat(quickView()->format());
DesignerSupport::createOpenGLContext(view);
QQmlComponent component(engine());
component.loadUrl(url);
rootItem = qobject_cast<QQuickItem *>(component.create());
if (!rootItem) {
qWarning() << "Could not create view for: " << url.toString() << component.errors();
return nullptr;
}
DesignerSupport::setRootItem(view, rootItem);
return view;
}
void Qt5InformationNodeInstanceServer::createEditView3D()
{
#ifdef QUICK3D_MODULE
@@ -120,58 +140,26 @@ void Qt5InformationNodeInstanceServer::createEditView3D()
new QmlDesigner::Internal::IconGizmoImageProvider);
m_3dHelper = helper;
m_editView3D = new QQuickView(quickView()->engine(), quickView());
m_editView3D->setFormat(quickView()->format());
DesignerSupport::createOpenGLContext(m_editView3D.data());
QQmlComponent component(engine());
component.loadUrl(QUrl("qrc:/qtquickplugin/mockfiles/EditView3D.qml"));
m_editView3DRootItem = qobject_cast<QQuickItem *>(component.create());
m_editView3D = createAuxiliaryQuickView(QUrl("qrc:/qtquickplugin/mockfiles/EditView3D.qml"), m_editView3DRootItem);
if (!m_editView3DRootItem) {
qWarning() << "Could not create edit view 3D: " << component.errors();
return;
if (m_editView3DRootItem) {
QObject::connect(m_editView3DRootItem, SIGNAL(selectionChanged(QVariant)),
this, SLOT(handleSelectionChanged(QVariant)));
QObject::connect(m_editView3DRootItem, SIGNAL(commitObjectProperty(QVariant, QVariant)),
this, SLOT(handleObjectPropertyCommit(QVariant, QVariant)));
QObject::connect(m_editView3DRootItem, SIGNAL(changeObjectProperty(QVariant, QVariant)),
this, SLOT(handleObjectPropertyChange(QVariant, QVariant)));
QObject::connect(m_editView3DRootItem, SIGNAL(notifyActiveSceneChange()),
this, SLOT(handleActiveSceneChange()));
QObject::connect(&m_propertyChangeTimer, &QTimer::timeout,
this, &Qt5InformationNodeInstanceServer::handleObjectPropertyChangeTimeout);
QObject::connect(&m_selectionChangeTimer, &QTimer::timeout,
this, &Qt5InformationNodeInstanceServer::handleSelectionChangeTimeout);
QObject::connect(&m_render3DEditViewTimer, &QTimer::timeout,
this, &Qt5InformationNodeInstanceServer::doRender3DEditView);
helper->setParent(m_editView3DRootItem);
}
DesignerSupport::setRootItem(m_editView3D, m_editView3DRootItem);
QObject::connect(m_editView3DRootItem, SIGNAL(selectionChanged(QVariant)),
this, SLOT(handleSelectionChanged(QVariant)));
QObject::connect(m_editView3DRootItem, SIGNAL(commitObjectProperty(QVariant, QVariant)),
this, SLOT(handleObjectPropertyCommit(QVariant, QVariant)));
QObject::connect(m_editView3DRootItem, SIGNAL(changeObjectProperty(QVariant, QVariant)),
this, SLOT(handleObjectPropertyChange(QVariant, QVariant)));
QObject::connect(m_editView3DRootItem, SIGNAL(notifyActiveSceneChange()),
this, SLOT(handleActiveSceneChange()));
QObject::connect(&m_propertyChangeTimer, &QTimer::timeout,
this, &Qt5InformationNodeInstanceServer::handleObjectPropertyChangeTimeout);
QObject::connect(&m_selectionChangeTimer, &QTimer::timeout,
this, &Qt5InformationNodeInstanceServer::handleSelectionChangeTimeout);
QObject::connect(&m_render3DEditViewTimer, &QTimer::timeout,
this, &Qt5InformationNodeInstanceServer::doRender3DEditView);
QObject::connect(&m_renderModelNode3DImageViewTimer, &QTimer::timeout,
this, &Qt5InformationNodeInstanceServer::doRenderModelNode3DImageView);
helper->setParent(m_editView3DRootItem);
#endif
}
void Qt5InformationNodeInstanceServer::create3DPreviewView()
{
#ifdef QUICK3D_MODULE
// This function assumes createEditView3D() has been called previously
m_ModelNode3DImageView = new QQuickView(quickView()->engine(), quickView());
m_ModelNode3DImageView->setFormat(quickView()->format());
DesignerSupport::createOpenGLContext(m_ModelNode3DImageView.data());
QQmlComponent component(engine());
component.loadUrl(QUrl("qrc:/qtquickplugin/mockfiles/ModelNode3DImageView.qml"));
m_ModelNode3DImageViewRootItem = qobject_cast<QQuickItem *>(component.create());
if (!m_ModelNode3DImageViewRootItem) {
qWarning() << "Could not create ModelNode preview image 3D view: " << component.errors();
return;
}
DesignerSupport::setRootItem(m_ModelNode3DImageView, m_ModelNode3DImageViewRootItem);
#endif
}
@@ -521,10 +509,20 @@ void Qt5InformationNodeInstanceServer::doRender3DEditView()
}
}
void Qt5InformationNodeInstanceServer::renderModelNode3DImageView()
void Qt5InformationNodeInstanceServer::renderModelNodeImageView()
{
if (!m_renderModelNode3DImageViewTimer.isActive())
m_renderModelNode3DImageViewTimer.start(0);
if (!m_renderModelNodeImageViewTimer.isActive())
m_renderModelNodeImageViewTimer.start(0);
}
void Qt5InformationNodeInstanceServer::doRenderModelNodeImageView()
{
ServerNodeInstance instance = instanceForId(m_modelNodePreviewImageCommand.instanceId());
if (instance.isSubclassOf("QQuick3DObject"))
doRenderModelNode3DImageView();
else if (instance.isSubclassOf("QQuickItem"))
doRenderModelNode2DImageView();
}
void Qt5InformationNodeInstanceServer::doRenderModelNode3DImageView()
@@ -542,13 +540,11 @@ void Qt5InformationNodeInstanceServer::doRenderModelNode3DImageView()
} else {
QObject *instanceObj = nullptr;
if (!m_modelNodePreviewImageCommand.componentPath().isEmpty()) {
QQmlComponent *component = new QQmlComponent(engine());
component->loadUrl(QUrl::fromLocalFile(m_modelNodePreviewImageCommand.componentPath()));
instanceObj = qobject_cast<QQuick3DObject *>(component->create());
QQmlComponent component(engine());
component.loadUrl(QUrl::fromLocalFile(m_modelNodePreviewImageCommand.componentPath()));
instanceObj = qobject_cast<QQuick3DObject *>(component.create());
if (!instanceObj) {
qWarning() << "Could not create preview component: " << component->errors();
nodeInstanceClient()->handlePuppetToCreatorCommand({PuppetToCreatorCommand::RenderModelNodePreviewImage,
QVariant::fromValue(imgContainer)});
qWarning() << "Could not create preview component: " << component.errors();
return;
}
} else {
@@ -584,18 +580,105 @@ void Qt5InformationNodeInstanceServer::doRenderModelNode3DImageView()
if (!m_modelNodePreviewImageCommand.componentPath().isEmpty()) {
// If component changes, puppet will need a reset anyway, so we can cache the image
m_modelNodePreviewImageCache.insert(m_modelNodePreviewImageCommand.componentPath(), renderImage);
delete instanceObj;
}
}
imgContainer.setImage(renderImage);
if (!renderImage.isNull()) {
imgContainer.setImage(renderImage);
// send the rendered image to creator process
nodeInstanceClient()->handlePuppetToCreatorCommand({PuppetToCreatorCommand::RenderModelNodePreviewImage,
QVariant::fromValue(imgContainer)});
// send the rendered image to creator process
nodeInstanceClient()->handlePuppetToCreatorCommand({PuppetToCreatorCommand::RenderModelNodePreviewImage,
QVariant::fromValue(imgContainer)});
}
}
#endif
}
static QRectF itemBoundingRect(QQuickItem *item)
{
QRectF itemRect;
if (item) {
itemRect = item->boundingRect();
if (item->clip()) {
return itemRect;
} else {
const auto childItems = item->childItems();
for (const auto &childItem : childItems) {
QRectF mappedRect = childItem->mapRectToItem(item, itemBoundingRect(childItem));
// Sanity check for size
if (mappedRect.isValid() && (mappedRect.width() < 10000) && (mappedRect.height() < 10000))
itemRect = itemRect.united(mappedRect);
}
}
}
return itemRect;
}
void Qt5InformationNodeInstanceServer::doRenderModelNode2DImageView()
{
if (m_ModelNode2DImageViewRootItem) {
if (!m_ModelNode2DImageViewContentItem)
m_ModelNode2DImageViewContentItem = getContentItemForRendering(m_ModelNode2DImageViewRootItem);
// Key number is the same as in 3D case as they produce image for same purpose
auto imgContainer = ImageContainer(m_modelNodePreviewImageCommand.instanceId(), {}, 2100000001);
QImage renderImage;
if (m_modelNodePreviewImageCache.contains(m_modelNodePreviewImageCommand.componentPath())) {
renderImage = m_modelNodePreviewImageCache[m_modelNodePreviewImageCommand.componentPath()];
} else {
QQuickItem *instanceItem = nullptr;
if (!m_modelNodePreviewImageCommand.componentPath().isEmpty()) {
QQmlComponent component(engine());
component.loadUrl(QUrl::fromLocalFile(m_modelNodePreviewImageCommand.componentPath()));
instanceItem = qobject_cast<QQuickItem *>(component.create());
if (!instanceItem) {
qWarning() << "Could not create preview component: " << component.errors();
return;
}
} else {
qWarning() << "2D image preview is not supported for non-components.";
return;
}
instanceItem->setParentItem(m_ModelNode2DImageViewContentItem);
// Some component may expect to always be shown at certain size, so their layouts may
// not support scaling, so let's always render at the default size if item has one and
// scale the resulting image instead.
QSize finalSize = m_modelNodePreviewImageCommand.size() * 2;
QRectF renderRect = itemBoundingRect(instanceItem);
QSize renderSize = renderRect.size().toSize();
if (renderSize.isEmpty()) {
renderSize = finalSize;
renderRect = QRectF(QPointF(0., 0.), QSizeF(renderSize));
instanceItem->setSize(renderSize);
}
updateNodesRecursive(m_ModelNode2DImageViewContentItem);
renderImage = designerSupport()->renderImageForItem(m_ModelNode2DImageViewContentItem, renderRect, renderSize);
if (renderSize != finalSize)
renderImage = renderImage.scaled(finalSize, Qt::KeepAspectRatio);
delete instanceItem;
// If component changes, puppet will need a reset anyway, so we can cache the image
m_modelNodePreviewImageCache.insert(m_modelNodePreviewImageCommand.componentPath(), renderImage);
}
if (!renderImage.isNull()) {
imgContainer.setImage(renderImage);
// send the rendered image to creator process
nodeInstanceClient()->handlePuppetToCreatorCommand({PuppetToCreatorCommand::RenderModelNodePreviewImage,
QVariant::fromValue(imgContainer)});
}
}
}
Qt5InformationNodeInstanceServer::Qt5InformationNodeInstanceServer(NodeInstanceClientInterface *nodeInstanceClient) :
Qt5NodeInstanceServer(nodeInstanceClient)
{
@@ -603,7 +686,7 @@ Qt5InformationNodeInstanceServer::Qt5InformationNodeInstanceServer(NodeInstanceC
m_propertyChangeTimer.setSingleShot(true);
m_selectionChangeTimer.setSingleShot(true);
m_render3DEditViewTimer.setSingleShot(true);
m_renderModelNode3DImageViewTimer.setSingleShot(true);
m_renderModelNodeImageViewTimer.setSingleShot(true);
}
void Qt5InformationNodeInstanceServer::sendTokenBack()
@@ -919,7 +1002,8 @@ void Qt5InformationNodeInstanceServer::setup3DEditView(const QList<ServerNodeIns
add3DScenes(instanceList);
createEditView3D();
create3DPreviewView();
m_ModelNode3DImageView = createAuxiliaryQuickView(QUrl("qrc:/qtquickplugin/mockfiles/ModelNode3DImageView.qml"),
m_ModelNode3DImageViewRootItem);
QString lastSceneId;
auto helper = qobject_cast<QmlDesigner::Internal::GeneralHelper *>(m_3dHelper);
@@ -1095,6 +1179,11 @@ void Qt5InformationNodeInstanceServer::createScene(const CreateSceneCommand &com
if (qEnvironmentVariableIsSet("QMLDESIGNER_QUICK3D_MODE"))
setup3DEditView(instanceList, command.edit3dToolStates());
m_ModelNode2DImageView = createAuxiliaryQuickView(QUrl("qrc:/qtquickplugin/mockfiles/ModelNode2DImageView.qml"),
m_ModelNode2DImageViewRootItem);
QObject::connect(&m_renderModelNodeImageViewTimer, &QTimer::timeout,
this, &Qt5InformationNodeInstanceServer::doRenderModelNodeImageView);
}
void Qt5InformationNodeInstanceServer::sendChildrenChangedCommand(const QList<ServerNodeInstance> &childList)
@@ -1345,10 +1434,7 @@ void Qt5InformationNodeInstanceServer::view3DAction(const View3DActionCommand &c
void Qt5InformationNodeInstanceServer::requestModelNodePreviewImage(const RequestModelNodePreviewImageCommand &command)
{
m_modelNodePreviewImageCommand = command;
ServerNodeInstance instance = instanceForId(m_modelNodePreviewImageCommand.instanceId());
if (instance.isSubclassOf("QQuick3DObject"))
renderModelNode3DImageView();
renderModelNodeImageView();
}
void Qt5InformationNodeInstanceServer::changeAuxiliaryValues(const ChangeAuxiliaryCommand &command)

11
share/qtcreator/qml/qmlpuppet/qml2puppet/instances/qt5informationnodeinstanceserver.h
View File

@@ -35,6 +35,7 @@
#include <QVariant>
#include <QPointer>
#include <QImage>
#include <QUrl>
QT_BEGIN_NAMESPACE
class QDragMoveEvent;
@@ -119,8 +120,11 @@ private:
QQuickItem *getContentItemForRendering(QQuickItem *rootItem);
void render3DEditView(int count = 1);
void doRender3DEditView();
void renderModelNode3DImageView();
void renderModelNodeImageView();
void doRenderModelNodeImageView();
void doRenderModelNode3DImageView();
void doRenderModelNode2DImageView();
QQuickView *createAuxiliaryQuickView(const QUrl &url, QQuickItem *&rootItem);
QPointer<QQuickView> m_editView3D;
QQuickItem *m_editView3DRootItem = nullptr;
@@ -128,6 +132,9 @@ private:
QPointer<QQuickView> m_ModelNode3DImageView;
QQuickItem *m_ModelNode3DImageViewRootItem = nullptr;
QQuickItem *m_ModelNode3DImageViewContentItem = nullptr;
QPointer<QQuickView> m_ModelNode2DImageView;
QQuickItem *m_ModelNode2DImageViewRootItem = nullptr;
QQuickItem *m_ModelNode2DImageViewContentItem = nullptr;
RequestModelNodePreviewImageCommand m_modelNodePreviewImageCommand;
QHash<QString, QImage> m_modelNodePreviewImageCache;
QSet<QObject *> m_view3Ds;
@@ -141,7 +148,7 @@ private:
QTimer m_propertyChangeTimer;
QTimer m_selectionChangeTimer;
QTimer m_render3DEditViewTimer;
QTimer m_renderModelNode3DImageViewTimer;
QTimer m_renderModelNodeImageViewTimer;
QVariant m_changedNode;
PropertyName m_changedProperty;
ChangeSelectionCommand m_lastSelectionChangeCommand;

1
share/qtcreator/qml/qmlpuppet/qmlpuppet.qrc
View File

@@ -41,6 +41,7 @@
<file>mockfiles/AxisHelperArm.qml</file>
<file>mockfiles/Line3D.qml</file>
<file>mockfiles/ModelNode3DImageView.qml</file>
<file>mockfiles/ModelNode2DImageView.qml</file>
<file>mockfiles/MaterialNodeView.qml</file>
<file>mockfiles/EffectNodeView.qml</file>
<file>mockfiles/ModelNodeView.qml</file>

10
src/plugins/qmldesigner/components/componentcore/designeractionmanager.cpp
View File

@@ -1402,13 +1402,17 @@ void DesignerActionManager::createDefaultModelNodePreviewImageHandlers()
ModelNodeOperations::previewImageDataForImageNode));
registerModelNodePreviewHandler(
ModelNodePreviewImageHandler("QtQuick3D.Material",
ModelNodeOperations::previewImageDataFor3DNode));
ModelNodeOperations::previewImageDataForGenericNode));
registerModelNodePreviewHandler(
ModelNodePreviewImageHandler("QtQuick3D.Model",
ModelNodeOperations::previewImageDataFor3DNode));
ModelNodeOperations::previewImageDataForGenericNode));
registerModelNodePreviewHandler(
ModelNodePreviewImageHandler("QtQuick3D.Node",
ModelNodeOperations::previewImageDataFor3DNode,
ModelNodeOperations::previewImageDataForGenericNode,
true));
registerModelNodePreviewHandler(
ModelNodePreviewImageHandler("QtQuick.Item",
ModelNodeOperations::previewImageDataForGenericNode,
true));
// TODO - Disabled until QTBUG-86616 is fixed

4
src/plugins/qmldesigner/components/componentcore/modelnodeoperations.cpp
View File

@@ -1519,10 +1519,10 @@ void removeGroup(const SelectionContext &selectionContext)
});
}
QVariant previewImageDataFor3DNode(const ModelNode &modelNode)
QVariant previewImageDataForGenericNode(const ModelNode &modelNode)
{
if (modelNode.isValid())
return modelNode.model()->nodeInstanceView()->previewImageDataFor3DNode(modelNode);
return modelNode.model()->nodeInstanceView()->previewImageDataForGenericNode(modelNode);
return {};
}

2
src/plugins/qmldesigner/components/componentcore/modelnodeoperations.h
View File

@@ -85,7 +85,7 @@ void mergeWithTemplate(const SelectionContext &selectionContext);
void removeGroup(const SelectionContext &selectionContext);
// ModelNodePreviewImageOperations
QVariant previewImageDataFor3DNode(const ModelNode &modelNode);
QVariant previewImageDataForGenericNode(const ModelNode &modelNode);
QVariant previewImageDataForImageNode(const ModelNode &modelNode);
} // namespace ModelNodeOperationso

5
src/plugins/qmldesigner/components/navigator/navigatortreemodel.cpp
View File

@@ -54,6 +54,7 @@
#include <QPointF>
#include <QDir>
#include <QFileInfo>
#include <QPixmap>
#include <coreplugin/messagebox.h>
@@ -857,9 +858,9 @@ void NavigatorTreeModel::resetModel()
endResetModel();
}
void NavigatorTreeModel::updateToolTipImage(const ModelNode &node, const QImage &image)
void NavigatorTreeModel::updateToolTipPixmap(const ModelNode &node, const QPixmap &pixmap)
{
emit toolTipImageUpdated(node.id(), image);
emit toolTipPixmapUpdated(node.id(), pixmap);
}
} // QmlDesigner

6
src/plugins/qmldesigner/components/navigator/navigatortreemodel.h
View File

@@ -34,6 +34,8 @@
#include <QPointer>
#include <QDateTime>
QT_FORWARD_DECLARE_CLASS(QPixmap)
namespace QmlDesigner {
class Model;
@@ -94,10 +96,10 @@ public:
void setOrder(bool reverseItemOrder) override;
void resetModel() override;
void updateToolTipImage(const ModelNode &node, const QImage &image);
void updateToolTipPixmap(const ModelNode &node, const QPixmap &pixmap);
signals:
void toolTipImageUpdated(const QString &id, const QImage &image) const;
void toolTipPixmapUpdated(const QString &id, const QPixmap &pixmap) const;
private:
void moveNodesInteractive(NodeAbstractProperty &parentProperty, const QList<ModelNode> &modelNodes,

8
src/plugins/qmldesigner/components/navigator/navigatortreeview.cpp
View File

@@ -196,16 +196,16 @@ bool NavigatorTreeView::viewportEvent(QEvent *event)
m_toolTipHideTimer.stop();
if (!m_previewToolTip) {
m_previewToolTip = new PreviewToolTip(QApplication::activeWindow());
connect(navModel, &NavigatorTreeModel::toolTipImageUpdated,
[this](const QString &id, const QImage &image) {
connect(navModel, &NavigatorTreeModel::toolTipPixmapUpdated,
[this](const QString &id, const QPixmap &pixmap) {
if (m_previewToolTip && m_previewToolTip->id() == id)
m_previewToolTip->setImage(image);
m_previewToolTip->setPixmap(pixmap);
});
}
m_previewToolTip->setId(imgMap["id"].toString());
m_previewToolTip->setType(imgMap["type"].toString());
m_previewToolTip->setInfo(imgMap["info"].toString());
m_previewToolTip->setImage(imgMap["image"].value<QImage>());
m_previewToolTip->setPixmap(imgMap["pixmap"].value<QPixmap>());
m_previewToolTip->move(m_previewToolTip->parentWidget()->mapFromGlobal(helpEvent->globalPos())
+ QPoint(15, 15));
if (!m_previewToolTip->isVisible())

6
src/plugins/qmldesigner/components/navigator/navigatorview.cpp
View File

@@ -51,7 +51,7 @@
#include <QHeaderView>
#include <QTimer>
#include <QPixmap>
static inline void setScenePos(const QmlDesigner::ModelNode &modelNode,const QPointF &pos)
{
@@ -263,9 +263,9 @@ void NavigatorView::enableWidget()
m_widget->enableNavigator();
}
void NavigatorView::modelNodePreviewImageChanged(const ModelNode &node, const QImage &image)
void NavigatorView::modelNodePreviewPixmapChanged(const ModelNode &node, const QPixmap &pixmap)
{
m_treeModel->updateToolTipImage(node, image);
m_treeModel->updateToolTipPixmap(node, pixmap);
}
ModelNode NavigatorView::modelNodeForIndex(const QModelIndex &modelIndex) const

4
src/plugins/qmldesigner/components/navigator/navigatorview.h
View File

@@ -38,7 +38,7 @@ class QTreeView;
class QItemSelection;
class QModelIndex;
class QAbstractItemModel;
class QImage;
class QPixmap;
QT_END_NAMESPACE
namespace QmlDesigner {
@@ -96,7 +96,7 @@ public:
void disableWidget() override;
void enableWidget() override;
void modelNodePreviewImageChanged(const ModelNode &node, const QImage &image) override;
void modelNodePreviewPixmapChanged(const ModelNode &node, const QPixmap &pixmap) override;
private:
ModelNode modelNodeForIndex(const QModelIndex &modelIndex) const;

4
src/plugins/qmldesigner/components/navigator/previewtooltip.cpp
View File

@@ -65,9 +65,9 @@ void PreviewToolTip::setInfo(const QString &info)
m_ui->infoLabel->setText(info);
}
void PreviewToolTip::setImage(const QImage &image)
void PreviewToolTip::setPixmap(const QPixmap &pixmap)
{
m_ui->imageLabel->setPixmap(QPixmap::fromImage(image));
m_ui->imageLabel->setPixmap(pixmap);
}
QString PreviewToolTip::id() const

4
src/plugins/qmldesigner/components/navigator/previewtooltip.h
View File

@@ -26,7 +26,7 @@
#pragma once
#include <QtWidgets/qwidget.h>
#include <QtGui/qimage.h>
#include <QtGui/qpixmap.h>
namespace QmlDesigner {
namespace Ui {
@@ -44,7 +44,7 @@ public:
void setId(const QString &id);
void setType(const QString &type);
void setInfo(const QString &info);
void setImage(const QImage &image);
void setPixmap(const QPixmap &pixmap);
QString id() const;

5
src/plugins/qmldesigner/designercore/include/abstractview.h
View File

@@ -45,6 +45,7 @@ QT_BEGIN_NAMESPACE
class QStyle;
class QToolButton;
class QImage;
class QPixmap;
QT_END_NAMESPACE
namespace QmlDesigner {
@@ -186,7 +187,7 @@ public:
void emitInstanceToken(const QString &token, int number, const QVector<ModelNode> &nodeVector);
void emitRenderImage3DChanged(const QImage &image);
void emitUpdateActiveScene3D(const QVariantMap &sceneState);
void emitModelNodelPreviewImageChanged(const ModelNode &node, const QImage &image);
void emitModelNodelPreviewPixmapChanged(const ModelNode &node, const QPixmap &pixmap);
void sendTokenToInstances(const QString &token, int number, const QVector<ModelNode> &nodeVector);
@@ -246,7 +247,7 @@ public:
virtual void renderImage3DChanged(const QImage &image);
virtual void updateActiveScene3D(const QVariantMap &sceneState);
virtual void modelNodePreviewImageChanged(const ModelNode &node, const QImage &image);
virtual void modelNodePreviewPixmapChanged(const ModelNode &node, const QPixmap &pixmap);
void changeRootNodeType(const TypeName &type, int majorVersion, int minorVersion);

2
src/plugins/qmldesigner/designercore/include/nodeinstanceview.h
View File

@@ -143,7 +143,7 @@ public:
void handlePuppetToCreatorCommand(const PuppetToCreatorCommand &command) override;
QVariant previewImageDataFor3DNode(const ModelNode &modelNode);
QVariant previewImageDataForGenericNode(const ModelNode &modelNode);
QVariant previewImageDataForImageNode(const ModelNode &modelNode);
protected:

33
src/plugins/qmldesigner/designercore/instances/nodeinstanceview.cpp
View File

@@ -1553,7 +1553,7 @@ void NodeInstanceView::timerEvent(QTimerEvent *event)
struct ImageData {
QDateTime time;
QImage image;
QPixmap pixmap;
QString type;
QString id;
QString info;
@@ -1562,10 +1562,10 @@ static QHash<QString, QHash<QString, ImageData>> imageDataMap;
static QVariant imageDataToVariant(const ImageData &imageData)
{
if (!imageData.image.isNull()) {
if (!imageData.pixmap.isNull()) {
QVariantMap map;
map.insert("type", imageData.type);
map.insert("image", QVariant::fromValue<QImage>(imageData.image));
map.insert("pixmap", QVariant::fromValue<QPixmap>(imageData.pixmap));
map.insert("id", imageData.id);
map.insert("info", imageData.info);
return map;
@@ -1599,13 +1599,13 @@ QVariant NodeInstanceView::previewImageDataForImageNode(const ModelNode &modelNo
}
if (reload) {
QImage originalImage;
originalImage.load(imageSource);
if (!originalImage.isNull()) {
imageData.image = originalImage.scaled(Constants::MODELNODE_PREVIEW_IMAGE_DIMENSIONS * 2,
Constants::MODELNODE_PREVIEW_IMAGE_DIMENSIONS * 2,
Qt::KeepAspectRatio);
imageData.image.setDevicePixelRatio(2.);
QPixmap originalPixmap;
originalPixmap.load(imageSource);
if (!originalPixmap.isNull()) {
imageData.pixmap = originalPixmap.scaled(Constants::MODELNODE_PREVIEW_IMAGE_DIMENSIONS * 2,
Constants::MODELNODE_PREVIEW_IMAGE_DIMENSIONS * 2,
Qt::KeepAspectRatio);
imageData.pixmap.setDevicePixelRatio(2.);
double imgSize = double(imageFi.size());
imageData.type = QStringLiteral("%1 (%2)").arg(QString::fromLatin1(modelNode.type())).arg(imageFi.suffix());
@@ -1616,7 +1616,7 @@ QVariant NodeInstanceView::previewImageDataForImageNode(const ModelNode &modelNo
++unitIndex;
imgSize /= 1024.;
}
imageData.info = QStringLiteral("%1 x %2 (%3%4)").arg(originalImage.width()).arg(originalImage.height())
imageData.info = QStringLiteral("%1 x %2 (%3%4)").arg(originalPixmap.width()).arg(originalPixmap.height())
.arg(QString::number(imgSize, 'g', 3)).arg(units[unitIndex]);
localDataMap.insert(imageSource, imageData);
}
@@ -1625,12 +1625,12 @@ QVariant NodeInstanceView::previewImageDataForImageNode(const ModelNode &modelNo
return imageDataToVariant(imageData);
}
QVariant NodeInstanceView::previewImageDataFor3DNode(const ModelNode &modelNode)
QVariant NodeInstanceView::previewImageDataForGenericNode(const ModelNode &modelNode)
{
QFileInfo docFi = QFileInfo(modelNode.model()->fileUrl().toLocalFile());
QHash<QString, ImageData> &localDataMap = imageDataMap[docFi.absoluteFilePath()];
ImageData imageData;
static const QImage placeHolder(":/navigator/icon/tooltip_placeholder.png");
static const QPixmap placeHolder(":/navigator/icon/tooltip_placeholder.png");
// We need puppet to generate the image, which needs to be asynchronous.
// Until the image is ready, we show a placeholder
@@ -1640,7 +1640,7 @@ QVariant NodeInstanceView::previewImageDataFor3DNode(const ModelNode &modelNode)
} else {
imageData.type = QString::fromLatin1(modelNode.type());
imageData.id = id;
imageData.image = placeHolder;
imageData.pixmap = placeHolder;
localDataMap.insert(id, imageData);
}
requestModelNodePreviewImage(modelNode);
@@ -1652,12 +1652,13 @@ void NodeInstanceView::updatePreviewImageForNode(const ModelNode &modelNode, con
{
QFileInfo docFi = QFileInfo(modelNode.model()->fileUrl().toLocalFile());
QString docPath = docFi.absoluteFilePath();
QPixmap pixmap = QPixmap::fromImage(image);
if (imageDataMap.contains(docPath)) {
QHash<QString, ImageData> &localDataMap = imageDataMap[docPath];
if (localDataMap.contains(modelNode.id()))
localDataMap[modelNode.id()].image = image;
localDataMap[modelNode.id()].pixmap = pixmap;
}
emitModelNodelPreviewImageChanged(modelNode, image);
emitModelNodelPreviewPixmapChanged(modelNode, pixmap);
}
}

6
src/plugins/qmldesigner/designercore/model/abstractview.cpp
View File

@@ -382,7 +382,7 @@ void AbstractView::updateActiveScene3D(const QVariantMap & /*sceneState*/)
{
}
void AbstractView::modelNodePreviewImageChanged(const ModelNode & /*node*/, const QImage & /*image*/)
void AbstractView::modelNodePreviewPixmapChanged(const ModelNode & /*node*/, const QPixmap & /*pixmap*/)
{
}
@@ -770,10 +770,10 @@ void AbstractView::emitUpdateActiveScene3D(const QVariantMap &sceneState)
model()->d->notifyUpdateActiveScene3D(sceneState);
}
void AbstractView::emitModelNodelPreviewImageChanged(const ModelNode &node, const QImage &image)
void AbstractView::emitModelNodelPreviewPixmapChanged(const ModelNode &node, const QPixmap &pixmap)
{
if (model())
model()->d->notifyModelNodePreviewImageChanged(node, image);
model()->d->notifyModelNodePreviewPixmapChanged(node, pixmap);
}
void AbstractView::emitRewriterEndTransaction()

4
src/plugins/qmldesigner/designercore/model/model.cpp
View File

@@ -700,11 +700,11 @@ void ModelPrivate::notifyUpdateActiveScene3D(const QVariantMap &sceneState)
}
}
void ModelPrivate::notifyModelNodePreviewImageChanged(const ModelNode &node, const QImage &image)
void ModelPrivate::notifyModelNodePreviewPixmapChanged(const ModelNode &node, const QPixmap &pixmap)
{
for (const QPointer<AbstractView> &view : qAsConst(m_viewList)) {
Q_ASSERT(view != nullptr);
view->modelNodePreviewImageChanged(node, image);
view->modelNodePreviewPixmapChanged(node, pixmap);
}
}

3
src/plugins/qmldesigner/designercore/model/model_p.h
View File

@@ -38,6 +38,7 @@
QT_BEGIN_NAMESPACE
class QPlainTextEdit;
class QPixmap;
QT_END_NAMESPACE
namespace QmlDesigner {
@@ -160,7 +161,7 @@ public:
void notifyRenderImage3DChanged(const QImage &image);
void notifyUpdateActiveScene3D(const QVariantMap &sceneState);
void notifyModelNodePreviewImageChanged(const ModelNode &node, const QImage &image);
void notifyModelNodePreviewPixmapChanged(const ModelNode &node, const QPixmap &pixmap);
void setDocumentMessages(const QList<DocumentMessage> &errors, const QList<DocumentMessage> &warnings);