QmlDesigner: Add states to ImageCache

Task-number: QDS-2998
Change-Id: I8e65881181ae1010ef1f8bab92fa71d92c961bcd
Reviewed-by: Thomas Hartmann <thomas.hartmann@qt.io>

share/qtcreator/qml/qmlpuppet/commands/createscenecommand.cpp

@@ -29,136 +29,20 @@
 
 namespace QmlDesigner {
 
-CreateSceneCommand::CreateSceneCommand() = default;
-
-CreateSceneCommand::CreateSceneCommand(const QVector<InstanceContainer> &instanceContainer,
-                                       const QVector<ReparentContainer> &reparentContainer,
-                                       const QVector<IdContainer> &idVector,
-                                       const QVector<PropertyValueContainer> &valueChangeVector,
-                                       const QVector<PropertyBindingContainer> &bindingChangeVector,
-                                       const QVector<PropertyValueContainer> &auxiliaryChangeVector,
-                                       const QVector<AddImportContainer> &importVector,
-                                       const QVector<MockupTypeContainer> &mockupTypeVector,
-                                       const QUrl &fileUrl,
-                                       const QHash<QString, QVariantMap> &edit3dToolStates,
-                                       const QString &language)
-    : m_instanceVector(instanceContainer),
-      m_reparentInstanceVector(reparentContainer),
-      m_idVector(idVector),
-      m_valueChangeVector(valueChangeVector),
-      m_bindingChangeVector(bindingChangeVector),
-      m_auxiliaryChangeVector(auxiliaryChangeVector),
-      m_importVector(importVector),
-      m_mockupTypeVector(mockupTypeVector),
-      m_fileUrl(fileUrl),
-      m_edit3dToolStates(edit3dToolStates),
-      m_language(language)
-{
-}
-
-QVector<InstanceContainer> CreateSceneCommand::instances() const
-{
-    return m_instanceVector;
-}
-
-QVector<ReparentContainer> CreateSceneCommand::reparentInstances() const
-{
-    return m_reparentInstanceVector;
-}
-
-QVector<IdContainer> CreateSceneCommand::ids() const
-{
-    return m_idVector;
-}
-
-QVector<PropertyValueContainer> CreateSceneCommand::valueChanges() const
-{
-    return m_valueChangeVector;
-}
-
-QVector<PropertyBindingContainer> CreateSceneCommand::bindingChanges() const
-{
-    return m_bindingChangeVector;
-}
-
-QVector<PropertyValueContainer> CreateSceneCommand::auxiliaryChanges() const
-{
-    return m_auxiliaryChangeVector;
-}
-
-QVector<AddImportContainer> CreateSceneCommand::imports() const
-{
-    return m_importVector;
-}
-
-QVector<MockupTypeContainer> CreateSceneCommand::mockupTypes() const
-{
-    return m_mockupTypeVector;
-}
-
-QUrl CreateSceneCommand::fileUrl() const
-{
-    return m_fileUrl;
-}
-
-QHash<QString, QVariantMap> CreateSceneCommand::edit3dToolStates() const
-{
-    return m_edit3dToolStates;
-}
-
-QString CreateSceneCommand::language() const
-{
-    return m_language;
-}
-
-QDataStream &operator<<(QDataStream &out, const CreateSceneCommand &command)
-{
-    out << command.instances();
-    out << command.reparentInstances();
-    out << command.ids();
-    out << command.valueChanges();
-    out << command.bindingChanges();
-    out << command.auxiliaryChanges();
-    out << command.imports();
-    out << command.mockupTypes();
-    out << command.fileUrl();
-    out << command.edit3dToolStates();
-    out << command.language();
-
-    return out;
-}
-
-QDataStream &operator>>(QDataStream &in, CreateSceneCommand &command)
-{
-    in >> command.m_instanceVector;
-    in >> command.m_reparentInstanceVector;
-    in >> command.m_idVector;
-    in >> command.m_valueChangeVector;
-    in >> command.m_bindingChangeVector;
-    in >> command.m_auxiliaryChangeVector;
-    in >> command.m_importVector;
-    in >> command.m_mockupTypeVector;
-    in >> command.m_fileUrl;
-    in >> command.m_edit3dToolStates;
-    in >> command.m_language;
-
-    return in;
-}
-
 QDebug operator <<(QDebug debug, const CreateSceneCommand &command)
 {
     return debug.nospace() << "CreateSceneCommand("
-                    << "instances: " << command.instances() << ", "
+                           << "instances: " << command.instances << ", "
-                    << "reparentInstances: " << command.reparentInstances() << ", "
+                           << "reparentInstances: " << command.reparentInstances << ", "
-                    << "ids: " << command.ids() << ", "
+                           << "ids: " << command.ids << ", "
-                    << "valueChanges: " << command.valueChanges() << ", "
+                           << "valueChanges: " << command.valueChanges << ", "
-                    << "bindingChanges: " << command.bindingChanges() << ", "
+                           << "bindingChanges: " << command.bindingChanges << ", "
-                    << "auxiliaryChanges: " << command.auxiliaryChanges() << ", "
+                           << "auxiliaryChanges: " << command.auxiliaryChanges << ", "
-                    << "imports: " << command.imports() << ", "
+                           << "imports: " << command.imports << ", "
-                    << "mockupTypes: " << command.mockupTypes() << ", "
+                           << "mockupTypes: " << command.mockupTypes << ", "
-                    << "fileUrl: " << command.fileUrl() << ", "
+                           << "fileUrl: " << command.fileUrl << ", "
-                    << "edit3dToolStates: " << command.edit3dToolStates() << ", "
+                           << "edit3dToolStates: " << command.edit3dToolStates << ", "
-                    << "language: " << command.language() << ")";
+                           << "language: " << command.language << ")";
 }
 
 }

share/qtcreator/qml/qmlpuppet/commands/createscenecommand.h

