QmlDesigner: Fix poor snapshot quality

It removes the image cache in the AssetsLibraryView too because it is not used. Fix ODR violation too. Fixes: QDS-6553 Change-Id: I83d8f8b7cd385e2c8352986e4b5a5abd76ac7d5b Reviewed-by: Thomas Hartmann <thomas.hartmann@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-04-11 17:20:37 +02:00
parent 63aaa65439
commit 4bd71ebf6a
16 changed files with 99 additions and 93 deletions
--- a/share/qtcreator/qml/qmlpuppet/commands/createscenecommand.h
+++ b/share/qtcreator/qml/qmlpuppet/commands/createscenecommand.h
@@ -25,9 +25,10 @@

 #pragma once

-#include <qmetatype.h>
+#include <QSize>
 #include <QUrl>
 #include <QVector>
+#include <qmetatype.h>

 #include "instancecontainer.h"
 #include "reparentcontainer.h"
@@ -55,6 +56,8 @@ public:
                                const QUrl &resourceUrl,
                                const QHash<QString, QVariantMap> &edit3dToolStates,
                                const QString &language,
+                                QSize captureImageMinimumSize,
+                                QSize captureImageMaximumSize,
                                qint32 stateInstanceId)
        : instances(instanceContainer)
        , reparentInstances(reparentContainer)
@@ -68,6 +71,8 @@ public:
        , resourceUrl(resourceUrl)
        , edit3dToolStates(edit3dToolStates)
        , language(language)
+        , captureImageMinimumSize(captureImageMinimumSize)
+        , captureImageMaximumSize(captureImageMaximumSize)
        , stateInstanceId{stateInstanceId}
    {}

@@ -86,6 +91,8 @@ public:
        out << command.edit3dToolStates;
        out << command.language;
        out << command.stateInstanceId;
+        out << command.captureImageMinimumSize;
+        out << command.captureImageMaximumSize;

        return out;
    }
@@ -105,6 +112,8 @@ public:
        in >> command.edit3dToolStates;
        in >> command.language;
        in >> command.stateInstanceId;
+        in >> command.captureImageMinimumSize;
+        in >> command.captureImageMaximumSize;

        return in;
    }
@@ -122,6 +131,8 @@ public:
    QUrl resourceUrl;
    QHash<QString, QVariantMap> edit3dToolStates;
    QString language;
+    QSize captureImageMinimumSize;
+    QSize captureImageMaximumSize;
    qint32 stateInstanceId = 0;
 };

--- a/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/qt5captureimagenodeinstanceserver.cpp
+++ b/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/qt5captureimagenodeinstanceserver.cpp
@@ -38,16 +38,22 @@ namespace QmlDesigner {

 namespace {

-QImage renderImage(ServerNodeInstance rootNodeInstance)
+QImage renderImage(ServerNodeInstance rootNodeInstance, QSize minimumSize, QSize maximumSize)
 {
    rootNodeInstance.updateDirtyNodeRecursive();

    QSize previewImageSize = rootNodeInstance.boundingRect().size().toSize();
-    if (previewImageSize.isEmpty())
-        previewImageSize = {150, 150};
+    if (previewImageSize.isEmpty()) {
+        previewImageSize = minimumSize;
+    } else if (previewImageSize.width() < minimumSize.width()
+               || previewImageSize.height() < minimumSize.height()) {
+        previewImageSize.scale(minimumSize, Qt::KeepAspectRatio);
+    }

-    if (previewImageSize.width() > 150 || previewImageSize.height() > 150)
-        previewImageSize.scale({150, 150}, Qt::KeepAspectRatio);
+    if (previewImageSize.width() > maximumSize.width()
+        || previewImageSize.height() > maximumSize.height()) {
+        previewImageSize.scale(maximumSize, Qt::KeepAspectRatio);
+    }

    QImage previewImage = rootNodeInstance.renderPreviewImage(previewImageSize);

@@ -73,7 +79,7 @@ void Qt5CaptureImageNodeInstanceServer::collectItemChangesAndSendChangeCommands(

        DesignerSupport::polishItems(quickWindow());

-        QImage image = renderImage(rooNodeInstance);
+        QImage image = renderImage(rooNodeInstance, m_minimumSize, m_maximumSize);

        nodeInstanceClient()->capturedData(CapturedDataCommand{std::move(image)});

@@ -82,4 +88,12 @@ void Qt5CaptureImageNodeInstanceServer::collectItemChangesAndSendChangeCommands(
    }
 }

+void QmlDesigner::Qt5CaptureImageNodeInstanceServer::createScene(const CreateSceneCommand &command)
+{
+    m_minimumSize = command.captureImageMinimumSize;
+    m_maximumSize = command.captureImageMaximumSize;
+
+    Qt5PreviewNodeInstanceServer::createScene(command);
+}
+
 } // namespace
--- a/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/qt5captureimagenodeinstanceserver.h
+++ b/share/qtcreator/qml/qmlpuppet/qml2puppet/instances/qt5captureimagenodeinstanceserver.h
@@ -36,10 +36,14 @@ public:
        : Qt5PreviewNodeInstanceServer(nodeInstanceClient)
    {}

+    void createScene(const CreateSceneCommand &command) override;
+
 protected:
    void collectItemChangesAndSendChangeCommands() override;

 private:
+    QSize m_minimumSize;
+    QSize m_maximumSize;
 };

 } // namespace QmlDesigner
