Add import options to asset import dialog

Available import options are queried from the importer and displayed
on the import dialog.

Change-Id: Id47dde29f41a1c91042623ebbd1156c77434e3a3
Fixes: QDS-1101
Reviewed-by: Thomas Hartmann <thomas.hartmann@qt.io>

5 files changed, 359 insertions, 27 deletions

diff --git a/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimportdialog.cpp b/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimportdialog.cpp
index 0917a22abd0..5f72ef3750c 100644
--- a/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimportdialog.cpp
+++ b/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimportdialog.cpp
@@ -30,15 +30,20 @@
 #include "model.h"
 
 #include "utils/outputformatter.h"
+#include "theme.h"
 
 #include <QtCore/qfileinfo.h>
 #include <QtCore/qdir.h>
 #include <QtCore/qloggingcategory.h>
 #include <QtCore/qtimer.h>
+#include <QtCore/qjsonarray.h>
 #include <QtWidgets/qpushbutton.h>
-#include <QtWidgets/qformlayout.h>
+#include <QtWidgets/qgridlayout.h>
 #include <QtWidgets/qlabel.h>
+#include <QtWidgets/qcheckbox.h>
+#include <QtWidgets/qspinbox.h>
 #include <QtWidgets/qscrollbar.h>
+#include <QtWidgets/qtabbar.h>
 
 namespace QmlDesigner {
 
@@ -83,8 +88,6 @@ ItemLibraryAssetImportDialog::ItemLibraryAssetImportDialog(const QStringList &im
     if (skipSome)
         addWarning("Cannot import 3D and other assets simultaneously. Skipping non-3D assets.");
 
-    // Import button will be used in near future when we add import options. Hide for now.
-    ui->buttonBox->button(QDialogButtonBox::Ok)->hide();
     ui->buttonBox->button(QDialogButtonBox::Ok)->setText(tr("Import"));
     connect(ui->buttonBox->button(QDialogButtonBox::Ok), &QPushButton::clicked,
             this, &ItemLibraryAssetImportDialog::onImport);
@@ -137,8 +140,236 @@ ItemLibraryAssetImportDialog::ItemLibraryAssetImportDialog(const QStringList &im
     }
     m_quick3DImportPath = candidatePath;
 
-    // Queue import immediately until we have some options
-    QTimer::singleShot(0, this, &ItemLibraryAssetImportDialog::onImport);
+    // Create UI controls for options
+    if (!importFiles.isEmpty()) {
+        QJsonObject supportedOptions = QJsonObject::fromVariantMap(
+                    m_importer.supportedOptions(importFiles[0]));
+        m_importOptions = supportedOptions.value("options").toObject();
+        const QJsonObject groups = supportedOptions.value("groups").toObject();
+
+        const int labelWidth = 210;
+        const int valueWidth = 75;
+        const int groupIndent = 10;
+        const int columnSpacing = 10;
+        const int rowHeight = 26;
+        int rowIndex[2] = {0, 0};
+
+        // First index has ungrouped widgets, rest are groups
+        // First item in each real group is group label
+        QVector<QVector<QPair<QWidget *, QWidget *>>> widgets;
+        QHash<QString, int> groupIndexMap;
+        QHash<QString, QPair<QWidget *, QWidget *>> optionToWidgetsMap;
+        QHash<QString, QJsonArray> conditionMap;
+        QHash<QString, QString> optionToGroupMap;
+
+        auto layout = new QGridLayout(ui->optionsAreaContents);
+        layout->setColumnMinimumWidth(0, groupIndent);
+        layout->setColumnMinimumWidth(1, labelWidth);
+        layout->setColumnMinimumWidth(2, valueWidth);
+        layout->setColumnMinimumWidth(3, columnSpacing);
+        layout->setColumnMinimumWidth(4, groupIndent);
+        layout->setColumnMinimumWidth(5, labelWidth);
+        layout->setColumnMinimumWidth(6, valueWidth);
+
+        widgets.append(QVector<QPair<QWidget *, QWidget *>>());
+
+        for (const auto group : groups) {
+            const QString name = group.toObject().value("name").toString();
+            const QJsonArray items = group.toObject().value("items").toArray();
+            for (const auto item : items)
+                optionToGroupMap.insert(item.toString(), name);
+            auto groupLabel = new QLabel(name, ui->optionsAreaContents);
+            QFont labelFont = groupLabel->font();
+            labelFont.setBold(true);
+            groupLabel->setFont(labelFont);
+            widgets.append({{groupLabel, nullptr}});
+            groupIndexMap.insert(name, widgets.size() - 1);
+        }
+
+        const auto optKeys = m_importOptions.keys();
+        for (const auto &optKey : optKeys) {
+            QJsonObject optObj = m_importOptions.value(optKey).toObject();
+            const QString optName = optObj.value("name").toString();
+            const QString optDesc = optObj.value("description").toString();
+            const QString optType = optObj.value("type").toString();
+            QJsonObject optRange = optObj.value("range").toObject();
+            QJsonValue optValue = optObj.value("value");
+            QJsonArray conditions = optObj.value("conditions").toArray();
+
+            QWidget *optControl = nullptr;
+            if (optType == "Boolean") {
+                auto *optCheck = new QCheckBox(ui->optionsAreaContents);
+                optCheck->setChecked(optValue.toBool());
+                optControl = optCheck;
+                QObject::connect(optCheck, &QCheckBox::toggled, [this, optCheck, optKey]() {
+                    QJsonObject optObj = m_importOptions.value(optKey).toObject();
+                    QJsonValue value(optCheck->isChecked());
+                    optObj.insert("value", value);
+                    m_importOptions.insert(optKey, optObj);
+                });
+            } else if (optType == "Real") {
+                auto *optSpin = new QDoubleSpinBox(ui->optionsAreaContents);
+                double min = -999999999.;
+                double max = 999999999.;
+                double step = 1.;
+                int decimals = 3;
+                if (!optRange.isEmpty()) {
+                    min = optRange.value("minimum").toDouble();
+                    max = optRange.value("maximum").toDouble();
+                    // Ensure step is reasonable for small ranges
+                    double range = max - min;
+                    while (range <= 10.) {
+                        step /= 10.;
+                        range *= 10.;
+                        if (step < 0.02)
+                            ++decimals;
+                    }
+
+                }
+                optSpin->setRange(min, max);
+                optSpin->setDecimals(decimals);
+                optSpin->setValue(optValue.toDouble());
+                optSpin->setSingleStep(step);
+                optControl = optSpin;
+                QObject::connect(optSpin, QOverload<double>::of(&QDoubleSpinBox::valueChanged),
+                                 [this, optSpin, optKey]() {
+                    QJsonObject optObj = m_importOptions.value(optKey).toObject();
+                    QJsonValue value(optSpin->value());
+                    optObj.insert("value", value);
+                    m_importOptions.insert(optKey, optObj);
+                });
+            } else {
+                qWarning() << __FUNCTION__ << "Unsupported option type:" << optType;
+                continue;
+            }
+
+            if (!conditions.isEmpty())
+                conditionMap.insert(optKey, conditions);
+
+            auto *optLabel = new QLabel(ui->optionsAreaContents);
+            optLabel->setText(optName);
+            optLabel->setToolTip(optDesc);
+            optControl->setToolTip(optDesc);
+
+            const QString &groupName = optionToGroupMap.value(optKey);
+            if (!groupName.isEmpty() && groupIndexMap.contains(groupName))
+                widgets[groupIndexMap[groupName]].append({optLabel, optControl});
+            else
+                widgets[0].append({optLabel, optControl});
+            optionToWidgetsMap.insert(optKey, {optLabel, optControl});
+        }
+
+        // Add option widgets to layout. Grouped options are added to the tops of the columns
+        for (int i = 1; i < widgets.size(); ++i) {
+            int col = rowIndex[1] < rowIndex[0] ? 1 : 0;
+            const auto &groupWidgets = widgets[i];
+            if (!groupWidgets.isEmpty()) {
+                // First widget in each group is the group label
+                layout->addWidget(groupWidgets[0].first, rowIndex[col], col * 4, 1, 3);
+                layout->setRowMinimumHeight(rowIndex[col],rowHeight);
+                ++rowIndex[col];
+                for (int j = 1; j < groupWidgets.size(); ++j) {
+                    layout->addWidget(groupWidgets[j].first, rowIndex[col], col * 4 + 1);
+                    layout->addWidget(groupWidgets[j].second, rowIndex[col], col * 4 + 2);
+                    layout->setRowMinimumHeight(rowIndex[col],rowHeight);
+                    ++rowIndex[col];
+                }
+            }
+        }
+
+        // Ungrouped options are spread evenly under the groups
+        int totalRowCount = (rowIndex[0] + rowIndex[1] + widgets[0].size() + 1) / 2;
+        for (const auto &widgets : qAsConst(widgets[0])) {
+            int col = rowIndex[0] < totalRowCount ? 0 : 1;
+            layout->addWidget(widgets.first, rowIndex[col], col * 4, 1, 2);
+            layout->addWidget(widgets.second, rowIndex[col], col * 4 + 2);
+            layout->setRowMinimumHeight(rowIndex[col],rowHeight);
+            ++rowIndex[col];
+        }
+
+        // Handle conditions
+        QHash<QString, QJsonArray>::const_iterator it = conditionMap.begin();
+        while (it != conditionMap.end()) {
+            const QString &option = it.key();
+            const QJsonArray &conditions = it.value();
+            const auto &conWidgets = optionToWidgetsMap.value(option);
+            QWidget *conLabel = conWidgets.first;
+            QWidget *conControl = conWidgets.second;
+            // Currently we only support single condition per option, though the schema allows for
+            // multiple, as no real life option currently has multiple conditions and connections
+            // get complicated if we need to comply to multiple conditions.
+            if (!conditions.isEmpty() && conLabel && conControl) {
+                const auto &conObj = conditions[0].toObject();
+                const QString optItem = conObj.value("property").toString();
+                const auto &optWidgets = optionToWidgetsMap.value(optItem);
+                const QString optMode = conObj.value("mode").toString();
+                const QVariant optValue = conObj.value("value").toVariant();
+                enum class Mode { equals, notEquals, greaterThan, lessThan };
+                Mode mode;
+                if (optMode == "NotEquals")
+                    mode = Mode::notEquals;
+                else if (optMode == "GreaterThan")
+                    mode = Mode::greaterThan;
+                else if (optMode == "LessThan")
+                    mode = Mode::lessThan;
+                else
+                    mode = Mode::equals; // Default to equals
+
+                if (optWidgets.first && optWidgets.second) {
+                    auto optCb = qobject_cast<QCheckBox *>(optWidgets.second);
+                    auto optSpin = qobject_cast<QDoubleSpinBox *>(optWidgets.second);
+                    if (optCb) {
+                        auto enableConditionally = [optValue](QCheckBox *cb, QWidget *w1,
+                                QWidget *w2, Mode mode) {
+                            bool equals = (mode == Mode::equals) == optValue.toBool();
+                            bool enable = cb->isChecked() == equals;
+                            w1->setEnabled(enable);
+                            w2->setEnabled(enable);
+                        };
+                        enableConditionally(optCb, conLabel, conControl, mode);
+                        QObject::connect(
+                                    optCb, &QCheckBox::toggled,
+                                    [optCb, conLabel, conControl, mode, enableConditionally]() {
+                            enableConditionally(optCb, conLabel, conControl, mode);
+                        });
+                    }
+                    if (optSpin) {
+                        auto enableConditionally = [optValue](QDoubleSpinBox *sb, QWidget *w1,
+                                QWidget *w2, Mode mode) {
+                            bool enable = false;
+                            double value = optValue.toDouble();
+                            if (mode == Mode::equals)
+                                enable = qFuzzyCompare(value, sb->value());
+                            else if (mode == Mode::notEquals)
+                                enable = !qFuzzyCompare(value, sb->value());
+                            else if (mode == Mode::greaterThan)
+                                enable = sb->value() > value;
+                            else if (mode == Mode::lessThan)
+                                enable = sb->value() < value;
+                            w1->setEnabled(enable);
+                            w2->setEnabled(enable);
+                        };
+                        enableConditionally(optSpin, conLabel, conControl, mode);
+                        QObject::connect(
+                                    optSpin, QOverload<double>::of(&QDoubleSpinBox::valueChanged),
+                                    [optSpin, conLabel, conControl, mode, enableConditionally]() {
+                            enableConditionally(optSpin, conLabel, conControl, mode);
+                        });
+                    }
+                }
+            }
+            ++it;
+        }
+
+        ui->optionsAreaContents->setLayout(layout);
+        ui->optionsAreaContents->resize(
+                    groupIndent * 2 + labelWidth * 2 + valueWidth * 2 + columnSpacing,
+                    rowHeight * qMax(rowIndex[0], rowIndex[1]));
+    }
+
+    ui->optionsArea->setStyleSheet("QScrollArea {background-color: transparent}");
+    ui->optionsAreaContents->setStyleSheet(
+                "QWidget#optionsAreaContents {background-color: transparent}");
 
     connect(ui->buttonBox->button(QDialogButtonBox::Close), &QPushButton::clicked,
             this, &ItemLibraryAssetImportDialog::onClose);
@@ -155,6 +386,10 @@ ItemLibraryAssetImportDialog::ItemLibraryAssetImportDialog(const QStringList &im
             this, &ItemLibraryAssetImportDialog::onImportFinished);
     connect(&m_importer, &ItemLibraryAssetImporter::progressChanged,
             this, &ItemLibraryAssetImportDialog::setImportProgress);
+
+    addInfo(tr("Select import options and press \"Import\" to import the following files:"));
+    for (const auto &file : m_quick3DFiles)
+        addInfo(file);
 }
 
 ItemLibraryAssetImportDialog::~ItemLibraryAssetImportDialog()
@@ -162,9 +397,18 @@ ItemLibraryAssetImportDialog::~ItemLibraryAssetImportDialog()
     delete ui;
 }
 