@@ -41,12 +41,9 @@ namespace QmlDesigner {
 
 class CreateSceneCommand
 {
-    friend QDataStream &operator>>(QDataStream &in, CreateSceneCommand &command);
-
 public:
-    CreateSceneCommand();
+    CreateSceneCommand() = default;
-    explicit CreateSceneCommand(
+    explicit CreateSceneCommand(const QVector<InstanceContainer> &instanceContainer,
-        const QVector<InstanceContainer> &instanceContainer,
                                 const QVector<ReparentContainer> &reparentContainer,
                                 const QVector<IdContainer> &idVector,
                                 const QVector<PropertyValueContainer> &valueChangeVector,
@@ -56,38 +53,75 @@ public:
                                 const QVector<MockupTypeContainer> &mockupTypeVector,
                                 const QUrl &fileUrl,
                                 const QHash<QString, QVariantMap> &edit3dToolStates,
-        const QString &language);
+                                const QString &language,
+                                qint32 stateInstanceId)
+        : instances(instanceContainer)
+        , reparentInstances(reparentContainer)
+        , ids(idVector)
+        , valueChanges(valueChangeVector)
+        , bindingChanges(bindingChangeVector)
+        , auxiliaryChanges(auxiliaryChangeVector)
+        , imports(importVector)
+        , mockupTypes(mockupTypeVector)
+        , fileUrl(fileUrl)
+        , edit3dToolStates(edit3dToolStates)
+        , language(language)
+        , stateInstanceId{stateInstanceId}
+    {}
 
-    QVector<InstanceContainer> instances() const;
+    friend QDataStream &operator<<(QDataStream &out, const CreateSceneCommand &command)
-    QVector<ReparentContainer> reparentInstances() const;
+    {
-    QVector<IdContainer> ids() const;
+        out << command.instances;
-    QVector<PropertyValueContainer> valueChanges() const;
+        out << command.reparentInstances;
-    QVector<PropertyBindingContainer> bindingChanges() const;
+        out << command.ids;
-    QVector<PropertyValueContainer> auxiliaryChanges() const;
+        out << command.valueChanges;
-    QVector<AddImportContainer> imports() const;
+        out << command.bindingChanges;
-    QVector<MockupTypeContainer> mockupTypes() const;
+        out << command.auxiliaryChanges;
-    QUrl fileUrl() const;
+        out << command.imports;
-    QHash<QString, QVariantMap> edit3dToolStates() const;
+        out << command.mockupTypes;
-    QString language() const;
+        out << command.fileUrl;
+        out << command.edit3dToolStates;
+        out << command.language;
+        out << command.stateInstanceId;
 
-private:
+        return out;
-    QVector<InstanceContainer> m_instanceVector;
-    QVector<ReparentContainer> m_reparentInstanceVector;
-    QVector<IdContainer> m_idVector;
-    QVector<PropertyValueContainer> m_valueChangeVector;
-    QVector<PropertyBindingContainer> m_bindingChangeVector;
-    QVector<PropertyValueContainer> m_auxiliaryChangeVector;
-    QVector<AddImportContainer> m_importVector;
-    QVector<MockupTypeContainer> m_mockupTypeVector;
-    QUrl m_fileUrl;
-    QHash<QString, QVariantMap> m_edit3dToolStates;
-    QString m_language;
-};
-
-QDataStream &operator<<(QDataStream &out, const CreateSceneCommand &command);
-QDataStream &operator>>(QDataStream &in, CreateSceneCommand &command);
-
-QDebug operator <<(QDebug debug, const CreateSceneCommand &command);
     }
 
+    friend QDataStream &operator>>(QDataStream &in, CreateSceneCommand &command)
+    {
+        in >> command.instances;
+        in >> command.reparentInstances;
+        in >> command.ids;
+        in >> command.valueChanges;
+        in >> command.bindingChanges;
+        in >> command.auxiliaryChanges;
+        in >> command.imports;
+        in >> command.mockupTypes;
+        in >> command.fileUrl;
+        in >> command.edit3dToolStates;
+        in >> command.language;
+        in >> command.stateInstanceId;
+
+        return in;
+    }
+
+public:
+    QVector<InstanceContainer> instances;
+    QVector<ReparentContainer> reparentInstances;
+    QVector<IdContainer> ids;
+    QVector<PropertyValueContainer> valueChanges;
+    QVector<PropertyBindingContainer> bindingChanges;
+    QVector<PropertyValueContainer> auxiliaryChanges;
+    QVector<AddImportContainer> imports;
+    QVector<MockupTypeContainer> mockupTypes;
+    QUrl fileUrl;
+    QHash<QString, QVariantMap> edit3dToolStates;
+    QString language;
+    qint32 stateInstanceId = 0;
+};
+
+QDebug operator<<(QDebug debug, const CreateSceneCommand &command);
+
+} // namespace QmlDesigner
+
 Q_DECLARE_METATYPE(QmlDesigner::CreateSceneCommand)

share/qtcreator/qml/qmlpuppet/qml2puppet/instances/nodeinstanceserver.cpp

@@ -318,12 +318,13 @@ void NodeInstanceServer::stopRenderTimer()
 
 void NodeInstanceServer::createScene(const CreateSceneCommand &command)
 {
-    setTranslationLanguage(command.language());
+    setTranslationLanguage(command.language);
     initializeView();
 
     Internal::QmlPrivateGate::stopUnifiedTimer();
 
     setupScene(command);
+    setupState(command.stateInstanceId);
     refreshBindings();
     startRenderTimer();
 }