--- a/src/plugins/qmldesigner/components/assetslibrary/assetslibraryview.cpp
+++ b/src/plugins/qmldesigner/components/assetslibrary/assetslibraryview.cpp
@@ -50,31 +50,17 @@

 namespace QmlDesigner {

-namespace {
-ProjectExplorer::Target *activeTarget(ProjectExplorer::Project *project)
-{
-    if (project)
-        return project->activeTarget();
-
-    return {};
-}
-} // namespace
-
-class ImageCacheData
+class AssetsLibraryView::ImageCacheData
 {
 public:
    Sqlite::Database database{Utils::PathString{
-                                  Core::ICore::cacheResourcePath("imagecache-v2.db").toString()},
+                                  Core::ICore::cacheResourcePath("fontimagecache.db").toString()},
                              Sqlite::JournalMode::Wal,
                              Sqlite::LockingMode::Normal};
    ImageCacheStorage<Sqlite::Database> storage{database};
-    ImageCacheConnectionManager connectionManager;
-    ImageCacheCollector collector{connectionManager};
    ImageCacheFontCollector fontCollector;
-    ImageCacheGenerator generator{collector, storage};
    ImageCacheGenerator fontGenerator{fontCollector, storage};
    TimeStampProvider timeStampProvider;
-    AsynchronousImageCache cache{storage, generator, timeStampProvider};
    AsynchronousImageCache asynchronousFontImageCache{storage, fontGenerator, timeStampProvider};
    SynchronousImageCache synchronousFontImageCache{storage, timeStampProvider, fontCollector};
 };
@@ -94,9 +80,8 @@ bool AssetsLibraryView::hasWidget() const
 WidgetInfo AssetsLibraryView::widgetInfo()
 {
    if (m_widget.isNull()) {
-        m_widget = new AssetsLibraryWidget{imageCacheData()->cache,
-                                         imageCacheData()->asynchronousFontImageCache,
-                                         imageCacheData()->synchronousFontImageCache};
+        m_widget = new AssetsLibraryWidget{imageCacheData()->asynchronousFontImageCache,
+                                           imageCacheData()->synchronousFontImageCache};
    }

    return createWidgetInfo(m_widget.data(),
@@ -133,49 +118,18 @@ void AssetsLibraryView::setResourcePath(const QString &resourcePath)
    m_lastResourcePath = resourcePath;

    if (m_widget.isNull()) {
-        m_widget = new AssetsLibraryWidget{m_imageCacheData->cache,
-                                           m_imageCacheData->asynchronousFontImageCache,
-                                           m_imageCacheData->synchronousFontImageCache};
+        m_widget = new AssetsLibraryWidget{imageCacheData()->asynchronousFontImageCache,
+                                           imageCacheData()->synchronousFontImageCache};
    }

    m_widget->setResourcePath(resourcePath);
 }

-ImageCacheData *AssetsLibraryView::imageCacheData()
+AssetsLibraryView::ImageCacheData *AssetsLibraryView::imageCacheData()
 {
-    std::call_once(imageCacheFlag, [this]() {
-        m_imageCacheData = std::make_unique<ImageCacheData>();
-        auto setTargetInImageCache =
-            [imageCacheData = m_imageCacheData.get()](ProjectExplorer::Target *target) {
-                if (target == imageCacheData->collector.target())
-                    return;
-
-                if (target)
-                    imageCacheData->cache.clean();
-
-                imageCacheData->collector.setTarget(target);
-            };
-
-        if (auto project = ProjectExplorer::SessionManager::startupProject(); project) {
-            m_imageCacheData->collector.setTarget(project->activeTarget());
-            connect(project,
-                    &ProjectExplorer::Project::activeTargetChanged,
-                    this,
-                    setTargetInImageCache);
-        }
-        connect(ProjectExplorer::SessionManager::instance(),
-                &ProjectExplorer::SessionManager::startupProjectChanged,
-                this,
-                [=](ProjectExplorer::Project *project) {
-                    setTargetInImageCache(activeTarget(project));
-                });
-    });
+    std::call_once(imageCacheFlag,
+                   [this]() { m_imageCacheData = std::make_unique<ImageCacheData>(); });
    return m_imageCacheData.get();
 }

-AsynchronousImageCache &AssetsLibraryView::imageCache()
-{
-    return imageCacheData()->cache;
-}
-
 } // namespace QmlDesigner
