QmlDesigner: Remove NodeMetaInfo::typeName() usage

The project storage is using the imports of a document to get the type.
So it is not using qualified types and gets the version from the imports.
After we switch all three methods will be removed.

Task-number: QDS-10266
Change-Id: Ic127a3bb6bd6f559457b3ce6a8631774359259a5
Reviewed-by: Thomas Hartmann <thomas.hartmann@qt.io>
Reviewed-by: Miikka Heikkinen <miikka.heikkinen@qt.io>

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

@@ -592,9 +592,9 @@ QList<SlotList> getSlotsLists(const ModelNode &node)
 ModelNode createNewConnection(ModelNode targetNode)
 {
     NodeMetaInfo connectionsMetaInfo = targetNode.view()->model()->qtQuickConnectionsMetaInfo();
-    ModelNode newConnectionNode = targetNode.view()->createModelNode(connectionsMetaInfo.typeName(),
+    const auto typeName = useProjectStorage() ? "Connections" : "QtQuick.Connections";
-                                                                     connectionsMetaInfo.majorVersion(),
+    ModelNode newConnectionNode = targetNode.view()->createModelNode(
-                                                                     connectionsMetaInfo.minorVersion());
+        typeName, connectionsMetaInfo.majorVersion(), connectionsMetaInfo.minorVersion());
     if (QmlItemNode::isValidQmlItemNode(targetNode)) {
         targetNode.nodeAbstractProperty("data").reparentHere(newConnectionNode);
     } else {
@@ -891,14 +891,18 @@ public:
         NodeMetaInfo elementMetaInfo = view->model()->metaInfo("ListElement");
 
         ListModelEditorModel model{[&] {
-                                       return view->createModelNode(modelMetaInfo.typeName(),
+                                       return view->createModelNode(useProjectStorage()
+                                                                        ? "ListModel"
+                                                                        : "QtQml.Models.ListModel",
                                                                     modelMetaInfo.majorVersion(),
                                                                     modelMetaInfo.minorVersion());
                                    },
                                    [&] {
-                                       return view->createModelNode(elementMetaInfo.typeName(),
+                                       return view->createModelNode(
-                                                                    elementMetaInfo.majorVersion(),
+                                           useProjectStorage() ? "ListElement"
-                                                                    elementMetaInfo.minorVersion());
+                                                               : "QtQml.Models.ListElement",
+                                           elementMetaInfo.majorVersion(),
+                                           elementMetaInfo.minorVersion());
                                    },
                                    [&](const ModelNode &node) {
                                        bool isNowInComponent = ModelNodeOperations::goIntoComponent(

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

@@ -1205,21 +1205,20 @@ void addFlowEffect(const SelectionContext &selectionContext, const TypeName &typ
    NodeMetaInfo effectMetaInfo = view->model()->metaInfo("FlowView." + typeName, -1, -1);
    QTC_ASSERT(typeName == "None" || effectMetaInfo.isValid(), return);
 
-   view->executeInTransaction("DesignerActionManager:addFlowEffect",
+   view->executeInTransaction("DesignerActionManager:addFlowEffect", [=]() {
-                              [view, container, effectMetaInfo](){
+       if (container.hasProperty("effect"))
+           container.removeProperty("effect");
 
-                                  if (container.hasProperty("effect"))
+       if (effectMetaInfo.isQtObject()) {
-                                      container.removeProperty("effect");
+           ModelNode effectNode = view->createModelNode(useProjectStorage()
+                                                            ? typeName
+                                                            : effectMetaInfo.typeName(),
+                                                        effectMetaInfo.majorVersion(),
+                                                        effectMetaInfo.minorVersion());
 
-                                  if (effectMetaInfo.isQtObject()) {
+           container.nodeProperty("effect").reparentHere(effectNode);
-                                      ModelNode effectNode =
+           view->setSelectedModelNode(effectNode);
-                                          view->createModelNode(effectMetaInfo.typeName(),
+       }
-                                                                effectMetaInfo.majorVersion(),
-                                                                effectMetaInfo.minorVersion());
-
-                                      container.nodeProperty("effect").reparentHere(effectNode);
-                                      view->setSelectedModelNode(effectNode);
-                                  }
    });
 }
 
@@ -1404,21 +1403,20 @@ void addCustomFlowEffect(const SelectionContext &selectionContext)
     NodeMetaInfo effectMetaInfo = view->model()->metaInfo(typeName, -1, -1);
     QTC_ASSERT(typeName == "None" || effectMetaInfo.isValid(), return);
 
-    view->executeInTransaction("DesignerActionManager:addFlowEffect",
+    view->executeInTransaction("DesignerActionManager:addFlowEffect", [=]() {
-                               [view, container, effectMetaInfo](){
+        if (container.hasProperty("effect"))
+            container.removeProperty("effect");
 
-                                   if (container.hasProperty("effect"))
+        if (effectMetaInfo.isValid()) {
-                                       container.removeProperty("effect");
+            ModelNode effectNode = view->createModelNode(useProjectStorage()
+                                                             ? typeName
+                                                             : effectMetaInfo.typeName(),
+                                                         effectMetaInfo.majorVersion(),
+                                                         effectMetaInfo.minorVersion());
 
-                                   if (effectMetaInfo.isValid()) {
+            container.nodeProperty("effect").reparentHere(effectNode);
-                                       ModelNode effectNode =
+            view->setSelectedModelNode(effectNode);
-                                           view->createModelNode(effectMetaInfo.typeName(),
+        }
-                                                                 effectMetaInfo.majorVersion(),
-                                                                 effectMetaInfo.minorVersion());
-
-                                       container.nodeProperty("effect").reparentHere(effectNode);
-                                       view->setSelectedModelNode(effectNode);
-                                   }
     });
 }
 

src/plugins/qmldesigner/components/connectioneditor/backendmodel.cpp

@@ -232,7 +232,11 @@ void BackendModel::addNewBackend()
                 int majorVersion = metaInfo.majorVersion();
 
                 if (dialog.localDefinition()) {
-                    ModelNode newNode = m_connectionView->createModelNode(metaInfo.typeName(), majorVersion, minorVersion);
+                    ModelNode newNode = m_connectionView->createModelNode(useProjectStorage()
+                                                                              ? typeName.toUtf8()
+                                                                              : metaInfo.typeName(),
+                                                                          majorVersion,
+                                                                          minorVersion);
 
                     m_connectionView->rootModelNode().nodeProperty(propertyName.toUtf8()).setDynamicTypeNameAndsetModelNode(
                                 typeName.toUtf8(), newNode);

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

@@ -209,7 +209,11 @@ void ContentLibraryBundleImporter::handleImportTimer()
         if (isImport == typeComplete) {
             m_pendingTypes.remove(pendingType);
             if (isImport)
+#ifdef QDS_USE_PROJECTSTORAGE
+                emit importFinished(pendingType.toUtf8());
+#else
                 emit importFinished(metaInfo);
+#endif
             else
                 emit unimportFinished(metaInfo);
         }

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

@@ -35,7 +35,11 @@ signals:
     // The metaInfo parameter will be invalid if an error was encountered during
     // asynchronous part of the import. In this case all remaining pending imports have been
     // terminated, and will not receive separate importFinished notifications.
+#ifdef QDS_USE_PROJECTSTORAGE
+    void importFinished(const QmlDesigner::TypeName &typeName);
+#else
     void importFinished(const QmlDesigner::NodeMetaInfo &metaInfo);
+#endif
     void unimportFinished(const QmlDesigner::NodeMetaInfo &metaInfo);
 
 private:

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

@@ -92,13 +92,27 @@ void ContentLibraryEffectsModel::createImporter(const QString &bundlePath, const
                                                 const QStringList &sharedFiles)
 {
     m_importer = new Internal::ContentLibraryBundleImporter(bundlePath, bundleId, sharedFiles);
-    connect(m_importer, &Internal::ContentLibraryBundleImporter::importFinished, this,
+#ifdef QDS_USE_PROJECTSTORAGE
+    connect(m_importer,
+            &Internal::ContentLibraryBundleImporter::importFinished,
+            this,
+            [&](const QmlDesigner::TypeName &typeName) {
+                m_importerRunning = false;
+                emit importerRunningChanged();
+                if (typeName.size())
+                    emit bundleItemImported(typeName);
+            });
+#else
+    connect(m_importer,
+            &Internal::ContentLibraryBundleImporter::importFinished,
+            this,
             [&](const QmlDesigner::NodeMetaInfo &metaInfo) {
                 m_importerRunning = false;
                 emit importerRunningChanged();
                 if (metaInfo.isValid())
                     emit bundleItemImported(metaInfo);
             });
+#endif
 
     connect(m_importer, &Internal::ContentLibraryBundleImporter::unimportFinished, this,
             [&](const QmlDesigner::NodeMetaInfo &metaInfo) {

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

@@ -57,7 +57,11 @@ public:
 signals:
     void isEmptyChanged();
     void hasRequiredQuick3DImportChanged();
+#ifdef QDS_USE_PROJECTSTORAGE
+    void bundleItemImported(const QmlDesigner::TypeName &typeName);
+#else
     void bundleItemImported(const QmlDesigner::NodeMetaInfo &metaInfo);
+#endif
     void bundleItemAboutToUnimport(const QmlDesigner::TypeName &type);
     void bundleItemUnimported(const QmlDesigner::NodeMetaInfo &metaInfo);
     void importerRunningChanged();

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

@@ -206,13 +206,27 @@ void ContentLibraryMaterialsModel::createImporter(const QString &bundlePath, con
                                                   const QStringList &sharedFiles)
 {
     m_importer = new Internal::ContentLibraryBundleImporter(bundlePath, bundleId, sharedFiles);
-    connect(m_importer, &Internal::ContentLibraryBundleImporter::importFinished, this,
+#ifdef QDS_USE_PROJECTSTORAGE
+    connect(m_importer,
+            &Internal::ContentLibraryBundleImporter::importFinished,
+            this,
+            [&](const QmlDesigner::TypeName &typeName) {
+                m_importerRunning = false;
+                emit importerRunningChanged();
+                if (typeName.size())
+                    emit bundleMaterialImported(typeName);
+            });
+#else
+    connect(m_importer,
+            &Internal::ContentLibraryBundleImporter::importFinished,
+            this,
             [&](const QmlDesigner::NodeMetaInfo &metaInfo) {
                 m_importerRunning = false;
                 emit importerRunningChanged();
                 if (metaInfo.isValid())
                     emit bundleMaterialImported(metaInfo);
             });
+#endif
 
     connect(m_importer, &Internal::ContentLibraryBundleImporter::unimportFinished, this,
             [&](const QmlDesigner::NodeMetaInfo &metaInfo) {

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

@@ -64,7 +64,11 @@ signals:
     void hasModelSelectionChanged();
     void materialVisibleChanged();
     void applyToSelectedTriggered(QmlDesigner::ContentLibraryMaterial *mat, bool add = false);
+#ifdef QDS_USE_PROJECTSTORAGE
+    void bundleMaterialImported(const QmlDesigner::TypeName &typeName);
+#else
     void bundleMaterialImported(const QmlDesigner::NodeMetaInfo &metaInfo);
+#endif
     void bundleMaterialAboutToUnimport(const QmlDesigner::TypeName &type);
     void bundleMaterialUnimported(const QmlDesigner::NodeMetaInfo &metaInfo);
     void importerRunningChanged();

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

@@ -79,26 +79,40 @@ WidgetInfo ContentLibraryView::widgetInfo()
 
         ContentLibraryMaterialsModel *materialsModel = m_widget->materialsModel().data();
 
-        connect(materialsModel, &ContentLibraryMaterialsModel::applyToSelectedTriggered, this,
+        connect(materialsModel,
-                [&] (ContentLibraryMaterial *bundleMat, bool add) {
+                &ContentLibraryMaterialsModel::applyToSelectedTriggered,
-            if (m_selectedModels.isEmpty())
+                this,
-                return;
+                [&](ContentLibraryMaterial *bundleMat, bool add) {
+                    if (m_selectedModels.isEmpty())
+                        return;
 
-            m_bundleMaterialTargets = m_selectedModels;
+                    m_bundleMaterialTargets = m_selectedModels;
-            m_bundleMaterialAddToSelected = add;
+                    m_bundleMaterialAddToSelected = add;
 
-            ModelNode defaultMat = getBundleMaterialDefaultInstance(bundleMat->type());
+                    ModelNode defaultMat = getBundleMaterialDefaultInstance(bundleMat->type());
-            if (defaultMat.isValid())
+                    if (defaultMat.isValid())
-                applyBundleMaterialToDropTarget(defaultMat);
+                        applyBundleMaterialToDropTarget(defaultMat);
-            else
+                    else
-                m_widget->materialsModel()->addToProject(bundleMat);
+                        m_widget->materialsModel()->addToProject(bundleMat);
-        });
+                });
 
-        connect(materialsModel, &ContentLibraryMaterialsModel::bundleMaterialImported, this,
+#ifdef QDS_USE_PROJECTSTORAGE
-                [&] (const QmlDesigner::NodeMetaInfo &metaInfo) {
+        connect(materialsModel,
-            applyBundleMaterialToDropTarget({}, metaInfo);
+                &ContentLibraryMaterialsModel::bundleMaterialImported,
-            updateBundleMaterialsImportedState();
+                this,
-        });
+                [&](const QmlDesigner::TypeName &typeName) {
+                    applyBundleMaterialToDropTarget({}, typeName);
+                    updateBundleMaterialsImportedState();
+                });
+#else
+        connect(materialsModel,
+                &ContentLibraryMaterialsModel::bundleMaterialImported,
+                this,
+                [&](const QmlDesigner::NodeMetaInfo &metaInfo) {
+                    applyBundleMaterialToDropTarget({}, metaInfo);
+                    updateBundleMaterialsImportedState();
+                });
+#endif
 
         connect(materialsModel, &ContentLibraryMaterialsModel::bundleMaterialAboutToUnimport, this,
                 [&] (const QmlDesigner::TypeName &type) {
@@ -120,30 +134,61 @@ WidgetInfo ContentLibraryView::widgetInfo()
 
         ContentLibraryEffectsModel *effectsModel = m_widget->effectsModel().data();
 
-        connect(effectsModel, &ContentLibraryEffectsModel::bundleItemImported, this,
+#ifdef QDS_USE_PROJECTSTORAGE
-                [&] (const QmlDesigner::NodeMetaInfo &metaInfo) {
+        connect(effectsModel,
-            QTC_ASSERT(metaInfo.isValid(), return);
+                &ContentLibraryEffectsModel::bundleItemImported,
+                this,
+                [&](const QmlDesigner::TypeName &typeName) {
+                    QTC_ASSERT(typeName.size(), return);
 
-            if (!m_bundleEffectTarget)
+                    if (!m_bundleEffectTarget)
-                m_bundleEffectTarget = active3DSceneNode();
+                        m_bundleEffectTarget = active3DSceneNode();
 
-            QTC_ASSERT(m_bundleEffectTarget, return);
+                    QTC_ASSERT(m_bundleEffectTarget, return);
 
-            executeInTransaction("ContentLibraryView::widgetInfo", [&] {
+                    executeInTransaction("ContentLibraryView::widgetInfo", [&] {
-                QVector3D pos = m_bundleEffectPos.value<QVector3D>();
+                        QVector3D pos = m_bundleEffectPos.value<QVector3D>();
-                ModelNode newEffNode = createModelNode(metaInfo.typeName(), metaInfo.majorVersion(),
+                        ModelNode newEffNode = createModelNode(
-                                                       metaInfo.minorVersion(),
+                            typeName, -1, -1, {{"x", pos.x()}, {"y", pos.y()}, {"z", pos.z()}});
-                                                       {{"x", pos.x()}, {"y", pos.y()}, {"z", pos.z()}});
+                        m_bundleEffectTarget.defaultNodeListProperty().reparentHere(newEffNode);
-                m_bundleEffectTarget.defaultNodeListProperty().reparentHere(newEffNode);
+                        clearSelectedModelNodes();
-                clearSelectedModelNodes();
+                        selectModelNode(newEffNode);
-                selectModelNode(newEffNode);
+                    });
-            });
 
-            updateBundleEffectsImportedState();
+                    updateBundleEffectsImportedState();
-            m_bundleEffectTarget = {};
+                    m_bundleEffectTarget = {};
-            m_bundleEffectPos = {};
+                    m_bundleEffectPos = {};
-        });
+                });
+#else
+        connect(effectsModel,
+                &ContentLibraryEffectsModel::bundleItemImported,
+                this,
+                [&](const QmlDesigner::NodeMetaInfo &metaInfo) {
+                    QTC_ASSERT(metaInfo.isValid(), return);
 
+                    if (!m_bundleEffectTarget)
+                        m_bundleEffectTarget = active3DSceneNode();
+
+                    QTC_ASSERT(m_bundleEffectTarget, return);
+
+                    executeInTransaction("ContentLibraryView::widgetInfo", [&] {
+                        QVector3D pos = m_bundleEffectPos.value<QVector3D>();
+                        ModelNode newEffNode = createModelNode(metaInfo.typeName(),
+                                                               metaInfo.majorVersion(),
+                                                               metaInfo.minorVersion(),
+                                                               {{"x", pos.x()},
+                                                                {"y", pos.y()},
+                                                                {"z", pos.z()}});
+                        m_bundleEffectTarget.defaultNodeListProperty().reparentHere(newEffNode);
+                        clearSelectedModelNodes();
+                        selectModelNode(newEffNode);
+                    });
+
+                    updateBundleEffectsImportedState();
+                    m_bundleEffectTarget = {};
+                    m_bundleEffectPos = {};
+                });
+#endif
         connect(effectsModel, &ContentLibraryEffectsModel::bundleItemAboutToUnimport, this,
                 [&] (const QmlDesigner::TypeName &type) {
                     // delete instances of the bundle effect that is about to be unimported
@@ -230,8 +275,10 @@ void ContentLibraryView::selectedNodesChanged(const QList<ModelNode> &selectedNo
     m_widget->materialsModel()->setHasModelSelection(!m_selectedModels.isEmpty());
 }
 
-void ContentLibraryView::customNotification(const AbstractView *view, const QString &identifier,
+void ContentLibraryView::customNotification(const AbstractView *view,
-                                            const QList<ModelNode> &nodeList, const QList<QVariant> &data)
+                                            const QString &identifier,
+                                            const QList<ModelNode> &nodeList,
+                                            const QList<QVariant> &data)
 {
     Q_UNUSED(data)
 
@@ -248,7 +295,11 @@ void ContentLibraryView::customNotification(const AbstractView *view, const QStr
         ModelNode defaultMat = getBundleMaterialDefaultInstance(m_draggedBundleMaterial->type());
         if (defaultMat.isValid()) {
             if (m_bundleMaterialTargets.isEmpty()) // if no drop target, create a duplicate material
+#ifdef QDS_USE_PROJECTSTORAGE
+                createMaterial(m_draggedBundleMaterial->type());
+#else
                 createMaterial(defaultMat.metaInfo());
+#endif
             else
                 applyBundleMaterialToDropTarget(defaultMat);
         } else {
@@ -256,7 +307,7 @@ void ContentLibraryView::customNotification(const AbstractView *view, const QStr
         }
 
         m_draggedBundleMaterial = nullptr;
-    } else  if (identifier == "drop_bundle_texture") {
+    } else if (identifier == "drop_bundle_texture") {
         ModelNode matLib = materialLibraryNode();
         if (!matLib.isValid())
             return;
@@ -288,6 +339,57 @@ void ContentLibraryView::nodeAboutToBeRemoved(const ModelNode &removedNode)
         m_widget->setHasMaterialLibrary(false);
 }
 
+#ifdef QDS_USE_PROJECTSTORAGE
+void ContentLibraryView::applyBundleMaterialToDropTarget(const ModelNode &bundleMat,
+                                                         const TypeName &typeName)
+{
+    if (!bundleMat.isValid() && !typeName.size())
+        return;
+
+    executeInTransaction("ContentLibraryView::applyBundleMaterialToDropTarget", [&] {
+        ModelNode newMatNode = typeName.size() ? createMaterial(typeName) : bundleMat;
+
+        // TODO: unify this logic as it exist elsewhere also
+        auto expToList = [](const QString &exp) {
+            QString copy = exp;
+            copy = copy.remove("[").remove("]");
+
+            QStringList tmp = copy.split(',', Qt::SkipEmptyParts);
+            for (QString &str : tmp)
+                str = str.trimmed();
+
+            return tmp;
+        };
+
+        auto listToExp = [](QStringList &stringList) {
+            if (stringList.size() > 1)
+                return QString("[" + stringList.join(",") + "]");
+
+            if (stringList.size() == 1)
+                return stringList.first();
+
+            return QString();
+        };
+
+        for (const ModelNode &target : std::as_const(m_bundleMaterialTargets)) {
+            if (target.isValid() && target.metaInfo().isQtQuick3DModel()) {
+                QmlObjectNode qmlObjNode(target);
+                if (m_bundleMaterialAddToSelected) {
+                    QStringList matList = expToList(qmlObjNode.expression("materials"));
+                    matList.append(newMatNode.id());
+                    QString updatedExp = listToExp(matList);
+                    qmlObjNode.setBindingProperty("materials", updatedExp);
+                } else {
+                    qmlObjNode.setBindingProperty("materials", newMatNode.id());
+                }
+            }
+
+            m_bundleMaterialTargets = {};
+            m_bundleMaterialAddToSelected = false;
+        }
+    });
+}
+#else
 void ContentLibraryView::applyBundleMaterialToDropTarget(const ModelNode &bundleMat,
                                                          const NodeMetaInfo &metaInfo)
 {
@@ -337,6 +439,7 @@ void ContentLibraryView::applyBundleMaterialToDropTarget(const ModelNode &bundle
         }
     });
 }
+#endif
 
 ModelNode ContentLibraryView::getBundleMaterialDefaultInstance(const TypeName &type)
 {
@@ -344,7 +447,7 @@ ModelNode ContentLibraryView::getBundleMaterialDefaultInstance(const TypeName &t
     if (!matLib.isValid())
         return {};
 
-    const QList <ModelNode> matLibNodes = matLib.directSubModelNodes();
+    const QList<ModelNode> matLibNodes = matLib.directSubModelNodes();
     for (const ModelNode &mat : matLibNodes) {
         if (mat.isValid() && mat.type() == type) {
             bool isDefault = true;
@@ -363,15 +466,40 @@ ModelNode ContentLibraryView::getBundleMaterialDefaultInstance(const TypeName &t
 
     return {};
 }
+#ifdef QDS_USE_PROJECTSTORAGE
+ModelNode ContentLibraryView::createMaterial(const TypeName &typeName)
+{
+    ModelNode matLib = materialLibraryNode();
+    if (!matLib.isValid() || !typeName.size())
+        return {};
 
+    ModelNode newMatNode = createModelNode(typeName, -1, -1);
+    matLib.defaultNodeListProperty().reparentHere(newMatNode);
+
+    static QRegularExpression rgx("([A-Z])([a-z]*)");
+    QString newName = QString::fromUtf8(typeName).replace(rgx, " \\1\\2").trimmed();
+    if (newName.endsWith(" Material"))
+        newName.chop(9); // remove trailing " Material"
+    QString newId = model()->generateIdFromName(newName, "material");
+    newMatNode.setIdWithRefactoring(newId);
+
+    VariantProperty objNameProp = newMatNode.variantProperty("objectName");
+    objNameProp.setValue(newName);
+
+    emitCustomNotification("focus_material_section", {});
+
+    return newMatNode;
+}
+#else
 ModelNode ContentLibraryView::createMaterial(const NodeMetaInfo &metaInfo)
 {
     ModelNode matLib = materialLibraryNode();
     if (!matLib.isValid() || !metaInfo.isValid())
         return {};
 
-    ModelNode newMatNode = createModelNode(metaInfo.typeName(), metaInfo.majorVersion(),
+    ModelNode newMatNode = createModelNode(metaInfo.typeName(),
-                                                                metaInfo.minorVersion());
+                                           metaInfo.majorVersion(),
+                                           metaInfo.minorVersion());
     matLib.defaultNodeListProperty().reparentHere(newMatNode);
 
     static QRegularExpression rgx("([A-Z])([a-z]*)");
@@ -388,6 +516,7 @@ ModelNode ContentLibraryView::createMaterial(const NodeMetaInfo &metaInfo)
 
     return newMatNode;
 }
+#endif
 
 void ContentLibraryView::updateBundleMaterialsImportedState()
 {
@@ -432,7 +561,7 @@ void ContentLibraryView::updateBundlesQuick3DVersion()
     bool hasImport = false;
     int major = -1;
     int minor = -1;
-    const QString url {"QtQuick3D"};
+    const QString url{"QtQuick3D"};
     const auto imports = model()->imports();
     for (const auto &import : imports) {
         if (import.url() == url) {

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

@@ -47,10 +47,18 @@ private:
     void updateBundleMaterialsImportedState();
     void updateBundleEffectsImportedState();
     void updateBundlesQuick3DVersion();
-    void applyBundleMaterialToDropTarget(const ModelNode &bundleMat, const NodeMetaInfo &metaInfo = {});
+#ifdef QDS_USE_PROJECTSTORAGE
+    void applyBundleMaterialToDropTarget(const ModelNode &bundleMat, const TypeName &typeName = {});
+#else
+    void applyBundleMaterialToDropTarget(const ModelNode &bundleMat,
+                                         const NodeMetaInfo &metaInfo = {});
+#endif
     ModelNode getBundleMaterialDefaultInstance(const TypeName &type);
+#ifdef QDS_USE_PROJECTSTORAGE
+    ModelNode createMaterial(const TypeName &typeName);
+#else
     ModelNode createMaterial(const NodeMetaInfo &metaInfo);
-
+#endif
     QPointer<ContentLibraryWidget> m_widget;
     QList<ModelNode> m_bundleMaterialTargets;
     ModelNode m_bundleEffectTarget; // target of the dropped bundle effect

src/plugins/qmldesigner/components/eventlist/eventlist.cpp

@@ -186,12 +186,15 @@ void EventList::initialize(EventListPluginView *parent)
     if (!m_model) {
         QByteArray unqualifiedTypeName = "ListModel";
         auto metaInfo = parent->model()->metaInfo(unqualifiedTypeName);
-
+#ifdef QDS_USE_PROJECTSTORAGE
+        m_model = Model::create(unqualifiedTypeName, -1, -1);
+#else
         QByteArray fullTypeName = metaInfo.typeName();
         int minorVersion = metaInfo.minorVersion();
         int majorVersion = metaInfo.majorVersion();
 
         m_model = Model::create(fullTypeName, majorVersion, minorVersion);
+#endif
         m_model->setParent(parent);
     }
 

src/plugins/qmldesigner/components/eventlist/eventlistview.cpp

@@ -85,6 +85,9 @@ void EventListView::addEvent(const Event &event)
     executeInTransaction("EventListView::addEvent", [=]() {
 
         QByteArray unqualifiedTypeName = "ListElement";
+#ifdef QDS_USE_PROJECTSTORAGE
+        ModelNode eventNode = createModelNode(unqualifiedTypeName, -1, -1);
+#else
         auto metaInfo = model()->metaInfo(unqualifiedTypeName);
 
         QByteArray fullTypeName = metaInfo.typeName();
@@ -92,6 +95,7 @@ void EventListView::addEvent(const Event &event)
         int majorVersion = metaInfo.majorVersion();
 
         ModelNode eventNode = createModelNode(fullTypeName, majorVersion, minorVersion);
+#endif
         eventNode.variantProperty("eventId").setValue(event.eventId);
 
         if (!event.shortcut.isEmpty())

src/plugins/qmldesigner/components/materialeditor/materialeditorcontextobject.cpp

@@ -233,11 +233,19 @@ void MaterialEditorContextObject::changeTypeName(const QString &typeName)
             }
         }
 
+#ifdef QDS_USE_PROJECTSTORAGE
+        if (m_selectedMaterial.isRootNode())
+            rewriterView->changeRootNodeType(typeName.toUtf8(), -1, -1);
+        else
+            m_selectedMaterial.changeType(typeName.toUtf8(), -1, -1);
+#else
         if (m_selectedMaterial.isRootNode())
             rewriterView->changeRootNodeType(metaInfo.typeName(), metaInfo.majorVersion(), metaInfo.minorVersion());
         else
-            m_selectedMaterial.changeType(metaInfo.typeName(), metaInfo.majorVersion(), metaInfo.minorVersion());
+            m_selectedMaterial.changeType(metaInfo.typeName(),
-
+                                          metaInfo.majorVersion(),
+                                          metaInfo.minorVersion());
+#endif
         for (const auto &key : copyKeys) {
             const CopyData &copyData = copyMap[key];
             if (copyData.isBinding)

src/plugins/qmldesigner/components/materialeditor/materialeditorview.cpp

@@ -197,13 +197,13 @@ void MaterialEditorView::changeExpression(const QString &propertyName)
         }
 
         if (auto property = m_selectedMaterial.metaInfo().property(name)) {
-            auto propertyTypeName = property.propertyType().typeName();
+            auto propertyType = property.propertyType();
-            if (propertyTypeName == "QColor") {
+            if (propertyType.isColor()) {
                 if (QColor(value->expression().remove('"')).isValid()) {
                     qmlObjectNode.setVariantProperty(name, QColor(value->expression().remove('"')));
                     return;
                 }
-            } else if (propertyTypeName == "bool") {
+            } else if (propertyType.isBool()) {
                 if (isTrueFalseLiteral(value->expression())) {
                     if (value->expression().compare("true", Qt::CaseInsensitive) == 0)
                         qmlObjectNode.setVariantProperty(name, true);
@@ -211,21 +211,21 @@ void MaterialEditorView::changeExpression(const QString &propertyName)
                         qmlObjectNode.setVariantProperty(name, false);
                     return;
                 }
-            } else if (propertyTypeName == "int") {
+            } else if (propertyType.isInteger()) {
                 bool ok;
                 int intValue = value->expression().toInt(&ok);
                 if (ok) {
                     qmlObjectNode.setVariantProperty(name, intValue);
                     return;
                 }
-            } else if (propertyTypeName == "qreal") {
+            } else if (propertyType.isFloat()) {
                 bool ok;
                 qreal realValue = value->expression().toDouble(&ok);
                 if (ok) {
                     qmlObjectNode.setVariantProperty(name, realValue);
                     return;
                 }
-            } else if (propertyTypeName == "QVariant") {
+            } else if (propertyType.isVariant()) {
                 bool ok;
                 qreal realValue = value->expression().toDouble(&ok);
                 if (ok) {

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

@@ -272,11 +272,17 @@ void PropertyEditorContextObject::changeTypeName(const QString &typeName)
                 selectedNode.removeProperty(p);
         }
 
+#ifdef QDS_USE_PROJECTSTORAGE
+        if (selectedNode.isRootNode())
+            rewriterView->changeRootNodeType(typeName.toUtf8(), -1, -1);
+        else
+            selectedNode.changeType(typeName.toUtf8(), -1, -1);
+#else
         if (selectedNode.isRootNode())
             rewriterView->changeRootNodeType(metaInfo.typeName(), metaInfo.majorVersion(), metaInfo.minorVersion());
         else
             selectedNode.changeType(metaInfo.typeName(), metaInfo.majorVersion(), metaInfo.minorVersion());
-
+#endif
         transaction.commit();
     } catch (const Exception &e) {
         e.showException();

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

@@ -187,13 +187,13 @@ void TextureEditorView::changeExpression(const QString &propertyName)
         }
 
         if (auto property = m_selectedTexture.metaInfo().property(name)) {
-            auto propertyTypeName = property.propertyType().typeName();
+            auto propertyType = property.propertyType();
-            if (propertyTypeName == "QColor") {
+            if (propertyType.isColor()) {
                 if (QColor(value->expression().remove('"')).isValid()) {
                     qmlObjectNode.setVariantProperty(name, QColor(value->expression().remove('"')));
                     return;
                 }
-            } else if (propertyTypeName == "bool") {
+            } else if (propertyType.isBool()) {
                 if (isTrueFalseLiteral(value->expression())) {
                     if (value->expression().compare("true", Qt::CaseInsensitive) == 0)
                         qmlObjectNode.setVariantProperty(name, true);
@@ -201,21 +201,21 @@ void TextureEditorView::changeExpression(const QString &propertyName)
                         qmlObjectNode.setVariantProperty(name, false);
                     return;
                 }
-            } else if (propertyTypeName == "int") {
+            } else if (propertyType.isInteger()) {
                 bool ok;
                 int intValue = value->expression().toInt(&ok);
                 if (ok) {
                     qmlObjectNode.setVariantProperty(name, intValue);
                     return;
                 }
-            } else if (propertyTypeName == "qreal") {
+            } else if (propertyType.isFloat()) {
                 bool ok;
                 qreal realValue = value->expression().toDouble(&ok);
                 if (ok) {
                     qmlObjectNode.setVariantProperty(name, realValue);
                     return;
                 }
-            } else if (propertyTypeName == "QVariant") {
+            } else if (propertyType.isVariant()) {
                 bool ok;
                 qreal realValue = value->expression().toDouble(&ok);
                 if (ok) {

src/plugins/qmldesigner/designercore/model/abstractview.cpp

@@ -787,12 +787,16 @@ void AbstractView::ensureMaterialLibraryNode()
     }
 
     executeInTransaction(__FUNCTION__, [&] {
-        // Create material library node
+    // Create material library node
+#ifdef QDS_USE_PROJECTSTORAGE
+        TypeName nodeTypeName = rootModelNode().metaInfo().isQtQuick3DNode() ? "Node" : "Item";
+        matLib = createModelNode(nodeTypeName, -1, -1);
+#else
         auto nodeType = rootModelNode().metaInfo().isQtQuick3DNode()
                             ? model()->qtQuick3DNodeMetaInfo()
                             : model()->qtQuickItemMetaInfo();
         matLib = createModelNode(nodeType.typeName(), nodeType.majorVersion(), nodeType.minorVersion());
-
+#endif
         matLib.setIdWithoutRefactoring(Constants::MATERIAL_LIB_ID);
         rootModelNode().defaultNodeListProperty().reparentHere(matLib);
     });
@@ -928,10 +932,8 @@ static int getMajorVersionFromNode(const ModelNode &modelNode)
 {
     if (modelNode.metaInfo().isValid()) {
         for (const NodeMetaInfo &info : modelNode.metaInfo().selfAndPrototypes()) {
-            if (info.typeName() == "QtQml.QtObject" || info.typeName() == "QtQuick.QtObject"
+            if (info.isQtObject() || info.isQtQuickItem())
-                || info.typeName() == "QtQuick.Item") {
                 return info.majorVersion();
-            }
         }
     }
 
@@ -943,7 +945,7 @@ static int getMinorVersionFromNode(const ModelNode &modelNode)
     if (modelNode.metaInfo().isValid()) {
         const NodeMetaInfos infos = modelNode.metaInfo().selfAndPrototypes();
         for (const NodeMetaInfo &info :  infos) {
-            if (info.typeName() == "QtQuick.QtObject" || info.typeName() == "QtQuick.Item")
+            if (info.isQtObject() || info.isQtQuickItem())
                 return info.minorVersion();
         }
     }

src/plugins/qmldesigner/designercore/model/texttomodelmerger.cpp

@@ -1221,7 +1221,7 @@ void TextToModelMerger::syncNode(ModelNode &modelNode,
     if (defaultPropertyName.isEmpty()) //fallback and use the meta system of the model
         defaultPropertyName = modelNode.metaInfo().defaultPropertyName();
 
-    if (modelNode.isRootNode() && !m_rewriterView->allowComponentRoot() && isComponentType(typeName)) {
+    if (modelNode.isRootNode() && !m_rewriterView->allowComponentRoot() && info.isQmlComponent()) {
         for (AST::UiObjectMemberList *iter = astInitializer->members; iter; iter = iter->next) {
             if (auto def = AST::cast<AST::UiObjectDefinition *>(iter->member)) {
                 syncNode(modelNode, def, context, differenceHandler);