-void ItemLibraryAssetImportDialog::setImportUiState(bool importing)
+void ItemLibraryAssetImportDialog::resizeEvent(QResizeEvent *event)
+{
+    Q_UNUSED(event)
+    int scrollBarHeight = ui->optionsArea->horizontalScrollBar()->isVisible()
+            ? ui->optionsArea->horizontalScrollBar()->height() : 0;
+    ui->tabWidget->setMaximumHeight(ui->optionsAreaContents->height() + scrollBarHeight
+                                    + ui->tabWidget->tabBar()->height() + 8);
+    ui->optionsArea->resize(ui->tabWidget->currentWidget()->size());
+}
+
+void ItemLibraryAssetImportDialog::setCloseButtonState(bool importing)
 {
-    ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(!importing);
     ui->buttonBox->button(QDialogButtonBox::Close)->setEnabled(true);
     ui->buttonBox->button(QDialogButtonBox::Close)->setText(importing ? tr("Cancel") : tr("Close"));
 }
@@ -186,12 +430,14 @@ void ItemLibraryAssetImportDialog::addInfo(const QString &info, const QString &s
 
 void ItemLibraryAssetImportDialog::onImport()
 {
-    setImportUiState(true);
+    ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
+    setCloseButtonState(true);
     ui->progressBar->setValue(0);
-    ui->plainTextEdit->clear();
 
-    if (!m_quick3DFiles.isEmpty())
-        m_importer.importQuick3D(m_quick3DFiles, m_quick3DImportPath);
+    if (!m_quick3DFiles.isEmpty()) {
+        m_importer.importQuick3D(m_quick3DFiles, m_quick3DImportPath,
+                                 m_importOptions.toVariantMap());
+    }
 }
 
 void ItemLibraryAssetImportDialog::setImportProgress(int value, const QString &text)
@@ -212,7 +458,7 @@ void ItemLibraryAssetImportDialog::onImportNearlyFinished()
 
 void ItemLibraryAssetImportDialog::onImportFinished()
 {
-    setImportUiState(false);
+    setCloseButtonState(false);
     if (m_importer.isCancelled()) {
         QString interruptStr = tr("Import interrupted.");
         addError(interruptStr);
diff --git a/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimportdialog.h b/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimportdialog.h
index b50753089ae..52fbcc09998 100644
--- a/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimportdialog.h
+++ b/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimportdialog.h
@@ -27,6 +27,7 @@
 #include "itemlibraryassetimporter.h"
 
 #include <QtWidgets/qdialog.h>
+#include <QtCore/qjsonobject.h>
 
 namespace Utils {
 class OutputFormatter;
@@ -48,13 +49,16 @@ public:
                                const QString &defaulTargetDirectory, QWidget *parent = nullptr);
     ~ItemLibraryAssetImportDialog();
 
+protected:
+    void resizeEvent(QResizeEvent *event) override;
+
 private slots:
     void addError(const QString &error, const QString &srcPath = {});
     void addWarning(const QString &warning, const QString &srcPath = {});
     void addInfo(const QString &info, const QString &srcPath = {});
 
 private:
-    void setImportUiState(bool importing);
+    void setCloseButtonState(bool importing);
 
     void onImport();
     void setImportProgress(int value, const QString &text);
@@ -68,5 +72,6 @@ private:
     QStringList m_quick3DFiles;
     QString m_quick3DImportPath;
     ItemLibraryAssetImporter m_importer;
+    QJsonObject m_importOptions;
 };
 }
diff --git a/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimportdialog.ui b/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimportdialog.ui
index 7cccc494144..7eb3df06d4e 100644
--- a/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimportdialog.ui
+++ b/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimportdialog.ui
@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>800</width>
-    <height>480</height>
+    <width>631</width>
+    <height>711</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -15,7 +15,75 @@
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
+    <widget class="QTabWidget" name="tabWidget">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+       <horstretch>0</horstretch>
+       <verstretch>2</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="currentIndex">
+      <number>0</number>
+     </property>
+     <property name="tabBarAutoHide">
+      <bool>false</bool>
+     </property>
+     <widget class="QWidget" name="modelOptionsTab">
+      <attribute name="title">
+       <string>Import Options</string>
+      </attribute>
+      <widget class="QScrollArea" name="optionsArea">
+       <property name="geometry">
+        <rect>
+         <x>0</x>
+         <y>0</y>
+         <width>611</width>
+         <height>351</height>
+        </rect>
+       </property>
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+         <horstretch>0</horstretch>
+         <verstretch>2</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="horizontalScrollBarPolicy">
+        <enum>Qt::ScrollBarAsNeeded</enum>
+       </property>
+       <property name="widgetResizable">
+        <bool>false</bool>
+       </property>
+       <widget class="QWidget" name="optionsAreaContents">
+        <property name="geometry">
+         <rect>
+          <x>0</x>
+          <y>0</y>
+          <width>0</width>
+          <height>0</height>
+         </rect>
+        </property>
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="autoFillBackground">
+         <bool>false</bool>
+        </property>
+       </widget>
+      </widget>
+     </widget>
+    </widget>
+   </item>
+   <item>
     <widget class="QPlainTextEdit" name="plainTextEdit">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+       <horstretch>0</horstretch>
+       <verstretch>1</verstretch>
+      </sizepolicy>
+     </property>
      <property name="readOnly">
       <bool>true</bool>
      </property>
diff --git a/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimporter.cpp b/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimporter.cpp
index d7c5acb053c..bef43074292 100644
--- a/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimporter.cpp
+++ b/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimporter.cpp
@@ -51,6 +51,9 @@ namespace QmlDesigner {
 ItemLibraryAssetImporter::ItemLibraryAssetImporter(QObject *parent) :
     QObject (parent)
 {
+#ifdef IMPORT_QUICK3D_ASSETS
+    m_quick3DAssetImporter.reset(new QSSGAssetImportManager);
+#endif
 }
 
 ItemLibraryAssetImporter::~ItemLibraryAssetImporter() {
@@ -59,7 +62,8 @@ ItemLibraryAssetImporter::~ItemLibraryAssetImporter() {
 };
 
 void ItemLibraryAssetImporter::importQuick3D(const QStringList &inputFiles,
-                                             const QString &importPath)
+                                             const QString &importPath,
+                                             const QVariantMap &options)
 {
     if (m_isImporting)
         cancelImport();
@@ -75,7 +79,7 @@ void ItemLibraryAssetImporter::importQuick3D(const QStringList &inputFiles,
 
     m_importPath = importPath;
 
-    parseFiles(inputFiles);
+    parseFiles(inputFiles, options);
 
     if (!isCancelled()) {
         // Don't allow cancel anymore as existing asset overwrites are not trivially recoverable.
@@ -169,6 +173,15 @@ bool ItemLibraryAssetImporter::isQuick3DAsset(const QString &fileName) const
     return quick3DExt.contains(QFileInfo(fileName).suffix());
 }
 
+QVariantMap ItemLibraryAssetImporter::supportedOptions(const QString &modelFile) const
+{
+#ifdef IMPORT_QUICK3D_ASSETS
+    return m_quick3DAssetImporter->getOptionsForFile(modelFile);
+#else
+    return {};
+#endif
+}
+
 void ItemLibraryAssetImporter::notifyFinished()
 {
     m_isImporting = false;
@@ -188,7 +201,7 @@ void ItemLibraryAssetImporter::reset()
 #endif
 }
 
-void ItemLibraryAssetImporter::parseFiles(const QStringList &filePaths)
+void ItemLibraryAssetImporter::parseFiles(const QStringList &filePaths, const QVariantMap &options)
 {
     if (isCancelled())
         return;
@@ -204,18 +217,16 @@ void ItemLibraryAssetImporter::parseFiles(const QStringList &filePaths)
         if (isCancelled())
             return;
         if (isQuick3DAsset(file))
-            parseQuick3DAsset(file);
+            parseQuick3DAsset(file, options);
         notifyProgress(qRound(++count * quota), progressTitle);
     }
     notifyProgress(100, progressTitle);
 }
 
-void ItemLibraryAssetImporter::parseQuick3DAsset(const QString &file)
+void ItemLibraryAssetImporter::parseQuick3DAsset(const QString &file, const QVariantMap &options)
 {
 #ifdef IMPORT_QUICK3D_ASSETS
     addInfo(tr("Parsing 3D Model"), file);
-    if (!m_quick3DAssetImporter)
-        m_quick3DAssetImporter.reset(new QSSGAssetImportManager);
 
     QString errorString;
 
@@ -258,8 +269,8 @@ void ItemLibraryAssetImporter::parseQuick3DAsset(const QString &file)
     addInfo(tr("Generating 3D assets for: \"%1\"").arg(targetDir.absoluteFilePath(assetName)));
 
     if (m_quick3DAssetImporter->importFile(
-                sourceInfo.absoluteFilePath(), outDir,
-                &errorString) != QSSGAssetImportManager::ImportState::Success) {
+                sourceInfo.absoluteFilePath(), outDir, options, &errorString)
+            != QSSGAssetImportManager::ImportState::Success) {
         addError(tr("Failed to import 3D asset with error: %1").arg(errorString),
                  sourceInfo.absoluteFilePath());
         return;
diff --git a/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimporter.h b/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimporter.h
index 622517e1aa9..cc31b57b68b 100644
--- a/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimporter.h
+++ b/src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimporter.h
@@ -45,7 +45,8 @@ public:
     ItemLibraryAssetImporter(QObject *parent = nullptr);
     ~ItemLibraryAssetImporter();
 
-    void importQuick3D(const QStringList &inputFiles, const QString &importPath);
+    void importQuick3D(const QStringList &inputFiles, const QString &importPath,
+                       const QVariantMap &options);
 
     bool isImporting() const;
     void cancelImport();
@@ -56,6 +57,7 @@ public:
     void addInfo(const QString &infoMsg, const QString &srcPath = {}) const;
 
     bool isQuick3DAsset(const QString &fileName) const;
+    QVariantMap supportedOptions(const QString &modelFile) const;
 
 signals:
     void errorReported(const QString &, const QString &) const;
@@ -68,8 +70,8 @@ signals:
 private:
     void notifyFinished();
     void reset();
-    void parseFiles(const QStringList &filePaths);
-    void parseQuick3DAsset(const QString &file);
+    void parseFiles(const QStringList &filePaths, const QVariantMap &options);
+    void parseQuick3DAsset(const QString &file, const QVariantMap &options);
     void copyImportedFiles();
 
     void notifyProgress(int value, const QString &text) const;