QmlDesigner: Cleanup CreateTexture

CreateTexture doesn't need to be a QObject. It is easier to take care
of its destruction if it is not a QObject.
Also there were a couple of non-related methods, that can be placed in
Utils3D.

Change-Id: Ie0aaf372d5572ac1a2d437f05bdd866bc705e861
Reviewed-by: Mahmoud Badri <mahmoud.badri@qt.io>
Reviewed-by: Miikka Heikkinen <miikka.heikkinen@qt.io>

src/plugins/qmldesigner/components/assetslibrary/assetslibrarywidget.cpp

@@ -7,6 +7,7 @@
 #include "assetslibrarymodel.h"
 #include "assetslibraryview.h"
 
+#include <createtexture.h>
 #include <designeractionmanager.h>
 #include <designerpaths.h>
 #include <designmodewidget.h>
@@ -100,7 +101,6 @@ AssetsLibraryWidget::AssetsLibraryWidget(AsynchronousImageCache &asynchronousFon
     , m_assetsIconProvider{new AssetsLibraryIconProvider(synchronousFontImageCache)}
     , m_assetsModel{new AssetsLibraryModel(this)}
     , m_assetsView{view}
-    , m_createTextures{view}
     , m_assetsWidget{Utils::makeUniqueObjectPtr<StudioQuickWidget>(this)}
 {
     setWindowTitle(tr("Assets Library", "Title of assets library widget"));
@@ -231,18 +231,20 @@ int AssetsLibraryWidget::qtVersion() const
 void AssetsLibraryWidget::addTextures(const QStringList &filePaths)
 {
     m_assetsView->executeInTransaction(__FUNCTION__, [&] {
-        m_createTextures.execute(filePaths,
+        CreateTexture(m_assetsView)
-                                 AddTextureMode::Texture,
+            .execute(filePaths,
-                                 Utils3D::active3DSceneId(m_assetsView->model()));
+                     AddTextureMode::Texture,
+                     Utils3D::active3DSceneId(m_assetsView->model()));
     });
 }
 
 void AssetsLibraryWidget::addLightProbe(const QString &filePath)
 {
     m_assetsView->executeInTransaction(__FUNCTION__, [&] {
-        m_createTextures.execute({filePath},
+        CreateTexture(m_assetsView)
-                                 AddTextureMode::LightProbe,
+            .execute(filePath,
-                                 Utils3D::active3DSceneId(m_assetsView->model()));
+                     AddTextureMode::LightProbe,
+                     Utils3D::active3DSceneId(m_assetsView->model()));
     });
 }
 
@@ -251,8 +253,9 @@ void AssetsLibraryWidget::updateContextMenuActionsEnableState()
     setHasMaterialLibrary(Utils3D::materialLibraryNode(m_assetsView).isValid()
                           && m_assetsView->model()->hasImport("QtQuick3D"));
 
-    ModelNode activeSceneEnv = m_createTextures.resolveSceneEnv(
+    ModelNode activeSceneEnv = Utils3D::resolveSceneEnv(m_assetsView,
-        Utils3D::active3DSceneId(m_assetsView->model()));
+                                                        Utils3D::active3DSceneId(
+                                                            m_assetsView->model()));
     setHasSceneEnv(activeSceneEnv.isValid());
 }
 

src/plugins/qmldesigner/components/assetslibrary/assetslibrarywidget.h

@@ -3,7 +3,6 @@
 
 #pragma once
 
-#include "createtexture.h"
 #include "previewtooltipbackend.h"
 
 #include <coreplugin/icontext.h>
@@ -135,7 +134,6 @@ private:
     AssetsLibraryIconProvider *m_assetsIconProvider = nullptr;
     AssetsLibraryModel *m_assetsModel = nullptr;
     AssetsLibraryView *m_assetsView = nullptr;
-    CreateTextures m_createTextures = nullptr;
 
     Utils::UniqueObjectPtr<StudioQuickWidget> m_assetsWidget;
     std::unique_ptr<PreviewTooltipBackend> m_fontPreviewTooltipBackend;

src/plugins/qmldesigner/components/componentcore/createtexture.cpp

@@ -114,10 +114,10 @@ ModelNode CreateTexture::execute(const QString &filePath, AddTextureMode mode, i
         return {};
 
     if (mode == AddTextureMode::LightProbe && sceneId != -1)
-        assignTextureAsLightProbe(texture, sceneId);
+        Utils3D::assignTextureAsLightProbe(m_view, texture, sceneId);
 
-    QTimer::singleShot(0, m_view, [this, texture]() {
+    QTimer::singleShot(0, m_view, [view = m_view, texture]() {
-        if (m_view->model() && texture.isValid()) {
+        if (view && view->model() && texture.isValid()) {
             QmlDesignerPlugin::instance()->mainWidget()->showDockWidget("MaterialBrowser");
             Utils3D::selectTexture(texture);
         }
@@ -210,6 +210,12 @@ ModelNode CreateTexture::execute(const ModelNode &texture)
     return duplicateTextureNode;
 }
 
+void CreateTexture::execute(const QStringList &filePaths, AddTextureMode mode, int sceneId)
+{
+    for (const QString &path : filePaths)
+        execute(path, mode, sceneId);
+}
+
 bool CreateTexture::addFileToProject(const QString &filePath)
 {
     AddFilesResult result = ModelNodeOperations::addImageToProject(
@@ -260,48 +266,4 @@ ModelNode CreateTexture::createTextureFromImage(const  Utils::FilePath &assetPat
     return newTexNode;
 }
 
-void CreateTexture::assignTextureAsLightProbe(const ModelNode &texture, int sceneId)
-{
-    ModelNode sceneEnvNode = resolveSceneEnv(sceneId);
-    QmlObjectNode sceneEnv = sceneEnvNode;
-    if (sceneEnv.isValid()) {
-        sceneEnv.setBindingProperty("lightProbe", texture.id());
-        sceneEnv.setVariantProperty("backgroundMode",
-                                    QVariant::fromValue(Enumeration("SceneEnvironment",
-                                                                    "SkyBox")));
-    }
-}
-
-ModelNode CreateTexture::resolveSceneEnv(int sceneId)
-{
-    ModelNode activeSceneEnv;
-    ModelNode selectedNode = m_view->firstSelectedModelNode();
-
-    if (selectedNode.metaInfo().isQtQuick3DSceneEnvironment()) {
-        activeSceneEnv = selectedNode;
-    } else if (sceneId != -1) {
-        ModelNode activeScene = Utils3D::active3DSceneNode(m_view);
-        if (activeScene.isValid()) {
-            QmlObjectNode view3D;
-            if (activeScene.metaInfo().isQtQuick3DView3D()) {
-                view3D = activeScene;
-            } else {
-                ModelNode sceneParent = activeScene.parentProperty().parentModelNode();
-                if (sceneParent.metaInfo().isQtQuick3DView3D())
-                    view3D = sceneParent;
-            }
-            if (view3D.isValid())
-                activeSceneEnv = m_view->modelNodeForId(view3D.expression("environment"));
-        }
-    }
-
-    return activeSceneEnv;
-}
-
-void CreateTextures::execute(const QStringList &filePaths, AddTextureMode mode, int sceneId)
-{
-    for (const QString &path : filePaths)
-        CreateTexture::execute(path, mode, sceneId);
-}
-
 } // namespace QmlDesigner

src/plugins/qmldesigner/components/componentcore/createtexture.h

@@ -3,7 +3,7 @@
 
 #pragma once
 
-#include <QObject>
+#include <QStringList>
 
 namespace Utils {
 class FilePath;
@@ -16,10 +16,8 @@ class ModelNode;
 
 enum class AddTextureMode { Image, Texture, LightProbe };
 
-class CreateTexture : public QObject
+class CreateTexture
 {
-    Q_OBJECT
-
 public:
     CreateTexture(AbstractView *view);
 
@@ -28,8 +26,7 @@ public:
                       AddTextureMode mode = AddTextureMode::Texture,
                       int sceneId = -1);
     ModelNode execute(const ModelNode &texture);
-    ModelNode resolveSceneEnv(int sceneId);
+    void execute(const QStringList &filePaths, AddTextureMode mode, int sceneId = -1);
-    void assignTextureAsLightProbe(const ModelNode &texture, int sceneId);
 
 private:
     bool addFileToProject(const QString &filePath);
@@ -38,11 +35,4 @@ private:
     AbstractView *m_view = nullptr;
 };
 
-class CreateTextures : public CreateTexture
-{
-public:
-    using CreateTexture::CreateTexture;
-    void execute(const QStringList &filePaths, AddTextureMode mode, int sceneId = -1);
-};
-
 } // namespace QmlDesigner

src/plugins/qmldesigner/components/componentcore/modelnodeoperations.cpp

@@ -1915,10 +1915,8 @@ ModelNode createTextureNode(AbstractView *view, const QString &imagePath)
 {
     QTC_ASSERT(view, return {});
 
-    auto textureCreator = new CreateTexture(view);
+    CreateTexture textureCreator(view);
-    ModelNode texture = textureCreator->execute(imagePath, AddTextureMode::Texture);
+    return textureCreator.execute(imagePath, AddTextureMode::Texture);
-    textureCreator->deleteLater();
-    return texture;
 }
 
 bool dropAsImage3dTexture(const ModelNode &targetNode,

src/plugins/qmldesigner/components/componentcore/utils3d.cpp

@@ -252,6 +252,43 @@ void applyMaterialToModels(AbstractView *view, const ModelNode &material,
     });
 }
 
+ModelNode resolveSceneEnv(AbstractView *view, int sceneId)
+{
+    ModelNode activeSceneEnv;
+    ModelNode selectedNode = view->firstSelectedModelNode();
+
+    if (selectedNode.metaInfo().isQtQuick3DSceneEnvironment()) {
+        activeSceneEnv = selectedNode;
+    } else if (sceneId != -1) {
+        ModelNode activeScene = Utils3D::active3DSceneNode(view);
+        if (activeScene.isValid()) {
+            QmlObjectNode view3D;
+            if (activeScene.metaInfo().isQtQuick3DView3D()) {
+                view3D = activeScene;
+            } else {
+                ModelNode sceneParent = activeScene.parentProperty().parentModelNode();
+                if (sceneParent.metaInfo().isQtQuick3DView3D())
+                    view3D = sceneParent;
+            }
+            if (view3D.isValid())
+                activeSceneEnv = view->modelNodeForId(view3D.expression("environment"));
+        }
+    }
+
+    return activeSceneEnv;
+}
+
+void assignTextureAsLightProbe(AbstractView *view, const ModelNode &texture, int sceneId)
+{
+    ModelNode sceneEnvNode = resolveSceneEnv(view, sceneId);
+    QmlObjectNode sceneEnv = sceneEnvNode;
+    if (sceneEnv.isValid()) {
+        sceneEnv.setBindingProperty("lightProbe", texture.id());
+        sceneEnv.setVariantProperty("backgroundMode",
+                                    QVariant::fromValue(Enumeration("SceneEnvironment", "SkyBox")));
+    }
+}
+
 // This method should be executed within a transaction as it performs multiple modifications to the model
 #ifdef QDS_USE_PROJECTSTORAGE
 ModelNode createMaterial(AbstractView *view, const TypeName &typeName)

src/plugins/qmldesigner/components/componentcore/utils3d.h

@@ -40,10 +40,14 @@ void selectTexture(const ModelNode &texture);
 ModelNode selectedMaterial(AbstractView *view);
 ModelNode selectedTexture(AbstractView *view);
 
+ModelNode resolveSceneEnv(AbstractView *view, int sceneId);
+
 QList<ModelNode> getSelectedModels(AbstractView *view);
 void applyMaterialToModels(AbstractView *view, const ModelNode &material,
                            const QList<ModelNode> &models, bool add = false);
 
+void assignTextureAsLightProbe(AbstractView *view, const ModelNode &texture, int sceneId);
+
 #ifdef QDS_USE_PROJECTSTORAGE
 ModelNode createMaterial(AbstractView *view, const TypeName &typeName);
 #else

src/plugins/qmldesigner/components/contentlibrary/contentlibraryview.cpp

@@ -57,7 +57,6 @@ ContentLibraryView::ContentLibraryView(AsynchronousImageCache &imageCache,
                                        ExternalDependenciesInterface &externalDependencies)
     : AbstractView(externalDependencies)
     , m_imageCache(imageCache)
-    , m_createTexture(this)
 {}
 
 ContentLibraryView::~ContentLibraryView()
@@ -88,15 +87,17 @@ WidgetInfo ContentLibraryView::widgetInfo()
             m_draggedBundleItem = item;
         });
 
-        connect(m_widget, &ContentLibraryWidget::addTextureRequested, this,
+        connect(m_widget,
-                [&] (const QString &texPath, AddTextureMode mode) {
+                &ContentLibraryWidget::addTextureRequested,
-            executeInTransaction("ContentLibraryView::widgetInfo", [&]() {
+                this,
-                m_createTexture.execute(texPath, mode, m_sceneId);
+                [&](const QString &texPath, AddTextureMode mode) {
-            });
+                    executeInTransaction("ContentLibraryView::widgetInfo", [&]() {
-        });
+                        CreateTexture(this).execute(texPath, mode, m_sceneId);
+                    });
+                });
 
         connect(m_widget, &ContentLibraryWidget::updateSceneEnvStateRequested, this, [&]() {
-            ModelNode activeSceneEnv = m_createTexture.resolveSceneEnv(m_sceneId);
+            ModelNode activeSceneEnv = Utils3D::resolveSceneEnv(this, m_sceneId);
             const bool sceneEnvExists = activeSceneEnv.isValid();
             m_widget->texturesModel()->setHasSceneEnv(sceneEnvExists);
             m_widget->environmentsModel()->setHasSceneEnv(sceneEnvExists);

src/plugins/qmldesigner/components/contentlibrary/contentlibraryview.h

@@ -90,7 +90,6 @@ private:
     bool m_bundleMaterialAddToSelected = false;
     bool m_hasQuick3DImport = false;
     qint32 m_sceneId = -1;
-    CreateTexture m_createTexture;
     Utils::FilePath m_iconSavePath;
     QString m_generatedFolderName;
     QString m_bundleId;

src/plugins/qmldesigner/components/materialbrowser/materialbrowserview.cpp

@@ -210,7 +210,7 @@ WidgetInfo MaterialBrowserView::widgetInfo()
         });
 
         connect(texturesModel, &MaterialBrowserTexturesModel::updateSceneEnvStateRequested, this, [&]() {
-            ModelNode activeSceneEnv = CreateTexture(this).resolveSceneEnv(m_sceneId);
+            ModelNode activeSceneEnv = Utils3D::resolveSceneEnv(this, m_sceneId);
             const bool sceneEnvExists = activeSceneEnv.isValid();
             m_widget->materialBrowserTexturesModel()->setHasSceneEnv(sceneEnvExists);
         });
@@ -223,12 +223,14 @@ WidgetInfo MaterialBrowserView::widgetInfo()
             m_widget->materialBrowserTexturesModel()->setHasSingleModelSelection(hasModel);
         });
 
-        connect(texturesModel, &MaterialBrowserTexturesModel::applyAsLightProbeRequested, this,
+        connect(texturesModel,
-                [&] (const ModelNode &texture) {
+                &MaterialBrowserTexturesModel::applyAsLightProbeRequested,
-            executeInTransaction(__FUNCTION__, [&] {
+                this,
-                CreateTexture(this).assignTextureAsLightProbe(texture, m_sceneId);
+                [&](const ModelNode &texture) {
-            });
+                    executeInTransaction(__FUNCTION__, [&] {
-        });
+                        Utils3D::assignTextureAsLightProbe(this, texture, m_sceneId);
+                    });
+                });
     }
 
     return createWidgetInfo(m_widget.data(),
@@ -240,13 +242,9 @@ WidgetInfo MaterialBrowserView::widgetInfo()
 
 void MaterialBrowserView::createTextures(const QStringList &assetPaths)
 {
-    auto *create = new CreateTextures(this);
-
     executeInTransaction("MaterialBrowserView::createTextures", [&]() {
-        create->execute(assetPaths, AddTextureMode::Texture, m_sceneId);
+        CreateTexture(this).execute(assetPaths, AddTextureMode::Texture, m_sceneId);
     });
-
-    create->deleteLater();
 }
 
 void MaterialBrowserView::modelAttached(Model *model)
@@ -741,11 +739,10 @@ void MaterialBrowserView::applyTextureToProperty(const QString &matId, const QSt
 {
     executeInTransaction(__FUNCTION__, [&] {
         if (m_appliedTextureId.isEmpty() && !m_appliedTexturePath.isEmpty()) {
-            auto texCreator = new CreateTexture(this);
+            CreateTexture texCreator(this);
-            ModelNode tex = texCreator->execute(m_appliedTexturePath, AddTextureMode::Texture);
+            ModelNode tex = texCreator.execute(m_appliedTexturePath, AddTextureMode::Texture);
             m_appliedTextureId = tex.id();
             m_appliedTexturePath.clear();
-            texCreator->deleteLater();
         }
 
         QTC_ASSERT(!m_appliedTextureId.isEmpty(), return);

src/plugins/qmldesigner/components/materialbrowser/materialbrowserwidget.cpp

@@ -300,10 +300,8 @@ void MaterialBrowserWidget::acceptBundleTextureDropOnMaterial(int matIndex, cons
     ModelNode mat = m_materialBrowserModel->materialAt(matIndex);
     QTC_ASSERT(mat.isValid(), return);
 
-    auto *creator = new CreateTexture(m_materialBrowserView);
-
     m_materialBrowserView->executeInTransaction(__FUNCTION__, [&] {
-        ModelNode tex = creator->execute(bundleTexPath.toLocalFile());
+        ModelNode tex = CreateTexture(m_materialBrowserView).execute(bundleTexPath.toLocalFile());
         QTC_ASSERT(tex.isValid(), return);
 
         m_materialBrowserModel->selectMaterial(matIndex);
@@ -312,8 +310,6 @@ void MaterialBrowserWidget::acceptBundleTextureDropOnMaterial(int matIndex, cons
 
     if (m_materialBrowserView->model())
         m_materialBrowserView->model()->endDrag();
-
-    creator->deleteLater();
 }
 
 void MaterialBrowserWidget::acceptAssetsDrop(const QList<QUrl> &urls)
@@ -329,14 +325,12 @@ void MaterialBrowserWidget::acceptAssetsDropOnMaterial(int matIndex, const QList
     ModelNode mat = m_materialBrowserModel->materialAt(matIndex);
     QTC_ASSERT(mat.isValid(), return);
 
-    auto *creator = new CreateTexture(m_materialBrowserView);
+    QString imageSrc = Utils::findOrDefault(urls, [](const QUrl &url) {
-
+                           return Asset(url.toLocalFile()).isValidTextureSource();
-    QString imageSrc = Utils::findOrDefault(urls, [] (const QUrl &url) {
+                       }).toLocalFile();
-        return Asset(url.toLocalFile()).isValidTextureSource();
-    }).toLocalFile();
 
     m_materialBrowserView->executeInTransaction(__FUNCTION__, [&] {
-        ModelNode tex = creator->execute(imageSrc);
+        ModelNode tex = CreateTexture(m_materialBrowserView).execute(imageSrc);
         QTC_ASSERT(tex.isValid(), return);
 
         m_materialBrowserModel->selectMaterial(matIndex);
@@ -345,8 +339,6 @@ void MaterialBrowserWidget::acceptAssetsDropOnMaterial(int matIndex, const QList
 
     if (m_materialBrowserView->model())
         m_materialBrowserView->model()->endDrag();
-
-    creator->deleteLater();
 }
 
 void MaterialBrowserWidget::acceptTextureDropOnMaterial(int matIndex, const QString &texId)

src/plugins/qmldesigner/components/navigator/navigatortreemodel.h

@@ -17,7 +17,6 @@ QT_FORWARD_DECLARE_CLASS(QPixmap)
 
 namespace QmlDesigner {
 
-class CreateTextures;
 class DesignerActionManager;
 class Model;
 class ModelNode;
@@ -88,7 +87,7 @@ public:
     void updateToolTipPixmap(const ModelNode &node, const QPixmap &pixmap);
 
 signals:
-    void toolTipPixmapUpdated(const QString &id, const QPixmap &pixmap) const;
+    void toolTipPixmapUpdated(const QString &id, const QPixmap &pixmap);
 
 private:
     void moveNodesInteractive(NodeAbstractProperty &parentProperty, const QList<ModelNode> &modelNodes,
@@ -107,7 +106,6 @@ private:
     bool moveNodeToParent(const NodeAbstractProperty &targetProperty, const ModelNode &newModelNode);
 
     QPointer<NavigatorView> m_view;
-    Utils::UniqueObjectPtr<CreateTextures> m_createTextures;
     mutable QHash<ModelNode, QModelIndex> m_nodeIndexHash;
     mutable QHash<ModelNode, QList<ModelNode> > m_rowCache;
     bool m_showOnlyVisibleItems = true;

src/plugins/qmldesigner/components/propertyeditor/propertyeditorvalue.cpp

@@ -521,9 +521,8 @@ void PropertyEditorValue::commitDrop(const QString &dropData)
         m_modelNode.view()->executeInTransaction(__FUNCTION__, [&] {
             ModelNode texture = m_modelNode.view()->modelNodeForInternalId(dropData.toInt());
             if (!texture || !texture.metaInfo().isQtQuick3DTexture()) {
-                auto texCreator = new CreateTexture(m_modelNode.view());
+                CreateTexture texCreator(m_modelNode.view());
-                texture = texCreator->execute(dropData, AddTextureMode::Texture);
+                texture = texCreator.execute(dropData, AddTextureMode::Texture);
-                texCreator->deleteLater();
             }
 
             // assign the texture to the property

src/plugins/qmldesigner/components/textureeditor/textureeditorview.cpp

@@ -58,7 +58,6 @@ TextureEditorView::TextureEditorView(AsynchronousImageCache &imageCache,
     : AbstractView{externalDependencies}
     , m_imageCache(imageCache)
     , m_stackedWidget(new QStackedWidget)
-    , m_createTexture(new CreateTexture(this))
     , m_dynamicPropertiesModel(new DynamicPropertiesModel(true, this))
 {
     m_updateShortcut = new QShortcut(QKeySequence(Qt::CTRL | Qt::Key_F12), m_stackedWidget);
@@ -399,7 +398,7 @@ void TextureEditorView::handleToolBarAction(int action)
     case TextureEditorContextObject::AddNewTexture: {
         if (!model())
             break;
-        m_createTexture->execute();
+        CreateTexture(this).execute();
         break;
     }
 
@@ -845,7 +844,7 @@ void TextureEditorView::importsChanged([[maybe_unused]] const Imports &addedImpo
 void TextureEditorView::duplicateTexture(const ModelNode &texture)
 {
     QTC_ASSERT(texture.isValid(), return);
-    m_createTexture->execute(texture);
+    CreateTexture(this).execute(texture);
 }
 
 void TextureEditorView::customNotification([[maybe_unused]] const AbstractView *view,

src/plugins/qmldesigner/components/textureeditor/textureeditorview.h

@@ -18,7 +18,6 @@ QT_END_NAMESPACE
 
 namespace QmlDesigner {
 
-class CreateTexture;
 class DynamicPropertiesModel;
 class ModelNode;
 class QmlObjectNode;
@@ -126,7 +125,6 @@ private:
     bool m_selectedTextureChanged = false;
 
     QPointer<QColorDialog> m_colorDialog;
-    QPointer<CreateTexture> m_createTexture;
     DynamicPropertiesModel *m_dynamicPropertiesModel = nullptr;
 };