--- a/src/plugins/qmldesigner/components/assetslibrary/assetslibraryview.h
+++ b/src/plugins/qmldesigner/components/assetslibrary/assetslibraryview.h
@@ -34,7 +34,6 @@
 namespace QmlDesigner {

 class AssetsLibraryWidget;
-class ImageCacheData;
 class AsynchronousImageCache;

 class AssetsLibraryView : public AbstractView
@@ -54,9 +53,8 @@ public:

    void setResourcePath(const QString &resourcePath);

-    AsynchronousImageCache &imageCache();
-
 private:
+    class ImageCacheData;
    ImageCacheData *imageCacheData();

    std::once_flag imageCacheFlag;
--- a/src/plugins/qmldesigner/components/assetslibrary/assetslibrarywidget.cpp
+++ b/src/plugins/qmldesigner/components/assetslibrary/assetslibrarywidget.cpp
@@ -110,16 +110,14 @@ bool AssetsLibraryWidget::eventFilter(QObject *obj, QEvent *event)
    return QObject::eventFilter(obj, event);
 }

-AssetsLibraryWidget::AssetsLibraryWidget(AsynchronousImageCache &imageCache,
-                                     AsynchronousImageCache &asynchronousFontImageCache,
-                                     SynchronousImageCache &synchronousFontImageCache)
+AssetsLibraryWidget::AssetsLibraryWidget(AsynchronousImageCache &asynchronousFontImageCache,
+                                         SynchronousImageCache &synchronousFontImageCache)
    : m_itemIconSize(24, 24)
    , m_fontImageCache(synchronousFontImageCache)
    , m_assetsIconProvider(new AssetsLibraryIconProvider(synchronousFontImageCache))
    , m_fileSystemWatcher(new Utils::FileSystemWatcher(this))
    , m_assetsModel(new AssetsLibraryModel(m_fileSystemWatcher, this))
    , m_assetsWidget(new QQuickWidget(this))
-    , m_imageCache{imageCache}
 {
    m_assetCompressionTimer.setInterval(200);
    m_assetCompressionTimer.setSingleShot(true);
--- a/src/plugins/qmldesigner/components/assetslibrary/assetslibrarywidget.h
+++ b/src/plugins/qmldesigner/components/assetslibrary/assetslibrarywidget.h
@@ -60,8 +60,7 @@ class AssetsLibraryWidget : public QFrame
    Q_OBJECT

 public:
-    AssetsLibraryWidget(AsynchronousImageCache &imageCache,
-                        AsynchronousImageCache &asynchronousFontImageCache,
+    AssetsLibraryWidget(AsynchronousImageCache &asynchronousFontImageCache,
                        SynchronousImageCache &synchronousFontImageCache);
    ~AssetsLibraryWidget();

@@ -110,7 +109,6 @@ private:
    std::unique_ptr<PreviewTooltipBackend> m_fontPreviewTooltipBackend;

    QShortcut *m_qmlSourceUpdateShortcut = nullptr;
-    AsynchronousImageCache &m_imageCache;
    QPointer<Model> m_model;
    QStringList m_assetsToDrag;
    bool m_updateRetry = false;
--- a/src/plugins/qmldesigner/components/itemlibrary/itemlibraryview.cpp
+++ b/src/plugins/qmldesigner/components/itemlibrary/itemlibraryview.cpp
@@ -62,7 +62,7 @@ ProjectExplorer::Target *activeTarget(ProjectExplorer::Project *project)
 }
 } // namespace