@@ -399,15 +400,7 @@ void NodeInstanceServer::reparentInstances(const ReparentInstancesCommand &comma
 
 void NodeInstanceServer::changeState(const ChangeStateCommand &command)
 {
-    if (hasInstanceForId(command.stateInstanceId())) {
+    setupState(command.stateInstanceId());
-        if (activeStateInstance().isValid())
-            activeStateInstance().deactivateState();
-        ServerNodeInstance instance = instanceForId(command.stateInstanceId());
-        instance.activateState();
-    } else {
-        if (activeStateInstance().isValid())
-            activeStateInstance().deactivateState();
-    }
 
     startRenderTimer();
 }
@@ -569,38 +562,37 @@ void NodeInstanceServer::setupDefaultDummyData()
 
 QList<ServerNodeInstance> NodeInstanceServer::setupInstances(const CreateSceneCommand &command)
 {
-    QList<ServerNodeInstance> instanceList = createInstances(command.instances());
+    QList<ServerNodeInstance> instanceList = createInstances(command.instances);
 
-    foreach (const IdContainer &container, command.ids()) {
+    for (const IdContainer &container : std::as_const(command.ids)) {
         if (hasInstanceForId(container.instanceId()))
             instanceForId(container.instanceId()).setId(container.id());
     }
 
-    foreach (const PropertyValueContainer &container, command.valueChanges()) {
+    for (const PropertyValueContainer &container : std::as_const(command.valueChanges)) {
         if (container.isDynamic())
             setInstancePropertyVariant(container);
     }
 
-    foreach (const PropertyValueContainer &container, command.valueChanges()) {
+    for (const PropertyValueContainer &container : std::as_const(command.valueChanges)) {
         if (!container.isDynamic())
             setInstancePropertyVariant(container);
     }
 
-    reparentInstances(command.reparentInstances());
+    reparentInstances(command.reparentInstances);
 
-    foreach (const PropertyBindingContainer &container, command.bindingChanges()) {
+    for (const PropertyBindingContainer &container : std::as_const(command.bindingChanges)) {
         if (container.isDynamic())
             setInstancePropertyBinding(container);
     }
 
-    foreach (const PropertyBindingContainer &container, command.bindingChanges()) {
+    for (const PropertyBindingContainer &container : std::as_const(command.bindingChanges)) {
         if (!container.isDynamic())
             setInstancePropertyBinding(container);
     }
 
-    foreach (const PropertyValueContainer &container, command.auxiliaryChanges()) {
+    for (const PropertyValueContainer &container : std::as_const(command.auxiliaryChanges))
         setInstanceAuxiliaryData(container);
-    }
 
     for (int i = instanceList.size(); --i >= 0; )
         instanceList[i].doComponentComplete();
@@ -1498,4 +1490,17 @@ void NodeInstanceServer::handleInstanceHidden(const ServerNodeInstance &/*instan
 {
 }
 
+void NodeInstanceServer::setupState(qint32 stateInstanceId)
+{
+    if (hasInstanceForId(stateInstanceId)) {
+        if (activeStateInstance().isValid())
+            activeStateInstance().deactivateState();
+        ServerNodeInstance instance = instanceForId(stateInstanceId);
+        instance.activateState();
+    } else {
+        if (activeStateInstance().isValid())
+            activeStateInstance().deactivateState();
+    }
+}
+
 } // namespace QmlDesigner

share/qtcreator/qml/qmlpuppet/qml2puppet/instances/nodeinstanceserver.h

@@ -289,6 +289,7 @@ protected:
     static QList<QObject*> allSubObjectsForObject(QObject *object);
 
     virtual void resizeCanvasSizeToRootItemSize() = 0;
+    void setupState(qint32 stateInstanceId);
 
 private:
     void setupOnlyWorkingImports(const QStringList &workingImportStatementList);

share/qtcreator/qml/qmlpuppet/qml2puppet/instances/qt5informationnodeinstanceserver.cpp

@@ -1316,8 +1316,7 @@ void Qt5InformationNodeInstanceServer::createScene(const CreateSceneCommand &com
     Qt5NodeInstanceServer::createScene(command);
 
     QList<ServerNodeInstance> instanceList;
-    const auto instances = command.instances();
+    for (const InstanceContainer &container : std::as_const(command.instances)) {
-    for (const InstanceContainer &container : instances) {
         if (hasInstanceForId(container.instanceId())) {
             ServerNodeInstance instance = instanceForId(container.instanceId());
             if (instance.isValid())
@@ -1331,7 +1330,7 @@ void Qt5InformationNodeInstanceServer::createScene(const CreateSceneCommand &com
     nodeInstanceClient()->componentCompleted(createComponentCompletedCommand(instanceList));
 
     if (isQuick3DMode())
-        setup3DEditView(instanceList, command.edit3dToolStates());
+        setup3DEditView(instanceList, command.edit3dToolStates);
 
     QObject::connect(&m_renderModelNodeImageViewTimer, &QTimer::timeout,
                      this, &Qt5InformationNodeInstanceServer::doRenderModelNodeImageView);

share/qtcreator/qml/qmlpuppet/qml2puppet/instances/qt5nodeinstanceserver.cpp

@@ -116,11 +116,10 @@ void Qt5NodeInstanceServer::resetAllItems()
 
 void Qt5NodeInstanceServer::setupScene(const CreateSceneCommand &command)
 {
-
+    setupMockupTypes(command.mockupTypes);
-    setupMockupTypes(command.mockupTypes());
+    setupFileUrl(command.fileUrl);
-    setupFileUrl(command.fileUrl());
+    setupImports(command.imports);
-    setupImports(command.imports());
+    setupDummyData(command.fileUrl);
-    setupDummyData(command.fileUrl());
 
     setupInstances(command);
     quickView()->resize(rootNodeInstance().boundingRect().size().toSize());

share/qtcreator/qml/qmlpuppet/qml2puppet/instances/qt5previewnodeinstanceserver.cpp

@@ -46,7 +46,7 @@ Qt5PreviewNodeInstanceServer::Qt5PreviewNodeInstanceServer(NodeInstanceClientInt
 
 void Qt5PreviewNodeInstanceServer::createScene(const CreateSceneCommand &command)
 {
-    setTranslationLanguage(command.language());
+    setTranslationLanguage(command.language);
     initializeView();
     setupScene(command);
     startRenderTimer();

share/qtcreator/qml/qmlpuppet/qml2puppet/instances/qt5rendernodeinstanceserver.cpp

@@ -137,7 +137,7 @@ void Qt5RenderNodeInstanceServer::createScene(const CreateSceneCommand &command)
     Qt5NodeInstanceServer::createScene(command);
 
     QList<ServerNodeInstance> instanceList;
-    foreach (const InstanceContainer &container, command.instances()) {
+    for (const InstanceContainer &container : std::as_const(command.instances)) {
         if (hasInstanceForId(container.instanceId())) {
             ServerNodeInstance instance = instanceForId(container.instanceId());
             if (instance.isValid()) {

src/plugins/qmldesigner/designercore/imagecache/imagecache.cpp

@@ -44,6 +44,7 @@ ImageCache::ImageCache(ImageCacheStorageInterface &storage,
         while (isRunning()) {
             if (auto [hasEntry, entry] = getEntry(); hasEntry) {
                 request(entry.name,
+                        entry.state,
                         entry.requestType,
                         std::move(entry.captureCallback),
                         std::move(entry.abortCallback),
@@ -64,6 +65,7 @@ ImageCache::~ImageCache()
 }
 
 void ImageCache::request(Utils::SmallStringView name,
+                         Utils::SmallStringView state,
                          ImageCache::RequestType requestType,
                          ImageCache::CaptureCallback captureCallback,
                          ImageCache::AbortCallback abortCallback,
@@ -71,9 +73,11 @@ void ImageCache::request(Utils::SmallStringView name,
                          ImageCacheGeneratorInterface &generator,
                          TimeStampProviderInterface &timeStampProvider)
 {
+    const auto id = state.empty() ? Utils::PathString{name} : Utils::PathString{name, "+", state};
+
     const auto timeStamp = timeStampProvider.timeStamp(name);
-    const auto entry = requestType == RequestType::Image ? storage.fetchImage(name, timeStamp)
+    const auto entry = requestType == RequestType::Image ? storage.fetchImage(id, timeStamp)
-                                                         : storage.fetchIcon(name, timeStamp);
+                                                         : storage.fetchIcon(id, timeStamp);
 
     if (entry.hasEntry) {
         if (entry.image.isNull())
@@ -81,7 +85,11 @@ void ImageCache::request(Utils::SmallStringView name,
         else
             captureCallback(entry.image);
     } else {
-        generator.generateImage(name, timeStamp, std::move(captureCallback), std::move(abortCallback));
+        generator.generateImage(name,
+                                state,
+                                timeStamp,
+                                std::move(captureCallback),
+                                std::move(abortCallback));
     }
 }
 
@@ -95,17 +103,27 @@ void ImageCache::wait()
 
 void ImageCache::requestImage(Utils::PathString name,
                               ImageCache::CaptureCallback captureCallback,
-                              AbortCallback abortCallback)
+                              AbortCallback abortCallback,
+                              Utils::SmallString state)
 {
-    addEntry(std::move(name), std::move(captureCallback), std::move(abortCallback), RequestType::Image);
+    addEntry(std::move(name),
+             std::move(state),
+             std::move(captureCallback),
+             std::move(abortCallback),
+             RequestType::Image);
     m_condition.notify_all();
 }
 
 void ImageCache::requestIcon(Utils::PathString name,
                              ImageCache::CaptureCallback captureCallback,
-                             ImageCache::AbortCallback abortCallback)
+                             ImageCache::AbortCallback abortCallback,
+                             Utils::SmallString state)
 {
-    addEntry(std::move(name), std::move(captureCallback), std::move(abortCallback), RequestType::Icon);
+    addEntry(std::move(name),
+             std::move(state),
+             std::move(captureCallback),
+             std::move(abortCallback),
+             RequestType::Icon);
     m_condition.notify_all();
 }
 
@@ -136,6 +154,7 @@ std::tuple<bool, ImageCache::Entry> ImageCache::getEntry()
 }
 
 void ImageCache::addEntry(Utils::PathString &&name,
+                          Utils::SmallString &&state,
                           ImageCache::CaptureCallback &&captureCallback,
                           AbortCallback &&abortCallback,
                           RequestType requestType)
@@ -143,6 +162,7 @@ void ImageCache::addEntry(Utils::PathString &&name,
     std::unique_lock lock{m_mutex};
 
     m_entries.emplace_back(std::move(name),
+                           std::move(state),
                            std::move(captureCallback),
                            std::move(abortCallback),
                            requestType);

src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.cpp

@@ -67,6 +67,7 @@ ImageCacheCollector::ImageCacheCollector(ImageCacheConnectionManager &connection
 ImageCacheCollector::~ImageCacheCollector() = default;
 
 void ImageCacheCollector::start(Utils::SmallStringView name,
+                                Utils::SmallStringView state,
                                 CaptureCallback captureCallback,
                                 AbortCallback abortCallback)
 {
@@ -91,6 +92,11 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
         return;
     }
 
+    ModelNode stateNode = rewriterView.modelNodeForId(QString{state});
+
+    if (stateNode.isValid())
+        rewriterView.setCurrentStateNode(stateNode);
+
     m_connectionManager.setCallback(std::move(captureCallback));
 
     nodeInstanceView.setTarget(m_target.get());

src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.h

@@ -53,6 +53,7 @@ public:
     ~ImageCacheCollector();
 
     void start(Utils::SmallStringView filePath,
+               Utils::SmallStringView state,
                CaptureCallback captureCallback,
                AbortCallback abortCallback) override;
 

src/plugins/qmldesigner/designercore/imagecache/imagecachecollectorinterface.h

@@ -38,6 +38,7 @@ public:
     using AbortCallback = std::function<void()>;
 
     virtual void start(Utils::SmallStringView filePath,
+                       Utils::SmallStringView state,
                        CaptureCallback captureCallback,
                        AbortCallback abortCallback)
         = 0;

src/plugins/qmldesigner/designercore/imagecache/imagecachegenerator.cpp

@@ -47,14 +47,20 @@ ImageCacheGenerator::~ImageCacheGenerator()
     waitForFinished();
 }
 
-void ImageCacheGenerator::generateImage(Utils::SmallStringView name,
+void ImageCacheGenerator::generateImage(
+    Utils::SmallStringView name,
+    Utils::SmallStringView state,
     Sqlite::TimeStamp timeStamp,
     ImageCacheGeneratorInterface::CaptureCallback &&captureCallback,
     AbortCallback &&abortCallback)
 {
     {
         std::lock_guard lock{m_mutex};
-        m_tasks.emplace_back(name, timeStamp, std::move(captureCallback), std::move(abortCallback));
+        m_tasks.emplace_back(name,
+                             state,
+                             timeStamp,
+                             std::move(captureCallback),
+                             std::move(abortCallback));
     }
 
     m_condition.notify_all();
@@ -99,6 +105,7 @@ void ImageCacheGenerator::startGeneration()
 
         m_collector.start(
             task.filePath,
+            task.state,
             [this, task](QImage &&image) {
                 if (image.isNull())
                     task.abortCallback();

src/plugins/qmldesigner/designercore/imagecache/imagecachegenerator.h

@@ -51,6 +51,7 @@ public:
     ~ImageCacheGenerator();
 
     void generateImage(Utils::SmallStringView filePath,
+                       Utils::SmallStringView state,
                        Sqlite::TimeStamp timeStamp,
                        CaptureCallback &&captureCallback,
                        AbortCallback &&abortCallback) override;
@@ -63,16 +64,19 @@ private:
     {
         Task() = default;
         Task(Utils::SmallStringView filePath,
+             Utils::SmallStringView state,
              Sqlite::TimeStamp timeStamp,
              CaptureCallback &&captureCallback,
              AbortCallback &&abortCallback)
             : filePath(filePath)
+            , state(std::move(state))
             , captureCallback(std::move(captureCallback))
             , abortCallback(std::move(abortCallback))
             , timeStamp(timeStamp)
         {}
 
         Utils::PathString filePath;
+        Utils::SmallString state;
         CaptureCallback captureCallback;
         AbortCallback abortCallback;
         Sqlite::TimeStamp timeStamp;

src/plugins/qmldesigner/designercore/imagecache/imagecachegeneratorinterface.h

@@ -39,6 +39,7 @@ public:
     using AbortCallback = std::function<void()>;
 
     virtual void generateImage(Utils::SmallStringView name,
+                               Utils::SmallStringView state,
                                Sqlite::TimeStamp timeStamp,
                                CaptureCallback &&captureCallback,
                                AbortCallback &&abortCallback)

src/plugins/qmldesigner/designercore/include/imagecache.h

@@ -54,10 +54,12 @@ public:
 
     void requestImage(Utils::PathString name,
                       CaptureCallback captureCallback,
-                      AbortCallback abortCallback);
+                      AbortCallback abortCallback,
+                      Utils::SmallString state = {});
     void requestIcon(Utils::PathString name,
                      CaptureCallback captureCallback,
-                     AbortCallback abortCallback);
+                     AbortCallback abortCallback,
+                     Utils::SmallString state = {});
 
     void clean();
     void waitForFinished();
@@ -68,16 +70,19 @@ private:
     {
         Entry() = default;
         Entry(Utils::PathString name,
+              Utils::SmallString state,
               CaptureCallback &&captureCallback,
               AbortCallback &&abortCallback,
               RequestType requestType)
             : name{std::move(name)}
+            , state{std::move(state)}
             , captureCallback{std::move(captureCallback)}
             , abortCallback{std::move(abortCallback)}
             , requestType{requestType}
         {}
 
         Utils::PathString name;
+        Utils::SmallString state;
         CaptureCallback captureCallback;
         AbortCallback abortCallback;
         RequestType requestType = RequestType::Image;
@@ -85,6 +90,7 @@ private:
 
     std::tuple<bool, Entry> getEntry();
     void addEntry(Utils::PathString &&name,
+                  Utils::SmallString &&state,
                   CaptureCallback &&captureCallback,
                   AbortCallback &&abortCallback,
                   RequestType requestType);
@@ -93,6 +99,7 @@ private:
     void stopThread();
     bool isRunning();
     static void request(Utils::SmallStringView name,
+                        Utils::SmallStringView state,
                         ImageCache::RequestType requestType,
                         ImageCache::CaptureCallback captureCallback,
                         ImageCache::AbortCallback abortCallback,

src/plugins/qmldesigner/designercore/instances/nodeinstanceview.cpp

@@ -856,7 +856,7 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
     QList<ModelNode> nodeList = allModelNodes();
     QList<NodeInstance> instanceList;
 
-    foreach (const ModelNode &node, nodeList) {
+    for (const ModelNode &node : std::as_const(nodeList)) {
         NodeInstance instance = loadNode(node);
         if (!isSkippedNode(node))
             instanceList.append(instance);
@@ -868,7 +868,7 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
     QList<BindingProperty> bindingPropertyList;
 
     QVector<PropertyValueContainer> auxiliaryContainerVector;
-    foreach (const ModelNode &node, nodeList) {
+    for (const ModelNode &node : std::as_const(nodeList)) {
         variantPropertyList.append(node.variantProperties());
         bindingPropertyList.append(node.bindingProperties());
         if (node.isValid() && hasInstanceForModelNode(node)) {
@@ -883,9 +883,8 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
         }
     }
 
-
     QVector<InstanceContainer> instanceContainerList;
-    foreach (const NodeInstance &instance, instanceList) {
+    for (const NodeInstance &instance : std::as_const(instanceList)) {
         InstanceContainer::NodeSourceType nodeSourceType = static_cast<InstanceContainer::NodeSourceType>(instance.modelNode().nodeSourceType());
 
         InstanceContainer::NodeMetaType nodeMetaType = InstanceContainer::ObjectMetaType;
@@ -911,7 +910,7 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
     }
 
     QVector<ReparentContainer> reparentContainerList;
-    foreach (const NodeInstance &instance, instanceList) {
+    for (const NodeInstance &instance : std::as_const(instanceList)) {
         if (instance.modelNode().hasParentProperty()) {
             NodeAbstractProperty parentProperty = instance.modelNode().parentProperty();
             ReparentContainer container(instance.instanceId(), -1, PropertyName(), instanceForModelNode(parentProperty.parentModelNode()).instanceId(), parentProperty.name());
@@ -920,7 +919,7 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
     }
 
     QVector<IdContainer> idContainerList;
-    foreach (const NodeInstance &instance, instanceList) {
+    for (const NodeInstance &instance : std::as_const(instanceList)) {
         QString id = instance.modelNode().id();
         if (!id.isEmpty()) {
             IdContainer container(instance.instanceId(), id);
@@ -929,7 +928,7 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
     }
 
     QVector<PropertyValueContainer> valueContainerList;
-    foreach (const VariantProperty &property, variantPropertyList) {
+    for (const VariantProperty &property : std::as_const(variantPropertyList)) {
         ModelNode node = property.parentModelNode();
         if (node.isValid() && hasInstanceForModelNode(node)) {
             NodeInstance instance = instanceForModelNode(node);
@@ -939,7 +938,7 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
     }
 
     QVector<PropertyBindingContainer> bindingContainerList;
-    foreach (const BindingProperty &property, bindingPropertyList) {
+    for (const BindingProperty &property : std::as_const(bindingPropertyList)) {
         ModelNode node = property.parentModelNode();
         if (node.isValid() && hasInstanceForModelNode(node)) {
             NodeInstance instance = instanceForModelNode(node);
@@ -949,7 +948,7 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
     }
 
     QVector<AddImportContainer> importVector;
-    foreach (const Import &import, model()->imports())
+    for (const Import &import : model()->imports())
         importVector.append(AddImportContainer(import.url(), import.file(), import.version(), import.alias(), import.importPaths()));
 
     QVector<MockupTypeContainer> mockupTypesVector;
@@ -993,8 +992,12 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
     if (auto multiLanguageAspect = QmlProjectManager::QmlMultiLanguageAspect::current(m_currentTarget))
         lastUsedLanguage = multiLanguageAspect->currentLocale();
 
-    return CreateSceneCommand(
+    ModelNode stateNode = currentStateNode();
-                instanceContainerList,
+    qint32 stateInstanceId = 0;
+    if (stateNode.isValid() && stateNode.metaInfo().isSubclassOf("QtQuick.State", 1, 0))
+        stateInstanceId = stateNode.internalId();
+
+    return CreateSceneCommand(instanceContainerList,
                               reparentContainerList,
                               idContainerList,
                               valueContainerList,
@@ -1004,8 +1007,8 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
                               mockupTypesVector,
                               model()->fileUrl(),
                               m_edit3DToolStates[model()->fileUrl()],
-                lastUsedLanguage
+                              lastUsedLanguage,
-                );
+                              stateInstanceId);
 }
 
 ClearSceneCommand NodeInstanceView::createClearSceneCommand() const

tests/unit/unittest/imagecache-test.cpp

@@ -112,8 +112,8 @@ TEST_F(ImageCache, RequestImageRequestImageFromGenerator)
         .WillByDefault(Return(Sqlite::TimeStamp{123}));
 
     EXPECT_CALL(mockGenerator,
-                generateImage(Eq("/path/to/Component.qml"), Eq(Sqlite::TimeStamp{123}), _, _))
+                generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _))
-        .WillRepeatedly([&](auto &&, auto, auto &&callback, auto) { notification.notify(); });
+        .WillRepeatedly([&](auto, auto, auto, auto &&callback, auto) { notification.notify(); });
 
     cache.requestImage("/path/to/Component.qml",
                        mockCaptureCallback.AsStdFunction(),
@@ -123,8 +123,8 @@ TEST_F(ImageCache, RequestImageRequestImageFromGenerator)
 
 TEST_F(ImageCache, RequestImageCallsCaptureCallbackWithImageFromGenerator)
 {
-    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _))
+    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _))
-        .WillByDefault([&](auto &&, auto, auto &&callback, auto) {
+        .WillByDefault([&](auto, auto, auto, auto &&callback, auto) {
             callback(QImage{image1});
             notification.notify();
         });
@@ -139,8 +139,8 @@ TEST_F(ImageCache, RequestImageCallsCaptureCallbackWithImageFromGenerator)
 
 TEST_F(ImageCache, RequestImageCallsAbortCallbackFromGenerator)
 {
-    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _))
+    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _))
-        .WillByDefault([&](auto &&, auto, auto &&, auto &&abortCallback) {
+        .WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback) {
             abortCallback();
             notification.notify();
         });
@@ -217,8 +217,8 @@ TEST_F(ImageCache, RequestIconRequestImageFromGenerator)
         .WillByDefault(Return(Sqlite::TimeStamp{123}));
 
     EXPECT_CALL(mockGenerator,
-                generateImage(Eq("/path/to/Component.qml"), Eq(Sqlite::TimeStamp{123}), _, _))
+                generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _))
-        .WillRepeatedly([&](auto &&, auto, auto &&callback, auto) { notification.notify(); });
+        .WillRepeatedly([&](auto, auto, auto, auto &&callback, auto) { notification.notify(); });
 
     cache.requestIcon("/path/to/Component.qml",
                       mockCaptureCallback.AsStdFunction(),
@@ -228,8 +228,8 @@ TEST_F(ImageCache, RequestIconRequestImageFromGenerator)
 
 TEST_F(ImageCache, RequestIconCallsCaptureCallbackWithImageFromGenerator)
 {
-    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _))
+    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _))
-        .WillByDefault([&](auto &&, auto, auto &&callback, auto) {
+        .WillByDefault([&](auto, auto, auto, auto &&callback, auto) {
             callback(QImage{image1});
             notification.notify();
         });
@@ -244,8 +244,8 @@ TEST_F(ImageCache, RequestIconCallsCaptureCallbackWithImageFromGenerator)
 
 TEST_F(ImageCache, RequestIconCallsAbortCallbackFromGenerator)
 {
-    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _))
+    ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _))
-        .WillByDefault([&](auto &&, auto, auto &&, auto &&abortCallback) {
+        .WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback) {
             abortCallback();
             notification.notify();
         });
@@ -260,8 +260,8 @@ TEST_F(ImageCache, RequestIconCallsAbortCallbackFromGenerator)
 
 TEST_F(ImageCache, CleanRemovesEntries)
 {
-    EXPECT_CALL(mockGenerator, generateImage(_, _, _, _))
+    EXPECT_CALL(mockGenerator, generateImage(_, _, _, _, _))
-        .WillRepeatedly([&](auto &&, auto, auto &&mockCaptureCallback, auto &&) {
+        .WillRepeatedly([&](auto, auto, auto, auto &&mockCaptureCallback, auto &&) {
             mockCaptureCallback(QImage{});
             waitInThread.wait();
         });
@@ -280,9 +280,9 @@ TEST_F(ImageCache, CleanRemovesEntries)
 
 TEST_F(ImageCache, CleanCallsAbort)
 {
-    ON_CALL(mockGenerator, generateImage(_, _, _, _))
+    ON_CALL(mockGenerator, generateImage(_, _, _, _, _))
         .WillByDefault(
-            [&](auto &&, auto, auto &&mockCaptureCallback, auto &&) { waitInThread.wait(); });
+            [&](auto, auto, auto, auto &&mockCaptureCallback, auto &&) { waitInThread.wait(); });
     cache.requestIcon("/path/to/Component1.qml",
                       mockCaptureCallback.AsStdFunction(),
                       mockAbortCallback.AsStdFunction());
@@ -310,8 +310,8 @@ TEST_F(ImageCache, AfterCleanNewJobsWorks)
 {
     cache.clean();
 
-    EXPECT_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _))
+    EXPECT_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _))
-        .WillRepeatedly([&](auto &&, auto, auto &&, auto &&) { notification.notify(); });
+        .WillRepeatedly([&](auto, auto, auto, auto &&, auto &&) { notification.notify(); });
 
     cache.requestIcon("/path/to/Component.qml",
                       mockCaptureCallback.AsStdFunction(),
@@ -342,4 +342,50 @@ TEST_F(ImageCache, WaitForFinishedInGenerator)
     cache.waitForFinished();
 }
 
+TEST_F(ImageCache, RequestImageWithStateFetchesImageFromStorage)
+{
+    EXPECT_CALL(mockStorage, fetchImage(Eq("/path/to/Component.qml+state1"), _))
+        .WillRepeatedly([&](Utils::SmallStringView, auto) {
+            notification.notify();
+            return QmlDesigner::ImageCacheStorageInterface::Entry{{}, false};
+        });
+
+    cache.requestImage("/path/to/Component.qml",
+                       mockCaptureCallback.AsStdFunction(),
+                       mockAbortCallback.AsStdFunction(),
+                       "state1");
+    notification.wait();
+}
+
+TEST_F(ImageCache, RequestIconWithStateFetchesImageFromStorage)
+{
+    EXPECT_CALL(mockStorage, fetchIcon(Eq("/path/to/Component.qml+state1"), _))
+        .WillRepeatedly([&](Utils::SmallStringView, auto) {
+            notification.notify();
+            return QmlDesigner::ImageCacheStorageInterface::Entry{{}, false};
+        });
+
+    cache.requestIcon("/path/to/Component.qml",
+                      mockCaptureCallback.AsStdFunction(),
+                      mockAbortCallback.AsStdFunction(),
+                      "state1");
+    notification.wait();
+}
+
+TEST_F(ImageCache, RequestImageWithStateRequestImageFromGenerator)
+{
+    ON_CALL(mockTimeStampProvider, timeStamp(Eq("/path/to/Component.qml")))
+        .WillByDefault(Return(Sqlite::TimeStamp{123}));
+
+    EXPECT_CALL(mockGenerator,
+                generateImage(Eq("/path/to/Component.qml"), Eq("state1"), Eq(Sqlite::TimeStamp{123}), _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto &&callback, auto) { notification.notify(); });
+
+    cache.requestImage("/path/to/Component.qml",
+                       mockCaptureCallback.AsStdFunction(),
+                       mockAbortCallback.AsStdFunction(),
+                       "state1");
+    notification.wait();
+}
+
 } // namespace

tests/unit/unittest/imagecachecollectormock.h

@@ -35,6 +35,7 @@ public:
     MOCK_METHOD(void,
                 start,
                 (Utils::SmallStringView filePath,
+                 Utils::SmallStringView state,
                  ImageCacheCollectorInterface::CaptureCallback captureCallback,
                  ImageCacheCollectorInterface::AbortCallback abortCallback),
                 (override));

tests/unit/unittest/imagecachegenerator-test.cpp

@@ -63,24 +63,25 @@ protected:
 
 TEST_F(ImageCacheGenerator, CallsCollectorWithCaptureCallback)
 {
-    EXPECT_CALL(collectorMock, start(Eq("name"), _, _))
+    EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _))
-        .WillRepeatedly([&](auto, auto captureCallback, auto) { captureCallback(QImage{image1}); });
+        .WillRepeatedly(
+            [&](auto, auto, auto captureCallback, auto) { captureCallback(QImage{image1}); });
     EXPECT_CALL(imageCallbackMock, Call(_)).WillRepeatedly([&](const QImage &) {
         notification.notify();
     });
 
-    generator.generateImage("name", {}, imageCallbackMock.AsStdFunction(), {});
+    generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {});
     notification.wait();
 }
 
 TEST_F(ImageCacheGenerator, CallsCollectorOnlyIfNotProcessing)
 {
-    EXPECT_CALL(collectorMock, start(Eq("name"), _, _)).WillRepeatedly([&](auto, auto, auto) {
+    EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _)).WillRepeatedly([&](auto, auto, auto, auto) {
         notification.notify();
     });
 
-    generator.generateImage("name", {}, imageCallbackMock.AsStdFunction(), {});
+    generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {});
-    generator.generateImage("name", {}, imageCallbackMock.AsStdFunction(), {});
+    generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {});
     notification.wait(2);
 }
 
@@ -88,37 +89,39 @@ TEST_F(ImageCacheGenerator, ProcessTaskAfterFirstFinished)
 {
     ON_CALL(imageCallbackMock, Call(_)).WillByDefault([&](const QImage &) { notification.notify(); });
 
-    EXPECT_CALL(collectorMock, start(Eq("name"), _, _)).WillOnce([&](auto, auto captureCallback, auto) {
+    EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _))
-        captureCallback(QImage{image1});
+        .WillOnce([&](auto, auto, auto captureCallback, auto) { captureCallback(QImage{image1}); });
-    });
+    EXPECT_CALL(collectorMock, start(Eq("name2"), _, _, _))
-    EXPECT_CALL(collectorMock, start(Eq("name2"), _, _)).WillOnce([&](auto, auto captureCallback, auto) {
+        .WillOnce([&](auto, auto, auto captureCallback, auto) { captureCallback(QImage{image1}); });
-        captureCallback(QImage{image1});
-    });
 
-    generator.generateImage("name", {}, imageCallbackMock.AsStdFunction(), {});
+    generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {});
-    generator.generateImage("name2", {}, imageCallbackMock.AsStdFunction(), {});
+    generator.generateImage("name2", {}, {}, imageCallbackMock.AsStdFunction(), {});
     notification.wait(2);
 }
 
 TEST_F(ImageCacheGenerator, DontCrashAtDestructingGenerator)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _)).WillByDefault([&](auto, auto captureCallback, auto) {
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _))
-        captureCallback(QImage{image1});
+        .WillByDefault(
-    });
+            [&](auto, auto, auto captureCallback, auto) { captureCallback(QImage{image1}); });
 
     generator.generateImage("name",
+                            {},
                             {},
                             imageCallbackMock.AsStdFunction(),
                             abortCallbackMock.AsStdFunction());
     generator.generateImage("name2",
+                            {},
                             {},
                             imageCallbackMock.AsStdFunction(),
                             abortCallbackMock.AsStdFunction());
     generator.generateImage("name3",
+                            {},
                             {},
                             imageCallbackMock.AsStdFunction(),
                             abortCallbackMock.AsStdFunction());
     generator.generateImage("name4",
+                            {},
                             {},
                             imageCallbackMock.AsStdFunction(),
                             abortCallbackMock.AsStdFunction());
@@ -126,27 +129,27 @@ TEST_F(ImageCacheGenerator, DontCrashAtDestructingGenerator)
 
 TEST_F(ImageCacheGenerator, StoreImage)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _)).WillByDefault([&](auto, auto captureCallback, auto) {
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _))
-        captureCallback(QImage{image1});
+        .WillByDefault(
-    });
+            [&](auto, auto, auto captureCallback, auto) { captureCallback(QImage{image1}); });
 
     EXPECT_CALL(storageMock, storeImage(Eq("name"), Eq(Sqlite::TimeStamp{11}), Eq(image1)))
         .WillRepeatedly([&](auto, auto, auto) { notification.notify(); });
 
-    generator.generateImage("name", {11}, imageCallbackMock.AsStdFunction(), {});
+    generator.generateImage("name", {}, {11}, imageCallbackMock.AsStdFunction(), {});
     notification.wait();
 }
 
 TEST_F(ImageCacheGenerator, StoreNullImage)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _)).WillByDefault([&](auto, auto captureCallback, auto) {
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _))
-        captureCallback(QImage{});
+        .WillByDefault([&](auto, auto, auto captureCallback, auto) { captureCallback(QImage{}); });
-    });
 
     EXPECT_CALL(storageMock, storeImage(Eq("name"), Eq(Sqlite::TimeStamp{11}), Eq(QImage{})))
         .WillRepeatedly([&](auto, auto, auto) { notification.notify(); });
 
     generator.generateImage("name",
+                            {},
                             {11},
                             imageCallbackMock.AsStdFunction(),
                             abortCallbackMock.AsStdFunction());
@@ -155,21 +158,22 @@ TEST_F(ImageCacheGenerator, StoreNullImage)
 
 TEST_F(ImageCacheGenerator, AbortCallback)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _)).WillByDefault([&](auto, auto captureCallback, auto) {
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _))
-        captureCallback(QImage{image1});
+        .WillByDefault(
-    });
+            [&](auto, auto, auto captureCallback, auto) { captureCallback(QImage{image1}); });
-    ON_CALL(collectorMock, start(Eq("name2"), _, _)).WillByDefault([&](auto, auto, auto abortCallback) {
+    ON_CALL(collectorMock, start(Eq("name2"), _, _, _))
-        abortCallback();
+        .WillByDefault([&](auto, auto, auto, auto abortCallback) { abortCallback(); });
-    });
 
     EXPECT_CALL(imageCallbackMock, Call(_)).WillOnce([&](const QImage &) { notification.notify(); });
     EXPECT_CALL(abortCallbackMock, Call()).WillOnce([&]() { notification.notify(); });
 
     generator.generateImage("name",
+                            {},
                             {},
                             imageCallbackMock.AsStdFunction(),
                             abortCallbackMock.AsStdFunction());
     generator.generateImage("name2",
+                            {},
                             {},
                             imageCallbackMock.AsStdFunction(),
                             abortCallbackMock.AsStdFunction());
@@ -178,7 +182,7 @@ TEST_F(ImageCacheGenerator, AbortCallback)
 
 TEST_F(ImageCacheGenerator, StoreNullImageForAbortCallback)
 {
-    ON_CALL(collectorMock, start(_, _, _)).WillByDefault([&](auto, auto, auto abortCallback) {
+    ON_CALL(collectorMock, start(_, _, _, _)).WillByDefault([&](auto, auto, auto, auto abortCallback) {
         abortCallback();
     });
 
@@ -186,6 +190,7 @@ TEST_F(ImageCacheGenerator, StoreNullImageForAbortCallback)
         .WillOnce([&](auto, auto, auto) { notification.notify(); });
 
     generator.generateImage("name",
+                            {},
                             {11},
                             imageCallbackMock.AsStdFunction(),
                             abortCallbackMock.AsStdFunction());
@@ -194,13 +199,13 @@ TEST_F(ImageCacheGenerator, StoreNullImageForAbortCallback)
 
 TEST_F(ImageCacheGenerator, AbortForEmptyImage)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _)).WillByDefault([&](auto, auto captureCallback, auto) {
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _))
-        captureCallback(QImage{});
+        .WillByDefault([&](auto, auto, auto captureCallback, auto) { captureCallback(QImage{}); });
-    });
 
     EXPECT_CALL(abortCallbackMock, Call()).WillOnce([&]() { notification.notify(); });
 
     generator.generateImage("name",
+                            {},
                             {},
                             imageCallbackMock.AsStdFunction(),
                             abortCallbackMock.AsStdFunction());
@@ -209,17 +214,18 @@ TEST_F(ImageCacheGenerator, AbortForEmptyImage)
 
 TEST_F(ImageCacheGenerator, CallWalCheckpointFullIfQueueIsEmpty)
 {
-    ON_CALL(collectorMock, start(Eq("name"), _, _)).WillByDefault([&](auto, auto captureCallback, auto) {
+    ON_CALL(collectorMock, start(Eq("name"), _, _, _))
-        captureCallback({});
+        .WillByDefault([&](auto, auto, auto captureCallback, auto) { captureCallback({}); });
-    });
 
     EXPECT_CALL(storageMock, walCheckpointFull()).WillRepeatedly([&]() { notification.notify(); });
 
     generator.generateImage("name",
+                            {},
                             {11},
                             imageCallbackMock.AsStdFunction(),
                             abortCallbackMock.AsStdFunction());
     generator.generateImage("name2",
+                            {},
                             {11},
                             imageCallbackMock.AsStdFunction(),
                             abortCallbackMock.AsStdFunction());
@@ -228,15 +234,17 @@ TEST_F(ImageCacheGenerator, CallWalCheckpointFullIfQueueIsEmpty)
 
 TEST_F(ImageCacheGenerator, CleanIsCallingAbortCallback)
 {
-    ON_CALL(collectorMock, start(_, _, _)).WillByDefault([&](auto, auto captureCallback, auto) {
+    ON_CALL(collectorMock, start(_, _, _, _)).WillByDefault([&](auto, auto, auto captureCallback, auto) {
         captureCallback({});
         waitInThread.wait();
     });
     generator.generateImage("name",
+                            {},
                             {11},
                             imageCallbackMock.AsStdFunction(),
                             abortCallbackMock.AsStdFunction());
     generator.generateImage("name2",
+                            {},
                             {11},
                             imageCallbackMock.AsStdFunction(),
                             abortCallbackMock.AsStdFunction());
@@ -249,14 +257,16 @@ TEST_F(ImageCacheGenerator, CleanIsCallingAbortCallback)
 
 TEST_F(ImageCacheGenerator, WaitForFinished)
 {
-    ON_CALL(collectorMock, start(_, _, _)).WillByDefault([&](auto, auto captureCallback, auto) {
+    ON_CALL(collectorMock, start(_, _, _, _)).WillByDefault([&](auto, auto, auto captureCallback, auto) {
         captureCallback(QImage{image1});
     });
     generator.generateImage("name",
+                            {},
                             {11},
                             imageCallbackMock.AsStdFunction(),
                             abortCallbackMock.AsStdFunction());
     generator.generateImage("name2",
+                            {},
                             {11},
                             imageCallbackMock.AsStdFunction(),
                             abortCallbackMock.AsStdFunction());
@@ -266,4 +276,13 @@ TEST_F(ImageCacheGenerator, WaitForFinished)
     generator.waitForFinished();
 }
 
+TEST_F(ImageCacheGenerator, CallsCollectorWithState)
+{
+    EXPECT_CALL(collectorMock, start(Eq("name"), Eq("state1"), _, _))
+        .WillRepeatedly([&](auto, auto, auto, auto) { notification.notify(); });
+
+    generator.generateImage("name", "state1", {}, imageCallbackMock.AsStdFunction(), {});
+    notification.wait();
+}
+
 } // namespace

tests/unit/unittest/mockimagecachegenerator.h

@@ -35,6 +35,7 @@ public:
     MOCK_METHOD(void,
                 generateImage,
                 (Utils::SmallStringView name,
+                 Utils::SmallStringView state,
                  Sqlite::TimeStamp timeStamp,
                  CaptureCallback &&captureCallback,
                  AbortCallback &&abortCallback),