-class ImageCacheData
+class ItemLibraryView::ImageCacheData
 {
 public:
    Sqlite::Database database{Utils::PathString{
@@ -71,7 +71,7 @@ public:
                              Sqlite::LockingMode::Normal};
    ImageCacheStorage<Sqlite::Database> storage{database};
    ImageCacheConnectionManager connectionManager;
-    ImageCacheCollector collector{connectionManager};
+    ImageCacheCollector collector{connectionManager, QSize{300, 300}, QSize{600, 600}};
    ImageCacheFontCollector fontCollector;
    ImageCacheGenerator generator{collector, storage};
    ImageCacheGenerator fontGenerator{fontCollector, storage};
@@ -182,7 +182,7 @@ void ItemLibraryView::usedImportsChanged(const QList<Import> &usedImports)
    m_widget->updateUsedImports(usedImports);
 }

-ImageCacheData *ItemLibraryView::imageCacheData()
+ItemLibraryView::ImageCacheData *ItemLibraryView::imageCacheData()
 {
    std::call_once(imageCacheFlag, [this]() {
        m_imageCacheData = std::make_unique<ImageCacheData>();
--- a/src/plugins/qmldesigner/components/itemlibrary/itemlibraryview.h
+++ b/src/plugins/qmldesigner/components/itemlibrary/itemlibraryview.h
@@ -34,7 +34,6 @@
 namespace QmlDesigner {

 class ItemLibraryWidget;
-class ImageCacheData;
 class AsynchronousImageCache;

 class ItemLibraryView : public AbstractView
@@ -65,6 +64,7 @@ protected:
    void updateImports();

 private:
+    class ImageCacheData;
    ImageCacheData *imageCacheData();

    std::once_flag imageCacheFlag;
--- a/src/plugins/qmldesigner/components/previewtooltip/previewimagetooltip.cpp
+++ b/src/plugins/qmldesigner/components/previewtooltip/previewimagetooltip.cpp
@@ -68,7 +68,8 @@ void PreviewImageTooltip::setImage(const QImage &image, bool scale)
    if (scale) {
        m_ui->imageLabel->setPixmap(pm.scaled(m_ui->imageLabel->width(),
                                              m_ui->imageLabel->height(),
-                                              Qt::KeepAspectRatio));
+                                              Qt::KeepAspectRatio,
+                                              Qt::SmoothTransformation));
    } else {
        m_ui->imageLabel->setPixmap(pm);
    }
--- a/src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.cpp
+++ b/src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.cpp
@@ -61,8 +61,12 @@ QString fileToString(const QString &filename)
 } // namespace

 ImageCacheCollector::ImageCacheCollector(ImageCacheConnectionManager &connectionManager,
+                                         QSize captureImageMinimumSize,
+                                         QSize captureImageMaximumSize,
                                         ImageCacheCollectorNullImageHandling nullImageHandling)
    : m_connectionManager{connectionManager}
+    , captureImageMinimumSize{captureImageMinimumSize}
+    , captureImageMaximumSize{captureImageMaximumSize}
    , nullImageHandling{nullImageHandling}
 {}

@@ -76,6 +80,8 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
 {
    RewriterView rewriterView{RewriterView::Amend, nullptr};
    NodeInstanceView nodeInstanceView{m_connectionManager};
+    nodeInstanceView.setCaptureImageMinimumAndMaximumSize(captureImageMinimumSize,
+                                                          captureImageMaximumSize);

    const QString filePath{name};
    std::unique_ptr<Model> model{QmlDesigner::Model::create("QtQuick/Item", 2, 1)};
@@ -107,7 +113,10 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
            || !image.isNull()) {
            QSize smallImageSize = image.size().scaled(QSize{96, 96}.boundedTo(image.size()),
                                                       Qt::KeepAspectRatio);
-            QImage smallImage = image.isNull() ? QImage{} : image.scaled(smallImageSize);
+            QImage smallImage = image.isNull() ? QImage{}
+                                               : image.scaled(smallImageSize,
+                                                              Qt::IgnoreAspectRatio,
+                                                              Qt::SmoothTransformation);
            captureCallback(image, smallImage);
        }
    };
--- a/src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.h
+++ b/src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.h
@@ -51,6 +51,8 @@ class ImageCacheCollector final : public ImageCacheCollectorInterface
 {
 public:
    ImageCacheCollector(ImageCacheConnectionManager &connectionManager,
+                        QSize captureImageMinimumSize,
+                        QSize captureImageMaximumSize,
                        ImageCacheCollectorNullImageHandling nullImageHandling = {});

    ~ImageCacheCollector();
@@ -75,6 +77,8 @@ public:
 private:
    ImageCacheConnectionManager &m_connectionManager;
    QPointer<ProjectExplorer::Target> m_target;
+    QSize captureImageMinimumSize;
+    QSize captureImageMaximumSize;
    ImageCacheCollectorNullImageHandling nullImageHandling{};
 };

--- a/src/plugins/qmldesigner/designercore/include/nodeinstanceview.h
+++ b/src/plugins/qmldesigner/designercore/include/nodeinstanceview.h
@@ -161,6 +161,13 @@ public:
        m_crashCallback = std::move(crashCallback);
    }

+    void setCaptureImageMinimumAndMaximumSize(QSize captureImageMinimumSize,
+                                              QSize captureImageMaximumSize)
+    {
+        m_captureImageMinimumSize = captureImageMinimumSize;
+        m_captureImageMaximumSize = captureImageMaximumSize;
+    }
+
    void startNanotrace();
    void endNanotrace();

@@ -293,6 +300,8 @@ private:
    QHash<QString, QStringList> m_qsbPathToFilterMap;
    int m_remainingQsbTargets = 0;
    QTimer m_rotBlockTimer;
+    QSize m_captureImageMinimumSize{150, 150};
+    QSize m_captureImageMaximumSize{1000, 1000};
 };

 } // namespace ProxyNodeInstanceView
--- a/src/plugins/qmldesigner/designercore/instances/nodeinstanceview.cpp
+++ b/src/plugins/qmldesigner/designercore/instances/nodeinstanceview.cpp
@@ -1138,24 +1138,27 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
    if (stateNode.isValid() && stateNode.metaInfo().isSubclassOf("QtQuick.State", 1, 0))
        stateInstanceId = stateNode.internalId();

-    return CreateSceneCommand(instanceContainerList,
-                              reparentContainerList,
-                              idContainerList,
-                              valueContainerList,
-                              bindingContainerList,
-                              auxiliaryContainerVector,
-                              importVector,
-                              mockupTypesVector,
-                              model()->fileUrl(),
+    return CreateSceneCommand(
+        instanceContainerList,
+        reparentContainerList,
+        idContainerList,
+        valueContainerList,
+        bindingContainerList,
+        auxiliaryContainerVector,
+        importVector,
+        mockupTypesVector,
+        model()->fileUrl(),
 #ifndef QMLDESIGNER_TEST
-                              QUrl::fromLocalFile(QmlDesigner::DocumentManager::currentResourcePath()
-                                                  .toFileInfo().absoluteFilePath()),
+        QUrl::fromLocalFile(
+            QmlDesigner::DocumentManager::currentResourcePath().toFileInfo().absoluteFilePath()),
 #else
-                              QUrl::fromLocalFile(QFileInfo(model()->fileUrl().toLocalFile()).absolutePath()),
+        QUrl::fromLocalFile(QFileInfo(model()->fileUrl().toLocalFile()).absolutePath()),
 #endif
-                              m_edit3DToolStates[model()->fileUrl()],
-                              lastUsedLanguage,
-                              stateInstanceId);
+        m_edit3DToolStates[model()->fileUrl()],
+        lastUsedLanguage,
+        m_captureImageMinimumSize,
+        m_captureImageMaximumSize,
+        stateInstanceId);
 }

 ClearSceneCommand NodeInstanceView::createClearSceneCommand() const
--- a/src/plugins/qmldesigner/qmldesignerprojectmanager.cpp
+++ b/src/plugins/qmldesigner/qmldesignerprojectmanager.cpp
@@ -108,6 +108,8 @@ public:
    {}
    ImageCacheConnectionManager connectionManager;
    ImageCacheCollector collector{connectionManager,
+                                  QSize{300, 300},
+                                  QSize{1000, 1000},
                                  ImageCacheCollectorNullImageHandling::DontCaptureNullImage};
    TimeStampProvider timeStampProvider;
    AsynchronousImageFactory factory;
--- a/src/plugins/studiowelcome/qml/welcomepage/HoverOverDesaturate.qml
+++ b/src/plugins/studiowelcome/qml/welcomepage/HoverOverDesaturate.qml
@@ -116,6 +116,7 @@ Item {
            id: image
            width: 240
            height: 125
+            mipmap: true
            fillMode: Image.PreserveAspectFit
        }
    }