GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1329:73d2a50d0c6d

Merge branch 'feature/AcqFixes' into develop

Alexandre Leroux -

r1329:73d2a50d0c6d

parent child

Context file:

r1329:73d2a50d0c6d

Collapse all files

core/src/Variable/VariableController.cpp +52 -19

             #include <Variable/Variable.h>
             #include <Variable/VariableAcquisitionWorker.h>
             #include <Variable/VariableCacheStrategy.h>
             #include <Variable/VariableCacheStrategyFactory.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Variable/VariableSynchronizationGroup.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
             #include <Data/VariableRequest.h>
             #include <Time/TimeController.h>
             #include <QDataStream>
             #include <QMutex>
             #include <QThread>
             #include <QUuid>
             #include <QtCore/QItemSelectionModel>
             #include <deque>
             #include <set>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             namespace {
             SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &graphRange,
                                                   const SqpRange &oldGraphRange)
             {
                 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
                 auto varRangeRequested = varRange;
                 switch (zoomType) {
                     case AcquisitionZoomType::ZoomIn: {
                         auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                         auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                         varRangeRequested.m_TStart += deltaLeft;
                         varRangeRequested.m_TEnd -= deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::ZoomOut: {
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                         varRangeRequested.m_TStart -= deltaLeft;
                         varRangeRequested.m_TEnd += deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::PanRight: {
                         auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                         varRangeRequested.m_TStart += deltaLeft;
                         varRangeRequested.m_TEnd += deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::PanLeft: {
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                         varRangeRequested.m_TStart -= deltaLeft;
                         varRangeRequested.m_TEnd -= deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::Unknown: {
                         qCCritical(LOG_VariableController())
                             << VariableController::tr("Impossible to synchronize: zoom type unknown");
                         break;
                     }
                     default:
                         qCCritical(LOG_VariableController()) << VariableController::tr(
                             "Impossible to synchronize: zoom type not take into account");
                         // No action
                         break;
                 }
                 return varRangeRequested;
             }
             }
             enum class VariableRequestHandlerState { OFF, RUNNING, PENDING };
             struct VariableRequestHandler {
                 VariableRequestHandler()
                 {
                     m_CanUpdate = false;
                     m_State = VariableRequestHandlerState::OFF;
                 }
                 QUuid m_VarId;
                 VariableRequest m_RunningVarRequest;
                 VariableRequest m_PendingVarRequest;
                 VariableRequestHandlerState m_State;
                 bool m_CanUpdate;
             };
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate(VariableController *parent)
                         : m_WorkingMutex{},
                           m_VariableModel{new VariableModel{parent}},
                           m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
                           // m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},
                           m_VariableCacheStrategy{VariableCacheStrategyFactory::createCacheStrategy(
                               CacheStrategy::SingleThreshold)},
                           m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()},
                           q{parent}
                 {
                     m_VariableAcquisitionWorker->moveToThread(&m_VariableAcquisitionWorkerThread);
                     m_VariableAcquisitionWorkerThread.setObjectName("VariableAcquisitionWorkerThread");
                 }
                 virtual ~VariableControllerPrivate()
                 {
                     qCDebug(LOG_VariableController()) << tr("VariableControllerPrivate destruction");
                     m_VariableAcquisitionWorkerThread.quit();
                     m_VariableAcquisitionWorkerThread.wait();
                 }
                 void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested,
                                     QUuid varRequestId);
                 std::shared_ptr<Variable> findVariable(QUuid vIdentifier);
                 std::shared_ptr<IDataSeries>
                 retrieveDataSeries(const QVector<AcquisitionDataPacket> acqDataPacketVector);
                 void registerProvider(std::shared_ptr<IDataProvider> provider);
                 void storeVariableRequest(QUuid varId, QUuid varRequestId, const VariableRequest &varRequest);
                 QUuid acceptVariableRequest(QUuid varId, std::shared_ptr<IDataSeries> dataSeries);
                 void updateVariables(QUuid varRequestId);
                 void updateVariableRequest(QUuid varRequestId);
                 void cancelVariableRequest(QUuid varRequestId);
                 void executeVarRequest(std::shared_ptr<Variable> var, VariableRequest &varRequest);
+                template <typename VariableIterator>
+                void desynchronize(VariableIterator variableIt, const QUuid &syncGroupId);
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 QItemSelectionModel *m_VariableSelectionModel;
                 TimeController *m_TimeController{nullptr};
                 std::unique_ptr<VariableCacheStrategy> m_VariableCacheStrategy;
                 std::unique_ptr<VariableAcquisitionWorker> m_VariableAcquisitionWorker;
                 QThread m_VariableAcquisitionWorkerThread;
                 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
                     m_VariableToProviderMap;
                 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
                 std::map<QUuid, std::shared_ptr<VariableSynchronizationGroup> >
                     m_GroupIdToVariableSynchronizationGroupMap;
                 std::map<QUuid, QUuid> m_VariableIdGroupIdMap;
                 std::set<std::shared_ptr<IDataProvider> > m_ProviderSet;
                 std::map<QUuid, std::list<QUuid> > m_VarGroupIdToVarIds;
                 std::map<QUuid, std::unique_ptr<VariableRequestHandler> > m_VarIdToVarRequestHandler;
                 VariableController *q;
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                   << QThread::currentThread();
                 connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
                         &VariableController::onAbortProgressRequested);
                 connect(impl->m_VariableAcquisitionWorker.get(),
                         &VariableAcquisitionWorker::variableCanceledRequested, this,
                         &VariableController::onAbortAcquisitionRequested);
                 connect(impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::dataProvided, this,
                         &VariableController::onDataProvided);
                 connect(impl->m_VariableAcquisitionWorker.get(),
                         &VariableAcquisitionWorker::variableRequestInProgress, this,
                         &VariableController::onVariableRetrieveDataInProgress);
                 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::started,
                         impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::initialize);
                 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::finished,
                         impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::finalize);
                 connect(impl->m_VariableModel, &VariableModel::requestVariableRangeUpdate, this,
                         &VariableController::onUpdateDateTime);
                 impl->m_VariableAcquisitionWorkerThread.start();
             }
             VariableController::~VariableController()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
                                                   << QThread::currentThread();
                 this->waitForFinish();
             }
             VariableModel *VariableController::variableModel() noexcept
             {
                 return impl->m_VariableModel;
             }
             QItemSelectionModel *VariableController::variableSelectionModel() noexcept
             {
                 return impl->m_VariableSelectionModel;
             }
             void VariableController::setTimeController(TimeController *timeController) noexcept
             {
                 impl->m_TimeController = timeController;
             }
             std::shared_ptr<Variable>
             VariableController::cloneVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (impl->m_VariableModel->containsVariable(variable)) {
                     // Clones variable
                     auto duplicate = variable->clone();
                     // Adds clone to model
                     impl->m_VariableModel->addVariable(duplicate);
                     // Generates clone identifier
                     impl->m_VariableToIdentifierMap[duplicate] = QUuid::createUuid();
                     // Registers provider
                     auto variableProvider = impl->m_VariableToProviderMap.at(variable);
                     auto duplicateProvider = variableProvider != nullptr ? variableProvider->clone() : nullptr;
                     impl->m_VariableToProviderMap[duplicate] = duplicateProvider;
                     if (duplicateProvider) {
                         impl->registerProvider(duplicateProvider);
                     }
                     return duplicate;
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Can't create duplicate of variable %1: variable not registered in the model")
                                .arg(variable->name());
                     return nullptr;
                 }
             }
             void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (!variable) {
                     qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
                     return;
                 }
                 // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
                 // make some treatments before the deletion
                 emit variableAboutToBeDeleted(variable);
+                auto variableIt = impl->m_VariableToIdentifierMap.find(variable);
+                Q_ASSERT(variableIt != impl->m_VariableToIdentifierMap.cend());
+                auto variableId = variableIt->second;
+                // Removes variable's handler
+                impl->m_VarIdToVarRequestHandler.erase(variableId);
+                // Desynchronizes variable (if the variable is in a sync group)
+                auto syncGroupIt = impl->m_VariableIdGroupIdMap.find(variableId);
+                if (syncGroupIt != impl->m_VariableIdGroupIdMap.cend()) {
+                    impl->desynchronize(variableIt, syncGroupIt->second);
+                }
                 // Deletes identifier
-                impl->m_VariableToIdentifierMap.erase(variable);
+                impl->m_VariableToIdentifierMap.erase(variableIt);
                 // Deletes provider
                 auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
                 qCDebug(LOG_VariableController())
                     << tr("Number of providers deleted for variable %1: %2")
                            .arg(variable->name(), QString::number(nbProvidersDeleted));
                 // Deletes from model
                 impl->m_VariableModel->deleteVariable(variable);
             }
             void VariableController::deleteVariables(
                 const QVector<std::shared_ptr<Variable> > &variables) noexcept
             {
                 for (auto variable : qAsConst(variables)) {
                     deleteVariable(variable);
                 }
             }
             QByteArray
             VariableController::mimeDataForVariables(const QList<std::shared_ptr<Variable> > &variables) const
             {
                 auto encodedData = QByteArray{};
                 QVariantList ids;
                 for (auto &var : variables) {
                     auto itVar = impl->m_VariableToIdentifierMap.find(var);
                     if (itVar == impl->m_VariableToIdentifierMap.cend()) {
                         qCCritical(LOG_VariableController())
                             << tr("Impossible to find the data for an unknown variable.");
                     }
                     ids << itVar->second.toByteArray();
                 }
                 QDataStream stream{&encodedData, QIODevice::WriteOnly};
                 stream << ids;
                 return encodedData;
             }
             QList<std::shared_ptr<Variable> >
             VariableController::variablesForMimeData(const QByteArray &mimeData) const
             {
                 auto variables = QList<std::shared_ptr<Variable> >{};
                 QDataStream stream{mimeData};
                 QVariantList ids;
                 stream >> ids;
                 for (auto id : ids) {
                     auto uuid = QUuid{id.toByteArray()};
                     auto var = impl->findVariable(uuid);
                     variables << var;
                 }
                 return variables;
             }
             std::shared_ptr<Variable>
             VariableController::createVariable(const QString &name, const QVariantHash &metadata,
                                                std::shared_ptr<IDataProvider> provider) noexcept
             {
                 if (!impl->m_TimeController) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to create variable: The time controller is null");
                     return nullptr;
                 }
                 auto range = impl->m_TimeController->dateTime();
                 if (auto newVariable = impl->m_VariableModel->createVariable(name, metadata)) {
                     auto varId = QUuid::createUuid();
                     // Create the handler
                     auto varRequestHandler = std::make_unique<VariableRequestHandler>();
                     varRequestHandler->m_VarId = varId;
                     impl->m_VarIdToVarRequestHandler.insert(
                         std::make_pair(varId, std::move(varRequestHandler)));
                     // store the provider
                     impl->registerProvider(provider);
                     // Associate the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
                     impl->m_VariableToIdentifierMap[newVariable] = varId;
                     this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{newVariable}, range, false);
                     //        auto varRequestId = QUuid::createUuid();
                     //        qCInfo(LOG_VariableController()) << "createVariable: " << varId << varRequestId;
                     //        impl->processRequest(newVariable, range, varRequestId);
                     //        impl->updateVariableRequest(varRequestId);
                     return newVariable;
                 }
                 qCCritical(LOG_VariableController()) << tr("Impossible to create variable");
                 return nullptr;
             }
             void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
             {
                 // NOTE: Even if acquisition request is aborting, the graphe range will be changed
                 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
                                                   << QThread::currentThread()->objectName();
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 // NOTE we only permit the time modification for one variable
                 // DEPRECATED
                 // auto variables = QVector<std::shared_ptr<Variable> >{};
                 //        for (const auto &selectedRow : qAsConst(selectedRows)) {
                 //            if (auto selectedVariable =
                 //            impl->m_VariableModel->variable(selectedRow.row())) {
                 //                variables << selectedVariable;
                 //                // notify that rescale operation has to be done
                 //                emit rangeChanged(selectedVariable, dateTime);
                 //            }
                 //        }
                 //        if (!variables.isEmpty()) {
                 //            this->onRequestDataLoading(variables, dateTime, synchro);
                 //        }
                 if (selectedRows.size() == 1) {
                     if (auto selectedVariable
                         = impl->m_VariableModel->variable(qAsConst(selectedRows).first().row())) {
                         onUpdateDateTime(selectedVariable, dateTime);
                     }
                 }
                 else if (selectedRows.size() > 1) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to set time for more than 1 variable in the same time");
                 }
                 else {
                     qCWarning(LOG_VariableController())
                         << tr("There is no variable selected to set the time one");
                 }
             }
             void VariableController::onUpdateDateTime(std::shared_ptr<Variable> variable,
                                                       const SqpRange &dateTime)
             {
                 auto itVar = impl->m_VariableToIdentifierMap.find(variable);
                 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to onDateTimeOnSelection request for unknown variable");
                     return;
                 }
                 // notify that rescale operation has to be done
                 emit rangeChanged(variable, dateTime);
                 auto synchro
                     = impl->m_VariableIdGroupIdMap.find(itVar->second) != impl->m_VariableIdGroupIdMap.cend();
                 this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{variable}, dateTime, synchro);
             }
             void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
                                                     const SqpRange &cacheRangeRequested,
                                                     QVector<AcquisitionDataPacket> dataAcquired)
             {
                 qCDebug(LOG_VariableController()) << tr("onDataProvided") << QThread::currentThread();
                 auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
                 auto varRequestId = impl->acceptVariableRequest(vIdentifier, retrievedDataSeries);
                 if (!varRequestId.isNull()) {
                     impl->updateVariables(varRequestId);
                 }
             }
             void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
             {
                 qCDebug(LOG_VariableController())
                     << "TORM: variableController::onVariableRetrieveDataInProgress"
                     << QThread::currentThread()->objectName() << progress;
                 if (auto var = impl->findVariable(identifier)) {
                     impl->m_VariableModel->setDataProgress(var, progress);
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to notify progression of a null variable");
                 }
             }
             void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
             {
                 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortProgressRequested"
                                                   << QThread::currentThread()->objectName() << variable->name();
                 auto itVar = impl->m_VariableToIdentifierMap.find(variable);
                 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to onAbortProgressRequested request for unknown variable");
                     return;
                 }
                 auto varId = itVar->second;
                 auto itVarHandler = impl->m_VarIdToVarRequestHandler.find(varId);
                 if (itVarHandler == impl->m_VarIdToVarRequestHandler.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to onAbortProgressRequested for variable with unknown handler");
                     return;
                 }
                 auto varHandler = itVarHandler->second.get();
                 // case where a variable has a running request
                 if (varHandler->m_State != VariableRequestHandlerState::OFF) {
                     impl->cancelVariableRequest(varHandler->m_RunningVarRequest.m_VariableGroupId);
                 }
             }
             void VariableController::onAbortAcquisitionRequested(QUuid vIdentifier)
             {
                 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortAcquisitionRequested"
                                                   << QThread::currentThread()->objectName() << vIdentifier;
                 if (auto var = impl->findVariable(vIdentifier)) {
                     this->onAbortProgressRequested(var);
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to abort Acquisition Requestof a null variable");
                 }
             }
             void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
             {
                 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"
                                                   << QThread::currentThread()->objectName()
                                                   << synchronizationGroupId;
                 auto vSynchroGroup = std::make_shared<VariableSynchronizationGroup>();
                 impl->m_GroupIdToVariableSynchronizationGroupMap.insert(
                     std::make_pair(synchronizationGroupId, vSynchroGroup));
             }
             void VariableController::onRemoveSynchronizationGroupId(QUuid synchronizationGroupId)
             {
                 impl->m_GroupIdToVariableSynchronizationGroupMap.erase(synchronizationGroupId);
             }
             void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,
                                                        QUuid synchronizationGroupId)
             {
                 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"
                                                   << synchronizationGroupId;
                 auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(variable);
                 if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
                     auto groupIdToVSGIt
                         = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
                     if (groupIdToVSGIt != impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
                         impl->m_VariableIdGroupIdMap.insert(
                             std::make_pair(varToVarIdIt->second, synchronizationGroupId));
                         groupIdToVSGIt->second->addVariableId(varToVarIdIt->second);
                     }
                     else {
                         qCCritical(LOG_VariableController())
                             << tr("Impossible to synchronize a variable with an unknown sycnhronization group")
                             << variable->name();
                     }
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to synchronize a variable with no identifier") << variable->name();
                 }
             }
             void VariableController::desynchronize(std::shared_ptr<Variable> variable,
                                                    QUuid synchronizationGroupId)
             {
                 // Gets variable id
                 auto variableIt = impl->m_VariableToIdentifierMap.find(variable);
                 if (variableIt == impl->m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Can't desynchronize variable %1: variable identifier not found")
                                .arg(variable->name());
                     return;
                 }
-                // Gets synchronization group
+                impl->desynchronize(variableIt, synchronizationGroupId);
-                auto groupIt = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
-                if (groupIt == impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
-                    qCCritical(LOG_VariableController())
-                        << tr("Can't desynchronize variable %1: unknown synchronization group")
-                               .arg(variable->name());
-                    return;
-                auto variableId = variableIt->second;
-                // Removes variable from synchronization group
-                auto synchronizationGroup = groupIt->second;
-                synchronizationGroup->removeVariableId(variableId);
-                // Removes link between variable and synchronization group
-                impl->m_VariableIdGroupIdMap.erase(variableId);
             }
             void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,
                                                           const SqpRange &range, bool synchronise)
             {
                 // variables is assumed synchronized
                 // TODO: Asser variables synchronization
                 // we want to load data of the variable for the dateTime.
                 if (variables.isEmpty()) {
                     return;
                 }
                 auto varRequestId = QUuid::createUuid();
                 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
                                                   << QThread::currentThread()->objectName() << varRequestId
                                                   << range << synchronise;
                 if (!synchronise) {
                     auto varIds = std::list<QUuid>{};
                     for (const auto &var : variables) {
                         auto vId = impl->m_VariableToIdentifierMap.at(var);
                         varIds.push_back(vId);
                     }
                     impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
                     for (const auto &var : variables) {
                         qCDebug(LOG_VariableController()) << "processRequest for" << var->name() << varRequestId
                                                           << varIds.size();
                         impl->processRequest(var, range, varRequestId);
                     }
                 }
                 else {
                     auto vId = impl->m_VariableToIdentifierMap.at(variables.first());
                     auto varIdToGroupIdIt = impl->m_VariableIdGroupIdMap.find(vId);
                     if (varIdToGroupIdIt != impl->m_VariableIdGroupIdMap.cend()) {
                         auto groupId = varIdToGroupIdIt->second;
                         auto vSynchronizationGroup
                             = impl->m_GroupIdToVariableSynchronizationGroupMap.at(groupId);
                         auto vSyncIds = vSynchronizationGroup->getIds();
                         auto varIds = std::list<QUuid>{};
                         for (auto vId : vSyncIds) {
                             varIds.push_back(vId);
                         }
                         impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
                         for (auto vId : vSyncIds) {
                             auto var = impl->findVariable(vId);
                             // Don't process already processed var
                             if (var != nullptr) {
                                 qCDebug(LOG_VariableController()) << "processRequest synchro for" << var->name()
                                                                   << varRequestId;
                                 auto vSyncRangeRequested
                                     = variables.contains(var)
                                           ? range
                                           : computeSynchroRangeRequested(var->range(), range,
                                                                          variables.first()->range());
                                 qCDebug(LOG_VariableController()) << "synchro RR" << vSyncRangeRequested;
                                 impl->processRequest(var, vSyncRangeRequested, varRequestId);
                             }
                             else {
                                 qCCritical(LOG_VariableController())
                                     << tr("Impossible to synchronize a null variable");
                             }
                         }
                     }
                 }
                 impl->updateVariables(varRequestId);
             }
             void VariableController::initialize()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableController()) << tr("VariableController init END");
             }
             void VariableController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }
             AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const SqpRange &oldRange)
             {
                 // t1.m_TStart <= t2.m_TStart && t2.m_TEnd <= t1.m_TEnd
                 auto zoomType = AcquisitionZoomType::Unknown;
                 if (range.m_TStart <= oldRange.m_TStart && oldRange.m_TEnd <= range.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: ZoomOut";
                     zoomType = AcquisitionZoomType::ZoomOut;
                 }
                 else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: PanRight";
                     zoomType = AcquisitionZoomType::PanRight;
                 }
                 else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: PanLeft";
                     zoomType = AcquisitionZoomType::PanLeft;
                 }
                 else if (range.m_TStart >= oldRange.m_TStart && oldRange.m_TEnd >= range.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: ZoomIn";
                     zoomType = AcquisitionZoomType::ZoomIn;
                 }
                 else {
                     qCDebug(LOG_VariableController()) << "getZoomType: Unknown type detected";
                 }
                 return zoomType;
             }
             void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,
                                                                                const SqpRange &rangeRequested,
                                                                                QUuid varRequestId)
             {
                 auto itVar = m_VariableToIdentifierMap.find(var);
                 if (itVar == m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to process request for unknown variable");
                     return;
                 }
                 auto varId = itVar->second;
                 auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);
                 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to process request for variable with unknown handler");
                     return;
                 }
                 auto oldRange = var->range();
                 auto varHandler = itVarHandler->second.get();
                 if (varHandler->m_State != VariableRequestHandlerState::OFF) {
                     oldRange = varHandler->m_RunningVarRequest.m_RangeRequested;
                 }
                 auto varRequest = VariableRequest{};
                 varRequest.m_VariableGroupId = varRequestId;
                 auto varStrategyRangesRequested
                     = m_VariableCacheStrategy->computeRange(oldRange, rangeRequested);
                 varRequest.m_RangeRequested = varStrategyRangesRequested.first;
                 varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
                 switch (varHandler->m_State) {
                     case VariableRequestHandlerState::OFF: {
                         qCDebug(LOG_VariableController()) << tr("Process Request OFF")
                                                           << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         varHandler->m_RunningVarRequest = varRequest;
                         varHandler->m_State = VariableRequestHandlerState::RUNNING;
                         executeVarRequest(var, varRequest);
                         break;
                     }
                     case VariableRequestHandlerState::RUNNING: {
                         qCDebug(LOG_VariableController()) << tr("Process Request RUNNING")
                                                           << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         varHandler->m_State = VariableRequestHandlerState::PENDING;
                         varHandler->m_PendingVarRequest = varRequest;
                         break;
                     }
                     case VariableRequestHandlerState::PENDING: {
                         qCDebug(LOG_VariableController()) << tr("Process Request PENDING")
                                                           << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         auto variableGroupIdToCancel = varHandler->m_PendingVarRequest.m_VariableGroupId;
                         cancelVariableRequest(variableGroupIdToCancel);
                         // Cancel variable can make state downgrade
                         varHandler->m_State = VariableRequestHandlerState::PENDING;
                         varHandler->m_PendingVarRequest = varRequest;
                         break;
                     }
                     default:
                         qCCritical(LOG_VariableController())
                             << QObject::tr("Unknown VariableRequestHandlerState");
                 }
             }
             std::shared_ptr<Variable>
             VariableController::VariableControllerPrivate::findVariable(QUuid vIdentifier)
             {
                 std::shared_ptr<Variable> var;
                 auto findReply = [vIdentifier](const auto &entry) { return vIdentifier == entry.second; };
                 auto end = m_VariableToIdentifierMap.cend();
                 auto it = std::find_if(m_VariableToIdentifierMap.cbegin(), end, findReply);
                 if (it != end) {
                     var = it->first;
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to find the variable with the identifier: ") << vIdentifier;
                 }
                 return var;
             }
             std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(
                 const QVector<AcquisitionDataPacket> acqDataPacketVector)
             {
                 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
                                                   << acqDataPacketVector.size();
                 std::shared_ptr<IDataSeries> dataSeries;
                 if (!acqDataPacketVector.isEmpty()) {
                     dataSeries = acqDataPacketVector[0].m_DateSeries;
                     for (int i = 1; i < acqDataPacketVector.size(); ++i) {
                         dataSeries->merge(acqDataPacketVector[i].m_DateSeries.get());
                     }
                 }
                 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size END")
                                                   << acqDataPacketVector.size();
                 return dataSeries;
             }
             void VariableController::VariableControllerPrivate::registerProvider(
                 std::shared_ptr<IDataProvider> provider)
             {
                 if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {
                     qCDebug(LOG_VariableController()) << tr("Registering of a new provider")
                                                       << provider->objectName();
                     m_ProviderSet.insert(provider);
                     connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableDataAcquired);
                     connect(provider.get(), &IDataProvider::dataProvidedProgress,
                             m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
                     connect(provider.get(), &IDataProvider::dataProvidedFailed,
                             m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableAcquisitionFailed);
                 }
                 else {
                     qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
                 }
             }
             QUuid VariableController::VariableControllerPrivate::acceptVariableRequest(
                 QUuid varId, std::shared_ptr<IDataSeries> dataSeries)
             {
                 auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);
                 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
                     return QUuid();
                 }
                 auto varHandler = itVarHandler->second.get();
                 if (varHandler->m_State == VariableRequestHandlerState::OFF) {
                     qCCritical(LOG_VariableController())
                         << tr("acceptVariableRequest impossible on a variable with OFF state");
                 }
                 varHandler->m_RunningVarRequest.m_DataSeries = dataSeries;
                 varHandler->m_CanUpdate = true;
                 // Element traité, on a déjà toutes les données necessaires
                 auto varGroupId = varHandler->m_RunningVarRequest.m_VariableGroupId;
                 qCDebug(LOG_VariableController()) << "Variable::acceptVariableRequest" << varGroupId
                                                   << m_VarGroupIdToVarIds.size();
                 return varHandler->m_RunningVarRequest.m_VariableGroupId;
             }
             void VariableController::VariableControllerPrivate::updateVariables(QUuid varRequestId)
             {
                 qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"
                                                   << QThread::currentThread()->objectName() << varRequestId;
                 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
                 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
                     qCWarning(LOG_VariableController())
                         << tr("Impossible to updateVariables of unknown variables") << varRequestId;
                     return;
                 }
                 auto &varIds = varGroupIdToVarIdsIt->second;
                 auto varIdsEnd = varIds.end();
                 bool processVariableUpdate = true;
                 qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"
                                                   << varRequestId << varIds.size();
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd) && processVariableUpdate;
                      ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                     if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                         processVariableUpdate &= itVarHandler->second->m_CanUpdate;
                     }
                 }
                 if (processVariableUpdate) {
                     qCDebug(LOG_VariableController()) << "Final update OK for the var request" << varIds.size();
                     for (auto varIdsIt = varIds.begin(); varIdsIt != varIdsEnd; ++varIdsIt) {
                         auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                         if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                             if (auto var = findVariable(*varIdsIt)) {
                                 auto &varRequest = itVarHandler->second->m_RunningVarRequest;
                                 var->setRange(varRequest.m_RangeRequested);
                                 var->setCacheRange(varRequest.m_CacheRangeRequested);
                                 qCDebug(LOG_VariableController()) << tr("1: onDataProvided")
                                                                   << varRequest.m_RangeRequested
                                                                   << varRequest.m_CacheRangeRequested;
                                 qCDebug(LOG_VariableController()) << tr("2: onDataProvided var points before")
                                                                   << var->nbPoints()
                                                                   << varRequest.m_DataSeries->nbPoints();
                                 var->mergeDataSeries(varRequest.m_DataSeries);
                                 qCDebug(LOG_VariableController()) << tr("3: onDataProvided var points after")
                                                                   << var->nbPoints();
                                 emit var->updated();
                                 qCDebug(LOG_VariableController()) << tr("Update OK");
                             }
                             else {
                                 qCCritical(LOG_VariableController())
                                     << tr("Impossible to update data to a null variable");
                             }
                         }
                     }
                     updateVariableRequest(varRequestId);
                     // cleaning varRequestId
                     qCDebug(LOG_VariableController()) << tr("m_VarGroupIdToVarIds erase") << varRequestId;
                     m_VarGroupIdToVarIds.erase(varRequestId);
                     if (m_VarGroupIdToVarIds.empty()) {
                         emit q->acquisitionFinished();
                     }
                 }
             }
             void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid varRequestId)
             {
                 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
                 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
                     qCCritical(LOG_VariableController()) << QObject::tr(
                         "Impossible to updateVariableRequest since varGroupdId isn't here anymore");
                     return;
                 }
                 auto &varIds = varGroupIdToVarIdsIt->second;
                 auto varIdsEnd = varIds.end();
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                     if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                         auto varHandler = itVarHandler->second.get();
                         varHandler->m_CanUpdate = false;
                         switch (varHandler->m_State) {
                             case VariableRequestHandlerState::OFF: {
                                 qCCritical(LOG_VariableController())
                                     << QObject::tr("Impossible to update a variable with handler in OFF state");
                             } break;
                             case VariableRequestHandlerState::RUNNING: {
                                 varHandler->m_State = VariableRequestHandlerState::OFF;
                                 varHandler->m_RunningVarRequest = VariableRequest{};
                                 break;
                             }
                             case VariableRequestHandlerState::PENDING: {
                                 varHandler->m_State = VariableRequestHandlerState::RUNNING;
                                 varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;
                                 varHandler->m_PendingVarRequest = VariableRequest{};
                                 auto var = findVariable(itVarHandler->first);
                                 executeVarRequest(var, varHandler->m_RunningVarRequest);
+                                updateVariables(varHandler->m_RunningVarRequest.m_VariableGroupId);
                                 break;
                             }
                             default:
                                 qCCritical(LOG_VariableController())
                                     << QObject::tr("Unknown VariableRequestHandlerState");
                         }
                     }
                 }
             }
             void VariableController::VariableControllerPrivate::cancelVariableRequest(QUuid varRequestId)
             {
                 qCDebug(LOG_VariableController()) << tr("cancelVariableRequest") << varRequestId;
                 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
                 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to cancelVariableRequest for unknown varGroupdId") << varRequestId;
                     return;
                 }
                 auto &varIds = varGroupIdToVarIdsIt->second;
                 auto varIdsEnd = varIds.end();
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                     if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                         auto varHandler = itVarHandler->second.get();
                         varHandler->m_VarId = QUuid{};
                         switch (varHandler->m_State) {
                             case VariableRequestHandlerState::OFF: {
                                 qCWarning(LOG_VariableController())
                                     << QObject::tr("Impossible to cancel a variable with no running request");
                                 break;
                             }
                             case VariableRequestHandlerState::RUNNING: {
                                 if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {
                                     auto var = findVariable(itVarHandler->first);
                                     auto varProvider = m_VariableToProviderMap.at(var);
                                     if (varProvider != nullptr) {
                                         m_VariableAcquisitionWorker->abortProgressRequested(
                                             itVarHandler->first);
                                     }
                                     m_VariableModel->setDataProgress(var, 0.0);
                                     varHandler->m_CanUpdate = false;
                                     varHandler->m_State = VariableRequestHandlerState::OFF;
                                     varHandler->m_RunningVarRequest = VariableRequest{};
                                 }
                                 else {
                                     // TODO: log Impossible to cancel the running variable request beacause its
                                     // varRequestId isn't not the canceled one
                                 }
                                 break;
                             }
                             case VariableRequestHandlerState::PENDING: {
                                 if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {
                                     auto var = findVariable(itVarHandler->first);
                                     auto varProvider = m_VariableToProviderMap.at(var);
                                     if (varProvider != nullptr) {
                                         m_VariableAcquisitionWorker->abortProgressRequested(
                                             itVarHandler->first);
                                     }
                                     m_VariableModel->setDataProgress(var, 0.0);
                                     varHandler->m_CanUpdate = false;
                                     varHandler->m_State = VariableRequestHandlerState::RUNNING;
                                     varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;
                                     varHandler->m_PendingVarRequest = VariableRequest{};
                                     executeVarRequest(var, varHandler->m_RunningVarRequest);
                                 }
                                 else if (varHandler->m_PendingVarRequest.m_VariableGroupId == varRequestId) {
                                     varHandler->m_State = VariableRequestHandlerState::RUNNING;
                                     varHandler->m_PendingVarRequest = VariableRequest{};
                                 }
                                 else {
                                     // TODO: log Impossible to cancel the variable request beacause its
                                     // varRequestId isn't not the canceled one
                                 }
                                 break;
                             }
                             default:
                                 qCCritical(LOG_VariableController())
                                     << QObject::tr("Unknown VariableRequestHandlerState");
                         }
                     }
                 }
                 qCDebug(LOG_VariableController()) << tr("cancelVariableRequest: erase") << varRequestId;
                 m_VarGroupIdToVarIds.erase(varRequestId);
                 if (m_VarGroupIdToVarIds.empty()) {
                     emit q->acquisitionFinished();
                 }
             }
             void VariableController::VariableControllerPrivate::executeVarRequest(std::shared_ptr<Variable> var,
                                                                                   VariableRequest &varRequest)
             {
                 qCDebug(LOG_VariableController()) << tr("TORM: executeVarRequest");
-                auto varId = m_VariableToIdentifierMap.at(var);
+                auto varIdIt = m_VariableToIdentifierMap.find(var);
+                if (varIdIt == m_VariableToIdentifierMap.cend()) {
+                    qCWarning(LOG_VariableController()) << tr(
+                        "Can't execute request of a variable that is not registered (may has been deleted)");
+                    return;
+                }
+                auto varId = varIdIt->second;
                 auto varCacheRange = var->cacheRange();
                 auto varCacheRangeRequested = varRequest.m_CacheRangeRequested;
                 auto notInCacheRangeList
                     = Variable::provideNotInCacheRangeList(varCacheRange, varCacheRangeRequested);
                 auto inCacheRangeList
                     = Variable::provideInCacheRangeList(varCacheRange, varCacheRangeRequested);
                 if (!notInCacheRangeList.empty()) {
                     auto varProvider = m_VariableToProviderMap.at(var);
                     if (varProvider != nullptr) {
                         qCDebug(LOG_VariableController()) << "executeVarRequest " << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         m_VariableAcquisitionWorker->pushVariableRequest(
                             varRequest.m_VariableGroupId, varId, varRequest.m_RangeRequested,
                             varRequest.m_CacheRangeRequested,
                             DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},
                             varProvider);
                     }
                     else {
                         qCCritical(LOG_VariableController())
                             << "Impossible to provide data with a null provider";
                     }
                     if (!inCacheRangeList.empty()) {
                         emit q->updateVarDisplaying(var, inCacheRangeList.first());
                     }
                 }
                 else {
                     acceptVariableRequest(varId,
                                           var->dataSeries()->subDataSeries(varRequest.m_CacheRangeRequested));
                 }
             }
+            template <typename VariableIterator>
+            void VariableController::VariableControllerPrivate::desynchronize(VariableIterator variableIt,
+                                                                              const QUuid &syncGroupId)
+            {
+                const auto &variable = variableIt->first;
+                const auto &variableId = variableIt->second;
+                // Gets synchronization group
+                auto groupIt = m_GroupIdToVariableSynchronizationGroupMap.find(syncGroupId);
+                if (groupIt == m_GroupIdToVariableSynchronizationGroupMap.cend()) {
+                    qCCritical(LOG_VariableController())
+                        << tr("Can't desynchronize variable %1: unknown synchronization group")
+                               .arg(variable->name());
+                    return;
+                }
+                // Removes variable from synchronization group
+                auto synchronizationGroup = groupIt->second;
+                synchronizationGroup->removeVariableId(variableId);
+                // Removes link between variable and synchronization group
+                m_VariableIdGroupIdMap.erase(variableId);
+            }

gui/include/Visualization/VisualizationGraphWidget.h +16 -2

             #ifndef SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
             #include <memory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphWidget)
             class QCPRange;
             class QCustomPlot;
             class SqpRange;
             class Variable;
             class VisualizationWidget;
             class VisualizationZoneWidget;
             class VisualizationSelectionZoneItem;
             namespace Ui {
             class VisualizationGraphWidget;
             } // namespace Ui
+            /// Defines options that can be associated with the graph
+            enum GraphFlag {
+                DisableAll = 0x0,        ///< Disables acquisition and synchronization
+                EnableAcquisition = 0x1, ///< When this flag is set, the change of the graph's range leads to
+                                         /// the acquisition of data
+                EnableSynchronization = 0x2, ///< When this flag is set, the change of the graph's range causes
+                                             /// the call to the synchronization of the graphs contained in the
+                /// same zone of this graph
+                EnableAll = ~DisableAll ///< Enables acquisition and synchronization
+            };
+            Q_DECLARE_FLAGS(GraphFlags, GraphFlag)
+            Q_DECLARE_OPERATORS_FOR_FLAGS(GraphFlags)
             class VisualizationGraphWidget : public VisualizationDragWidget, public IVisualizationWidget {
                 Q_OBJECT
                 friend class QCustomPlotSynchronizer;
                 friend class VisualizationGraphRenderingDelegate;
             public:
                 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationGraphWidget();
                 /// Returns the VisualizationZoneWidget which contains the graph or nullptr
                 VisualizationZoneWidget *parentZoneWidget() const noexcept;
                 /// Returns the main VisualizationWidget which contains the graph or nullptr
                 VisualizationWidget *parentVisualizationWidget() const;
-                /// If acquisition isn't enable, requestDataLoading signal cannot be emit
+                /// Sets graph options
-                void enableAcquisition(bool enable);
+                void setFlags(GraphFlags flags);
                 void addVariable(std::shared_ptr<Variable> variable, SqpRange range);
                 /// Removes a variable from the graph
                 void removeVariable(std::shared_ptr<Variable> variable) noexcept;
                 /// Returns the list of all variables used in the graph
                 QList<std::shared_ptr<Variable> > variables() const;
                 /// Sets the y-axis range based on the data of a variable
                 void setYRange(std::shared_ptr<Variable> variable);
                 SqpRange graphRange() const noexcept;
                 void setGraphRange(const SqpRange &range);
                 // Zones
                 /// Returns the ranges of all the selection zones on the graph
                 QVector<SqpRange> selectionZoneRanges() const;
                 /// Adds new selection zones in the graph
                 void addSelectionZones(const QVector<SqpRange> &ranges);
                 /// Removes the specified selection zone
                 void removeSelectionZone(VisualizationSelectionZoneItem *selectionZone);
                 /// Undo the last zoom  done with a zoom box
                 void undoZoom();
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
                 bool contains(const Variable &variable) const override;
                 QString name() const override;
                 // VisualisationDragWidget
                 QMimeData *mimeData(const QPoint &position) const override;
                 QPixmap customDragPixmap(const QPoint &dragPosition) override;
                 bool isDragAllowed() const override;
                 void highlightForMerge(bool highlighted) override;
                 // Cursors
                 /// Adds or moves the vertical cursor at the specified value on the x-axis
                 void addVerticalCursor(double time);
                 /// Adds or moves the vertical cursor at the specified value on the x-axis
                 void addVerticalCursorAtViewportPosition(double position);
                 void removeVerticalCursor();
                 /// Adds or moves the vertical cursor at the specified value on the y-axis
                 void addHorizontalCursor(double value);
                 /// Adds or moves the vertical cursor at the specified value on the y-axis
                 void addHorizontalCursorAtViewportPosition(double position);
                 void removeHorizontalCursor();
             signals:
                 void synchronize(const SqpRange &range, const SqpRange &oldRange);
                 void requestDataLoading(QVector<std::shared_ptr<Variable> > variable, const SqpRange &range,
                                         bool synchronise);
                 /// Signal emitted when the variable is about to be removed from the graph
                 void variableAboutToBeRemoved(std::shared_ptr<Variable> var);
                 /// Signal emitted when the variable has been added to the graph
                 void variableAdded(std::shared_ptr<Variable> var);
             protected:
                 void closeEvent(QCloseEvent *event) override;
                 void enterEvent(QEvent *event) override;
                 void leaveEvent(QEvent *event) override;
                 QCustomPlot &plot() const noexcept;
             private:
                 Ui::VisualizationGraphWidget *ui;
                 class VisualizationGraphWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
             private slots:
                 /// Slot called when right clicking on the graph (displays a menu)
                 void onGraphMenuRequested(const QPoint &pos) noexcept;
                 /// Rescale the X axe to range parameter
                 void onRangeChanged(const QCPRange &t1, const QCPRange &t2);
                 /// Slot called when a mouse double click was made
                 void onMouseDoubleClick(QMouseEvent *event) noexcept;
                 /// Slot called when a mouse move was made
                 void onMouseMove(QMouseEvent *event) noexcept;
                 /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
                 void onMouseWheel(QWheelEvent *event) noexcept;
                 /// Slot called when a mouse press was made, to activate the calibration of a graph
                 void onMousePress(QMouseEvent *event) noexcept;
                 /// Slot called when a mouse release was made, to deactivate the calibration of a graph
                 void onMouseRelease(QMouseEvent *event) noexcept;
                 void onDataCacheVariableUpdated();
                 void onUpdateVarDisplaying(std::shared_ptr<Variable> variable, const SqpRange &range);
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H

gui/src/Visualization/VisualizationGraphWidget.cpp +17 -16

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationCursorItem.h"
             #include "Visualization/VisualizationDefs.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "Visualization/VisualizationMultiZoneSelectionDialog.h"
             #include "Visualization/VisualizationSelectionZoneItem.h"
             #include "Visualization/VisualizationSelectionZoneManager.h"
             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Actions/ActionsGuiController.h>
             #include <Common/MimeTypesDef.h>
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <DragAndDrop/DragDropGuiController.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
             namespace {
             /// Key pressed to enable drag&drop in all modes
             const auto DRAG_DROP_MODIFIER = Qt::AltModifier;
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::ControlModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ShiftModifier;
             /// Speed of a step of a wheel event for a pan, in percentage of the axis range
             const auto PAN_SPEED = 5;
             /// Key pressed to enable a calibration pan
             const auto VERTICAL_PAN_MODIFIER = Qt::AltModifier;
             /// Key pressed to enable multi selection of selection zones
             const auto MULTI_ZONE_SELECTION_MODIFIER = Qt::ControlModifier;
             /// Minimum size for the zoom box, in percentage of the axis range
             const auto ZOOM_BOX_MIN_SIZE = 0.8;
             /// Format of the dates appearing in the label of a cursor
             const auto CURSOR_LABELS_DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd\nhh:mm:ss:zzz");
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                 explicit VisualizationGraphWidgetPrivate(const QString &name)
                         : m_Name{name},
-                          m_DoAcquisition{true},
+                          m_Flags{GraphFlag::EnableAll},
                           m_IsCalibration{false},
                           m_RenderingDelegate{nullptr}
                 {
                 }
                 void updateData(PlottablesMap &plottables, std::shared_ptr<IDataSeries> dataSeries,
                                 const SqpRange &range)
                 {
                     VisualizationGraphHelper::updateData(plottables, dataSeries, range);
                     // Prevents that data has changed to update rendering
                     m_RenderingDelegate->onPlotUpdated();
                 }
                 QString m_Name;
                 // 1 variable -> n qcpplot
                 std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
-                bool m_DoAcquisition;
+                GraphFlags m_Flags;
                 bool m_IsCalibration;
                 /// Delegate used to attach rendering features to the plot
                 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
                 QCPItemRect *m_DrawingZoomRect = nullptr;
                 QStack<QPair<QCPRange, QCPRange> > m_ZoomStack;
                 std::unique_ptr<VisualizationCursorItem> m_HorizontalCursor = nullptr;
                 std::unique_ptr<VisualizationCursorItem> m_VerticalCursor = nullptr;
                 VisualizationSelectionZoneItem *m_DrawingZone = nullptr;
                 VisualizationSelectionZoneItem *m_HoveredZone = nullptr;
                 QVector<VisualizationSelectionZoneItem *> m_SelectionZones;
                 bool m_HasMovedMouse = false; // Indicates if the mouse moved in a releaseMouse even
                 void startDrawingRect(const QPoint &pos, QCustomPlot &plot)
                 {
                     removeDrawingRect(plot);
                     auto axisPos = posToAxisPos(pos, plot);
                     m_DrawingZoomRect = new QCPItemRect{&plot};
                     QPen p;
                     p.setWidth(2);
                     m_DrawingZoomRect->setPen(p);
                     m_DrawingZoomRect->topLeft->setCoords(axisPos);
                     m_DrawingZoomRect->bottomRight->setCoords(axisPos);
                 }
                 void removeDrawingRect(QCustomPlot &plot)
                 {
                     if (m_DrawingZoomRect) {
                         plot.removeItem(m_DrawingZoomRect); // the item is deleted by QCustomPlot
                         m_DrawingZoomRect = nullptr;
                         plot.replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 void startDrawingZone(const QPoint &pos, VisualizationGraphWidget *graph)
                 {
                     endDrawingZone(graph);
                     auto axisPos = posToAxisPos(pos, graph->plot());
                     m_DrawingZone = new VisualizationSelectionZoneItem{&graph->plot()};
                     m_DrawingZone->setRange(axisPos.x(), axisPos.x());
                     m_DrawingZone->setEditionEnabled(false);
                 }
                 void endDrawingZone(VisualizationGraphWidget *graph)
                 {
                     if (m_DrawingZone) {
                         auto drawingZoneRange = m_DrawingZone->range();
                         if (qAbs(drawingZoneRange.m_TEnd - drawingZoneRange.m_TStart) > 0) {
                             m_DrawingZone->setEditionEnabled(true);
                             addSelectionZone(m_DrawingZone);
                         }
                         else {
                             graph->plot().removeItem(m_DrawingZone); // the item is deleted by QCustomPlot
                         }
                         graph->plot().replot(QCustomPlot::rpQueuedReplot);
                         m_DrawingZone = nullptr;
                     }
                 }
                 void setSelectionZonesEditionEnabled(bool value)
                 {
                     for (auto s : m_SelectionZones) {
                         s->setEditionEnabled(value);
                     }
                 }
                 void addSelectionZone(VisualizationSelectionZoneItem *zone) { m_SelectionZones << zone; }
                 VisualizationSelectionZoneItem *selectionZoneAt(const QPoint &pos,
                                                                 const QCustomPlot &plot) const
                 {
                     VisualizationSelectionZoneItem *selectionZoneItemUnderCursor = nullptr;
                     auto minDistanceToZone = -1;
                     for (auto zone : m_SelectionZones) {
                         auto distanceToZone = zone->selectTest(pos, false);
                         if ((minDistanceToZone < 0 || distanceToZone <= minDistanceToZone)
                             && distanceToZone >= 0 && distanceToZone < plot.selectionTolerance()) {
                             selectionZoneItemUnderCursor = zone;
                         }
                     }
                     return selectionZoneItemUnderCursor;
                 }
                 QVector<VisualizationSelectionZoneItem *> selectionZonesAt(const QPoint &pos,
                                                                            const QCustomPlot &plot) const
                 {
                     QVector<VisualizationSelectionZoneItem *> zones;
                     for (auto zone : m_SelectionZones) {
                         auto distanceToZone = zone->selectTest(pos, false);
                         if (distanceToZone >= 0 && distanceToZone < plot.selectionTolerance()) {
                             zones << zone;
                         }
                     }
                     return zones;
                 }
                 void moveSelectionZoneOnTop(VisualizationSelectionZoneItem *zone, QCustomPlot &plot)
                 {
                     if (!m_SelectionZones.isEmpty() && m_SelectionZones.last() != zone) {
                         zone->moveToTop();
                         m_SelectionZones.removeAll(zone);
                         m_SelectionZones.append(zone);
                     }
                 }
                 QPointF posToAxisPos(const QPoint &pos, QCustomPlot &plot) const
                 {
                     auto axisX = plot.axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = plot.axisRect()->axis(QCPAxis::atLeft);
                     return QPointF{axisX->pixelToCoord(pos.x()), axisY->pixelToCoord(pos.y())};
                 }
                 bool pointIsInAxisRect(const QPointF &axisPoint, QCustomPlot &plot) const
                 {
                     auto axisX = plot.axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = plot.axisRect()->axis(QCPAxis::atLeft);
                     return axisX->range().contains(axisPoint.x()) && axisY->range().contains(axisPoint.y());
                 }
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 // Set qcpplot properties :
                 // - zoom is enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                 ui->widget->setInteractions(QCP::iRangeZoom);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal | Qt::Vertical);
                 // The delegate must be initialized after the ui as it uses the plot
                 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*this);
                 // Init the cursors
                 impl->m_HorizontalCursor = std::make_unique<VisualizationCursorItem>(&plot());
                 impl->m_HorizontalCursor->setOrientation(Qt::Horizontal);
                 impl->m_VerticalCursor = std::make_unique<VisualizationCursorItem>(&plot());
                 impl->m_VerticalCursor->setOrientation(Qt::Vertical);
                 connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
                 connect(ui->widget, &QCustomPlot::mouseRelease, this,
                         &VisualizationGraphWidget::onMouseRelease);
                 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
                 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
                 connect(ui->widget, &QCustomPlot::mouseDoubleClick, this,
                         &VisualizationGraphWidget::onMouseDoubleClick);
                 connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
                                                &QCPAxis::rangeChanged),
                         this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
                 // Activates menu when right clicking on the graph
                 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
                         &VisualizationGraphWidget::onGraphMenuRequested);
                 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
                         &VariableController::onRequestDataLoading);
                 connect(&sqpApp->variableController(), &VariableController::updateVarDisplaying, this,
                         &VisualizationGraphWidget::onUpdateVarDisplaying);
             #ifdef Q_OS_MAC
                 plot().setPlottingHint(QCP::phFastPolylines, true);
             #endif
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
             VisualizationZoneWidget *VisualizationGraphWidget::parentZoneWidget() const noexcept
             {
                 auto parent = parentWidget();
                 while (parent != nullptr && !qobject_cast<VisualizationZoneWidget *>(parent)) {
                     parent = parent->parentWidget();
                 }
                 return qobject_cast<VisualizationZoneWidget *>(parent);
             }
             VisualizationWidget *VisualizationGraphWidget::parentVisualizationWidget() const
             {
                 auto parent = parentWidget();
                 while (parent != nullptr && !qobject_cast<VisualizationWidget *>(parent)) {
                     parent = parent->parentWidget();
                 }
                 return qobject_cast<VisualizationWidget *>(parent);
             }
-            void VisualizationGraphWidget::enableAcquisition(bool enable)
+            void VisualizationGraphWidget::setFlags(GraphFlags flags)
             {
-                impl->m_DoAcquisition = enable;
+                impl->m_Flags = std::move(flags);
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
                 if (auto dataSeries = variable->dataSeries()) {
                     // Set axes properties according to the units of the data series
                     impl->m_RenderingDelegate->setAxesProperties(dataSeries);
                     // Sets rendering properties for the new plottables
                     // Warning: this method must be called after setAxesProperties(), as it can access to some
                     // axes properties that have to be initialized
                     impl->m_RenderingDelegate->setPlottablesProperties(dataSeries, createdPlottables);
                 }
                 impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
-                this->enableAcquisition(false);
+                this->setFlags(GraphFlag::DisableAll);
                 this->setGraphRange(range);
-                this->enableAcquisition(true);
+                this->setFlags(GraphFlag::EnableAll);
                 emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable, range, false);
                 emit variableAdded(variable);
             }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 // Each component associated to the variable :
                 // - is removed from qcpplot (which deletes it)
                 // - is no longer referenced in the map
                 auto variableIt = impl->m_VariableToPlotMultiMap.find(variable);
                 if (variableIt != impl->m_VariableToPlotMultiMap.cend()) {
                     emit variableAboutToBeRemoved(variable);
                     auto &plottablesMap = variableIt->second;
                     for (auto plottableIt = plottablesMap.cbegin(), plottableEnd = plottablesMap.cend();
                          plottableIt != plottableEnd;) {
                         ui->widget->removePlottable(plottableIt->second);
                         plottableIt = plottablesMap.erase(plottableIt);
                     }
                     impl->m_VariableToPlotMultiMap.erase(variableIt);
                 }
                 // Updates graph
                 ui->widget->replot();
             }
             QList<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
             {
                 auto variables = QList<std::shared_ptr<Variable> >{};
                 for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap);
                      it != std::cend(impl->m_VariableToPlotMultiMap); ++it) {
                     variables << it->first;
                 }
                 return variables;
             }
             void VisualizationGraphWidget::setYRange(std::shared_ptr<Variable> variable)
             {
                 if (!variable) {
                     qCCritical(LOG_VisualizationGraphWidget()) << "Can't set y-axis range: variable is null";
                     return;
                 }
                 VisualizationGraphHelper::setYAxisRange(variable, *ui->widget);
             }
             SqpRange VisualizationGraphWidget::graphRange() const noexcept
             {
                 auto graphRange = ui->widget->xAxis->range();
                 return SqpRange{graphRange.lower, graphRange.upper};
             }
             void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
                 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                 ui->widget->replot();
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
             }
             QVector<SqpRange> VisualizationGraphWidget::selectionZoneRanges() const
             {
                 QVector<SqpRange> ranges;
                 for (auto zone : impl->m_SelectionZones) {
                     ranges << zone->range();
                 }
                 return ranges;
             }
             void VisualizationGraphWidget::addSelectionZones(const QVector<SqpRange> &ranges)
             {
                 for (const auto &range : ranges) {
                     // note: ownership is transfered to QCustomPlot
                     auto zone = new VisualizationSelectionZoneItem(&plot());
                     zone->setRange(range.m_TStart, range.m_TEnd);
                     impl->addSelectionZone(zone);
                 }
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::removeSelectionZone(VisualizationSelectionZoneItem *selectionZone)
             {
                 parentVisualizationWidget()->selectionZoneManager().setSelected(selectionZone, false);
                 if (impl->m_HoveredZone == selectionZone) {
                     impl->m_HoveredZone = nullptr;
                     setCursor(Qt::ArrowCursor);
                 }
                 impl->m_SelectionZones.removeAll(selectionZone);
                 plot().removeItem(selectionZone);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::undoZoom()
             {
                 auto zoom = impl->m_ZoomStack.pop();
                 auto axisX = plot().axisRect()->axis(QCPAxis::atBottom);
                 auto axisY = plot().axisRect()->axis(QCPAxis::atLeft);
                 axisX->setRange(zoom.first);
                 axisY->setRange(zoom.second);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visit(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationGraphWidget())
                         << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationGraphWidget::canDrop(const Variable &variable) const
             {
                 auto isSpectrogram = [](const auto &variable) {
                     return std::dynamic_pointer_cast<SpectrogramSeries>(variable.dataSeries()) != nullptr;
                 };
                 // - A spectrogram series can't be dropped on graph with existing plottables
                 // - No data series can be dropped on graph with existing spectrogram series
                 return isSpectrogram(variable)
                            ? impl->m_VariableToPlotMultiMap.empty()
                            : std::none_of(
                                  impl->m_VariableToPlotMultiMap.cbegin(), impl->m_VariableToPlotMultiMap.cend(),
                                  [isSpectrogram](const auto &entry) { return isSpectrogram(*entry.first); });
             }
             bool VisualizationGraphWidget::contains(const Variable &variable) const
             {
                 // Finds the variable among the keys of the map
                 auto variablePtr = &variable;
                 auto findVariable
                     = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
                 auto end = impl->m_VariableToPlotMultiMap.cend();
                 auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
                 return it != end;
             }
             QString VisualizationGraphWidget::name() const
             {
                 return impl->m_Name;
             }
             QMimeData *VisualizationGraphWidget::mimeData(const QPoint &position) const
             {
                 auto mimeData = new QMimeData;
                 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(position, plot());
                 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
                     && selectionZoneItemUnderCursor) {
                     mimeData->setData(MIME_TYPE_TIME_RANGE, TimeController::mimeDataForTimeRange(
                                                                 selectionZoneItemUnderCursor->range()));
                     mimeData->setData(MIME_TYPE_SELECTION_ZONE, TimeController::mimeDataForTimeRange(
                                                                     selectionZoneItemUnderCursor->range()));
                 }
                 else {
                     mimeData->setData(MIME_TYPE_GRAPH, QByteArray{});
                     auto timeRangeData = TimeController::mimeDataForTimeRange(graphRange());
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
                 }
                 return mimeData;
             }
             QPixmap VisualizationGraphWidget::customDragPixmap(const QPoint &dragPosition)
             {
                 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(dragPosition, plot());
                 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
                     && selectionZoneItemUnderCursor) {
                     auto zoneTopLeft = selectionZoneItemUnderCursor->topLeft->pixelPosition();
                     auto zoneBottomRight = selectionZoneItemUnderCursor->bottomRight->pixelPosition();
                     auto zoneSize = QSizeF{qAbs(zoneBottomRight.x() - zoneTopLeft.x()),
                                            qAbs(zoneBottomRight.y() - zoneTopLeft.y())}
                                         .toSize();
                     auto pixmap = QPixmap(zoneSize);
                     render(&pixmap, QPoint(), QRegion{QRect{zoneTopLeft.toPoint(), zoneSize}});
                     return pixmap;
                 }
                 return QPixmap();
             }
             bool VisualizationGraphWidget::isDragAllowed() const
             {
                 return true;
             }
             void VisualizationGraphWidget::highlightForMerge(bool highlighted)
             {
                 if (highlighted) {
                     plot().setBackground(QBrush(QColor("#BBD5EE")));
                 }
                 else {
                     plot().setBackground(QBrush(Qt::white));
                 }
                 plot().update();
             }
             void VisualizationGraphWidget::addVerticalCursor(double time)
             {
                 impl->m_VerticalCursor->setPosition(time);
                 impl->m_VerticalCursor->setVisible(true);
                 auto text
                     = DateUtils::dateTime(time).toString(CURSOR_LABELS_DATETIME_FORMAT).replace(' ', '\n');
                 impl->m_VerticalCursor->setLabelText(text);
             }
             void VisualizationGraphWidget::addVerticalCursorAtViewportPosition(double position)
             {
                 impl->m_VerticalCursor->setAbsolutePosition(position);
                 impl->m_VerticalCursor->setVisible(true);
                 auto axis = plot().axisRect()->axis(QCPAxis::atBottom);
                 auto text
                     = DateUtils::dateTime(axis->pixelToCoord(position)).toString(CURSOR_LABELS_DATETIME_FORMAT);
                 impl->m_VerticalCursor->setLabelText(text);
             }
             void VisualizationGraphWidget::removeVerticalCursor()
             {
                 impl->m_VerticalCursor->setVisible(false);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::addHorizontalCursor(double value)
             {
                 impl->m_HorizontalCursor->setPosition(value);
                 impl->m_HorizontalCursor->setVisible(true);
                 impl->m_HorizontalCursor->setLabelText(QString::number(value));
             }
             void VisualizationGraphWidget::addHorizontalCursorAtViewportPosition(double position)
             {
                 impl->m_HorizontalCursor->setAbsolutePosition(position);
                 impl->m_HorizontalCursor->setVisible(true);
                 auto axis = plot().axisRect()->axis(QCPAxis::atLeft);
                 impl->m_HorizontalCursor->setLabelText(QString::number(axis->pixelToCoord(position)));
             }
             void VisualizationGraphWidget::removeHorizontalCursor()
             {
                 impl->m_HorizontalCursor->setVisible(false);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::closeEvent(QCloseEvent *event)
             {
                 Q_UNUSED(event);
                 // Prevents that all variables will be removed from graph when it will be closed
                 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
                     emit variableAboutToBeRemoved(variableEntry.first);
                 }
             }
             void VisualizationGraphWidget::enterEvent(QEvent *event)
             {
                 Q_UNUSED(event);
                 impl->m_RenderingDelegate->showGraphOverlay(true);
             }
             void VisualizationGraphWidget::leaveEvent(QEvent *event)
             {
                 Q_UNUSED(event);
                 impl->m_RenderingDelegate->showGraphOverlay(false);
                 if (auto parentZone = parentZoneWidget()) {
                     parentZone->notifyMouseLeaveGraph(this);
                 }
                 else {
                     qCWarning(LOG_VisualizationGraphWidget()) << "leaveEvent: No parent zone widget";
                 }
                 if (impl->m_HoveredZone) {
                     impl->m_HoveredZone->setHovered(false);
                     impl->m_HoveredZone = nullptr;
                 }
             }
             QCustomPlot &VisualizationGraphWidget::plot() const noexcept
             {
                 return *ui->widget;
             }
             void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
             {
                 QMenu graphMenu{};
                 // Iterates on variables (unique keys)
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
                           end = impl->m_VariableToPlotMultiMap.cend();
                      it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                     // 'Remove variable' action
                     graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
                                         [ this, var = it->first ]() { removeVariable(var); });
                 }
                 if (!impl->m_ZoomStack.isEmpty()) {
                     if (!graphMenu.isEmpty()) {
                         graphMenu.addSeparator();
                     }
                     graphMenu.addAction(tr("Undo Zoom"), [this]() { undoZoom(); });
                 }
                 // Selection Zone Actions
                 auto selectionZoneItem = impl->selectionZoneAt(pos, plot());
                 if (selectionZoneItem) {
                     auto selectedItems = parentVisualizationWidget()->selectionZoneManager().selectedItems();
                     selectedItems.removeAll(selectionZoneItem);
                     selectedItems.prepend(selectionZoneItem); // Put the current selection zone first
                     auto zoneActions = sqpApp->actionsGuiController().selectionZoneActions();
                     if (!zoneActions.isEmpty() && !graphMenu.isEmpty()) {
                         graphMenu.addSeparator();
                     }
                     QHash<QString, QMenu *> subMenus;
                     QHash<QString, bool> subMenusEnabled;
                     for (auto zoneAction : zoneActions) {
                         auto isEnabled = zoneAction->isEnabled(selectedItems);
                         auto menu = &graphMenu;
                         for (auto subMenuName : zoneAction->subMenuList()) {
                             if (!subMenus.contains(subMenuName)) {
                                 menu = menu->addMenu(subMenuName);
                                 subMenus[subMenuName] = menu;
                                 subMenusEnabled[subMenuName] = isEnabled;
                             }
                             else {
                                 menu = subMenus.value(subMenuName);
                                 if (isEnabled) {
                                     // The sub menu is enabled if at least one of its actions is enabled
                                     subMenusEnabled[subMenuName] = true;
                                 }
                             }
                         }
                         auto action = menu->addAction(zoneAction->name());
                         action->setEnabled(isEnabled);
                         action->setShortcut(zoneAction->displayedShortcut());
                         QObject::connect(action, &QAction::triggered,
                                          [zoneAction, selectedItems]() { zoneAction->execute(selectedItems); });
                     }
                     for (auto it = subMenus.cbegin(); it != subMenus.cend(); ++it) {
                         it.value()->setEnabled(subMenusEnabled[it.key()]);
                     }
                 }
                 if (!graphMenu.isEmpty()) {
                     graphMenu.exec(QCursor::pos());
                 }
             }
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
                                                         << QThread::currentThread()->objectName() << "DoAcqui"
-                                                        << impl->m_DoAcquisition;
+                                                        << impl->m_Flags.testFlag(GraphFlag::EnableAcquisition);
                 auto graphRange = SqpRange{t1.lower, t1.upper};
                 auto oldGraphRange = SqpRange{t2.lower, t2.upper};
-                if (impl->m_DoAcquisition) {
+                if (impl->m_Flags.testFlag(GraphFlag::EnableAcquisition)) {
                     QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
                     for (auto it = impl->m_VariableToPlotMultiMap.begin(),
                               end = impl->m_VariableToPlotMultiMap.end();
                          it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                         variableUnderGraphVector.push_back(it->first);
                     }
                     emit requestDataLoading(std::move(variableUnderGraphVector), graphRange,
                                             !impl->m_IsCalibration);
+                }
-                    if (!impl->m_IsCalibration) {
+                if (impl->m_Flags.testFlag(GraphFlag::EnableSynchronization) && !impl->m_IsCalibration) {
-                        qCDebug(LOG_VisualizationGraphWidget())
+                    qCDebug(LOG_VisualizationGraphWidget())
-                            << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
+                        << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
-                            << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
+                        << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
-                        emit synchronize(graphRange, oldGraphRange);
+                    emit synchronize(graphRange, oldGraphRange);
                 }
                 auto pos = mapFromGlobal(QCursor::pos());
                 auto axisPos = impl->posToAxisPos(pos, plot());
                 if (auto parentZone = parentZoneWidget()) {
                     if (impl->pointIsInAxisRect(axisPos, plot())) {
                         parentZone->notifyMouseMoveInGraph(pos, axisPos, this);
                     }
                     else {
                         parentZone->notifyMouseLeaveGraph(this);
                     }
                 }
                 else {
                     qCWarning(LOG_VisualizationGraphWidget()) << "onMouseMove: No parent zone widget";
                 }
+                // Quits calibration
+                impl->m_IsCalibration = false;
             }
             void VisualizationGraphWidget::onMouseDoubleClick(QMouseEvent *event) noexcept
             {
                 impl->m_RenderingDelegate->onMouseDoubleClick(event);
             }
             void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
             {
                 // Handles plot rendering when mouse is moving
                 impl->m_RenderingDelegate->onMouseMove(event);
                 auto axisPos = impl->posToAxisPos(event->pos(), plot());
                 // Zoom box and zone drawing
                 if (impl->m_DrawingZoomRect) {
                     impl->m_DrawingZoomRect->bottomRight->setCoords(axisPos);
                 }
                 else if (impl->m_DrawingZone) {
                     impl->m_DrawingZone->setEnd(axisPos.x());
                 }
                 // Cursor
                 if (auto parentZone = parentZoneWidget()) {
                     if (impl->pointIsInAxisRect(axisPos, plot())) {
                         parentZone->notifyMouseMoveInGraph(event->pos(), axisPos, this);
                     }
                     else {
                         parentZone->notifyMouseLeaveGraph(this);
                     }
                 }
                 else {
                     qCWarning(LOG_VisualizationGraphWidget()) << "onMouseMove: No parent zone widget";
                 }
                 // Search for the selection zone under the mouse
                 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos(), plot());
                 if (selectionZoneItemUnderCursor && !impl->m_DrawingZone
                     && sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones) {
                     // Sets the appropriate cursor shape
                     auto cursorShape = selectionZoneItemUnderCursor->curshorShapeForPosition(event->pos());
                     setCursor(cursorShape);
                     // Manages the hovered zone
                     if (selectionZoneItemUnderCursor != impl->m_HoveredZone) {
                         if (impl->m_HoveredZone) {
                             impl->m_HoveredZone->setHovered(false);
                         }
                         selectionZoneItemUnderCursor->setHovered(true);
                         impl->m_HoveredZone = selectionZoneItemUnderCursor;
                         plot().replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 else {
                     // There is no zone under the mouse or the interaction mode is not "selection zones"
                     if (impl->m_HoveredZone) {
                         impl->m_HoveredZone->setHovered(false);
                         impl->m_HoveredZone = nullptr;
                     }
                     setCursor(Qt::ArrowCursor);
                 }
                 impl->m_HasMovedMouse = true;
                 VisualizationDragWidget::mouseMoveEvent(event);
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto value = event->angleDelta().x() + event->angleDelta().y();
                 if (value != 0) {
                     auto direction = value > 0 ? 1.0 : -1.0;
                     auto isZoomX = event->modifiers().testFlag(HORIZONTAL_ZOOM_MODIFIER);
                     auto isZoomY = event->modifiers().testFlag(VERTICAL_ZOOM_MODIFIER);
                     impl->m_IsCalibration = event->modifiers().testFlag(VERTICAL_PAN_MODIFIER);
                     auto zoomOrientations = QFlags<Qt::Orientation>{};
                     zoomOrientations.setFlag(Qt::Horizontal, isZoomX);
                     zoomOrientations.setFlag(Qt::Vertical, isZoomY);
                     ui->widget->axisRect()->setRangeZoom(zoomOrientations);
                     if (!isZoomX && !isZoomY) {
                         auto axis = plot().axisRect()->axis(QCPAxis::atBottom);
                         auto diff = direction * (axis->range().size() * (PAN_SPEED / 100.0));
                         axis->setRange(axis->range() + diff);
                         if (plot().noAntialiasingOnDrag()) {
                             plot().setNotAntialiasedElements(QCP::aeAll);
                         }
                         plot().replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
             }
             void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
             {
                 auto isDragDropClick = event->modifiers().testFlag(DRAG_DROP_MODIFIER);
                 auto isSelectionZoneMode
                     = sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones;
                 auto isLeftClick = event->buttons().testFlag(Qt::LeftButton);
                 if (!isDragDropClick && isLeftClick) {
                     if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::ZoomBox) {
                         // Starts a zoom box
                         impl->startDrawingRect(event->pos(), plot());
                     }
                     else if (isSelectionZoneMode && impl->m_DrawingZone == nullptr) {
                         // Starts a new selection zone
                         auto zoneAtPos = impl->selectionZoneAt(event->pos(), plot());
                         if (!zoneAtPos) {
                             impl->startDrawingZone(event->pos(), this);
                         }
                     }
                 }
                 // Allows mouse panning only in default mode
                 plot().setInteraction(QCP::iRangeDrag, sqpApp->plotsInteractionMode()
                                                                == SqpApplication::PlotsInteractionMode::None
                                                            && !isDragDropClick);
                 // Allows zone edition only in selection zone mode without drag&drop
                 impl->setSelectionZonesEditionEnabled(isSelectionZoneMode && !isDragDropClick);
                 // Selection / Deselection
                 if (isSelectionZoneMode) {
                     auto isMultiSelectionClick = event->modifiers().testFlag(MULTI_ZONE_SELECTION_MODIFIER);
                     auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos(), plot());
                     if (selectionZoneItemUnderCursor && !selectionZoneItemUnderCursor->selected()
                         && !isMultiSelectionClick) {
                         parentVisualizationWidget()->selectionZoneManager().select(
                             {selectionZoneItemUnderCursor});
                     }
                     else if (!selectionZoneItemUnderCursor && !isMultiSelectionClick && isLeftClick) {
                         parentVisualizationWidget()->selectionZoneManager().clearSelection();
                     }
                     else {
                         // No selection change
                     }
                     if (selectionZoneItemUnderCursor && isLeftClick) {
                         selectionZoneItemUnderCursor->setAssociatedEditedZones(
                             parentVisualizationWidget()->selectionZoneManager().selectedItems());
                     }
                 }
                 impl->m_HasMovedMouse = false;
                 VisualizationDragWidget::mousePressEvent(event);
             }
             void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
             {
                 if (impl->m_DrawingZoomRect) {
                     auto axisX = plot().axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = plot().axisRect()->axis(QCPAxis::atLeft);
                     auto newAxisXRange = QCPRange{impl->m_DrawingZoomRect->topLeft->coords().x(),
                                                   impl->m_DrawingZoomRect->bottomRight->coords().x()};
                     auto newAxisYRange = QCPRange{impl->m_DrawingZoomRect->topLeft->coords().y(),
                                                   impl->m_DrawingZoomRect->bottomRight->coords().y()};
                     impl->removeDrawingRect(plot());
                     if (newAxisXRange.size() > axisX->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0)
                         && newAxisYRange.size() > axisY->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0)) {
                         impl->m_ZoomStack.push(qMakePair(axisX->range(), axisY->range()));
                         axisX->setRange(newAxisXRange);
                         axisY->setRange(newAxisYRange);
                         plot().replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 impl->endDrawingZone(this);
-                impl->m_IsCalibration = false;
                 // Selection / Deselection
                 auto isSelectionZoneMode
                     = sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones;
                 if (isSelectionZoneMode) {
                     auto isMultiSelectionClick = event->modifiers().testFlag(MULTI_ZONE_SELECTION_MODIFIER);
                     auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos(), plot());
                     if (selectionZoneItemUnderCursor && event->button() == Qt::LeftButton
                         && !impl->m_HasMovedMouse) {
                         auto zonesUnderCursor = impl->selectionZonesAt(event->pos(), plot());
                         if (zonesUnderCursor.count() > 1) {
                             // There are multiple zones under the mouse.
                             // Performs the selection with a selection dialog.
                             VisualizationMultiZoneSelectionDialog dialog{this};
                             dialog.setZones(zonesUnderCursor);
                             dialog.move(mapToGlobal(event->pos() - QPoint(dialog.width() / 2, 20)));
                             dialog.activateWindow();
                             dialog.raise();
                             if (dialog.exec() == QDialog::Accepted) {
                                 auto selection = dialog.selectedZones();
                                 if (!isMultiSelectionClick) {
                                     parentVisualizationWidget()->selectionZoneManager().clearSelection();
                                 }
                                 for (auto it = selection.cbegin(); it != selection.cend(); ++it) {
                                     auto zone = it.key();
                                     auto isSelected = it.value();
                                     parentVisualizationWidget()->selectionZoneManager().setSelected(zone,
                                                                                                     isSelected);
                                     if (isSelected) {
                                         // Puts the zone on top of the stack so it can be moved or resized
                                         impl->moveSelectionZoneOnTop(zone, plot());
                                     }
                                 }
                             }
                         }
                         else {
                             if (!isMultiSelectionClick) {
                                 parentVisualizationWidget()->selectionZoneManager().select(
                                     {selectionZoneItemUnderCursor});
                                 impl->moveSelectionZoneOnTop(selectionZoneItemUnderCursor, plot());
                             }
                             else {
                                 parentVisualizationWidget()->selectionZoneManager().setSelected(
                                     selectionZoneItemUnderCursor, !selectionZoneItemUnderCursor->selected()
                                                                       || event->button() == Qt::RightButton);
                             }
                         }
                     }
                     else {
                         // No selection change
                     }
                 }
             }
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
                 auto graphRange = ui->widget->xAxis->range();
                 auto dateTime = SqpRange{graphRange.lower, graphRange.upper};
                 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
                     auto variable = variableEntry.first;
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
                     if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
                         impl->updateData(variableEntry.second, variable->dataSeries(), variable->range());
                     }
                 }
             }
             void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,
                                                                  const SqpRange &range)
             {
                 auto it = impl->m_VariableToPlotMultiMap.find(variable);
                 if (it != impl->m_VariableToPlotMultiMap.end()) {
                     impl->updateData(it->second, variable->dataSeries(), range);
                 }
             }

gui/src/Visualization/VisualizationZoneWidget.cpp +6 -6

             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/QCustomPlotSynchronizer.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationWidget.h"
             #include "ui_VisualizationZoneWidget.h"
             #include "Common/MimeTypesDef.h"
             #include "Common/VisualizationDef.h"
             #include <Data/SqpRange.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/operations/FindVariableOperation.h>
             #include <DragAndDrop/DragDropGuiController.h>
             #include <QUuid>
             #include <SqpApplication.h>
             #include <cmath>
             #include <QLayout>
             Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
             namespace {
             /**
              * Applies a function to all graphs of the zone represented by its layout
              * @param layout the layout that contains graphs
              * @param fun the function to apply to each graph
              */
             template <typename Fun>
             void processGraphs(QLayout &layout, Fun fun)
             {
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (auto item = layout.itemAt(i)) {
                         if (auto visualizationGraphWidget
                             = qobject_cast<VisualizationGraphWidget *>(item->widget())) {
                             fun(*visualizationGraphWidget);
                         }
                     }
                 }
             }
             /// Generates a default name for a new graph, according to the number of graphs already displayed in
             /// the zone
             QString defaultGraphName(QLayout &layout)
             {
                 QSet<QString> existingNames;
                 processGraphs(
                     layout, [&existingNames](auto &graphWidget) { existingNames.insert(graphWidget.name()); });
                 int zoneNum = 1;
                 QString name;
                 do {
                     name = QObject::tr("Graph ").append(QString::number(zoneNum));
                     ++zoneNum;
                 } while (existingNames.contains(name));
                 return name;
             }
             } // namespace
             struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
                 explicit VisualizationZoneWidgetPrivate()
                         : m_SynchronisationGroupId{QUuid::createUuid()},
                           m_Synchronizer{std::make_unique<QCustomPlotSynchronizer>()}
                 {
                 }
                 QUuid m_SynchronisationGroupId;
                 std::unique_ptr<IGraphSynchronizer> m_Synchronizer;
                 void dropGraph(int index, VisualizationZoneWidget *zoneWidget);
                 void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
                                    VisualizationZoneWidget *zoneWidget);
             };
             VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
                     : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationZoneWidget},
                       impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 ui->zoneNameLabel->setText(name);
                 ui->dragDropContainer->setPlaceHolderType(DragDropGuiController::PlaceHolderType::Graph);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_GRAPH,
                                                    VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setMimeType(
                     MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_TIME_RANGE,
                                                    VisualizationDragDropContainer::DropBehavior::Merged);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_ZONE,
                                                    VisualizationDragDropContainer::DropBehavior::Forbidden);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_SELECTION_ZONE,
                                                    VisualizationDragDropContainer::DropBehavior::Forbidden);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropGuiController().checkMimeDataForVisualization(mimeData,
                                                                                          ui->dragDropContainer);
                 });
                 auto acceptDragWidgetFun = [](auto dragWidget, auto mimeData) {
                     if (!mimeData) {
                         return false;
                     }
                     if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                         auto variables = sqpApp->variableController().variablesForMimeData(
                             mimeData->data(MIME_TYPE_VARIABLE_LIST));
                         if (variables.count() != 1) {
                             return false;
                         }
                         auto variable = variables.first();
                         if (auto graphWidget = dynamic_cast<const VisualizationGraphWidget *>(dragWidget)) {
                             return graphWidget->canDrop(*variable);
                         }
                     }
                     return true;
                 };
                 ui->dragDropContainer->setAcceptDragWidgetFunction(acceptDragWidgetFun);
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
                         &VisualizationZoneWidget::dropMimeData);
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredOnWidget, this,
                         &VisualizationZoneWidget::dropMimeDataOnGraph);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                 // Synchronisation id
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             VisualizationZoneWidget::~VisualizationZoneWidget()
             {
                 delete ui;
             }
             void VisualizationZoneWidget::setZoneRange(const SqpRange &range)
             {
                 if (auto graph = firstGraph()) {
                     graph->setGraphRange(range);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("setZoneRange:Cannot set the range of an empty zone.");
                 }
             }
             void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
             {
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->addDragWidget(graphWidget);
             }
             void VisualizationZoneWidget::insertGraph(int index, VisualizationGraphWidget *graphWidget)
             {
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->insertDragWidget(index, graphWidget);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
             {
                 return createGraph(variable, -1);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable,
                                                                            int index)
             {
                 auto graphWidget
                     = new VisualizationGraphWidget{defaultGraphName(*ui->dragDropContainer->layout()), this};
                 // Set graph properties
                 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
                 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
                 // Lambda to synchronize zone widget
                 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &graphRange,
                                                                  const SqpRange &oldGraphRange) {
                     auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
                     auto frameLayout = ui->dragDropContainer->layout();
                     for (auto i = 0; i < frameLayout->count(); ++i) {
                         auto graphChild
                             = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
                         if (graphChild && (graphChild != graphWidget)) {
                             auto graphChildRange = graphChild->graphRange();
                             switch (zoomType) {
                                 case AcquisitionZoomType::ZoomIn: {
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                            << deltaLeft;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                            << deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::ZoomOut: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                            << deltaLeft;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                            << deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanRight: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanLeft: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     break;
                                 }
                                 case AcquisitionZoomType::Unknown: {
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type unknown");
                                     break;
                                 }
                                 default:
                                     qCCritical(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type not take into account");
                                     // No action
                                     break;
                             }
-                            graphChild->enableAcquisition(false);
+                            graphChild->setFlags(GraphFlag::DisableAll);
-                            qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
+                            qCDebug(LOG_VisualizationZoneWidget())
-                                                                   << graphChild->graphRange();
+                                << tr("TORM: Range before: ") << graphChild->graphRange();
-                            qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
+                            qCDebug(LOG_VisualizationZoneWidget())
-                                                                   << graphChildRange;
+                                << tr("TORM: Range after : ") << graphChildRange;
                             qCDebug(LOG_VisualizationZoneWidget())
                                 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                             graphChild->setGraphRange(graphChildRange);
-                            graphChild->enableAcquisition(true);
+                            graphChild->setFlags(GraphFlag::EnableAll);
                         }
                     }
                 };
                 // connection for synchronization
                 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
                 connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
                         &VisualizationZoneWidget::onVariableAdded);
                 connect(graphWidget, &VisualizationGraphWidget::variableAboutToBeRemoved, this,
                         &VisualizationZoneWidget::onVariableAboutToBeRemoved);
                 auto range = SqpRange{};
                 if (auto firstGraph = this->firstGraph()) {
                     // Case of a new graph in a existant zone
                     range = firstGraph->graphRange();
                 }
                 else {
                     // Case of a new graph as the first of the zone
                     range = variable->range();
                 }
                 this->insertGraph(index, graphWidget);
                 graphWidget->addVariable(variable, range);
                 graphWidget->setYRange(variable);
                 return graphWidget;
             }
             VisualizationGraphWidget *
             VisualizationZoneWidget::createGraph(const QList<std::shared_ptr<Variable> > variables, int index)
             {
                 if (variables.isEmpty()) {
                     return nullptr;
                 }
                 auto graphWidget = createGraph(variables.first(), index);
                 for (auto variableIt = variables.cbegin() + 1; variableIt != variables.cend(); ++variableIt) {
                     graphWidget->addVariable(*variableIt, graphWidget->graphRange());
                 }
                 return graphWidget;
             }
             VisualizationGraphWidget *VisualizationZoneWidget::firstGraph() const
             {
                 VisualizationGraphWidget *firstGraph = nullptr;
                 auto layout = ui->dragDropContainer->layout();
                 if (layout->count() > 0) {
                     if (auto visualizationGraphWidget
                         = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                         firstGraph = visualizationGraphWidget;
                     }
                 }
                 return firstGraph;
             }
             void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to graph children: widgets different from graphs are not visited (no
                     // action)
                     processGraphs(
                         *ui->dragDropContainer->layout(),
                         [visitor](VisualizationGraphWidget &graphWidget) { graphWidget.accept(visitor); });
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationZoneWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationZoneWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationZoneWidget::name() const
             {
                 return ui->zoneNameLabel->text();
             }
             QMimeData *VisualizationZoneWidget::mimeData(const QPoint &position) const
             {
                 Q_UNUSED(position);
                 auto mimeData = new QMimeData;
                 mimeData->setData(MIME_TYPE_ZONE, QByteArray{});
                 if (auto firstGraph = this->firstGraph()) {
                     auto timeRangeData = TimeController::mimeDataForTimeRange(firstGraph->graphRange());
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
                 }
                 return mimeData;
             }
             bool VisualizationZoneWidget::isDragAllowed() const
             {
                 return true;
             }
             void VisualizationZoneWidget::notifyMouseMoveInGraph(const QPointF &graphPosition,
                                                                  const QPointF &plotPosition,
                                                                  VisualizationGraphWidget *graphWidget)
             {
                 processGraphs(*ui->dragDropContainer->layout(), [&graphPosition, &plotPosition, &graphWidget](
                                                                     VisualizationGraphWidget &processedGraph) {
                     switch (sqpApp->plotsCursorMode()) {
                         case SqpApplication::PlotsCursorMode::Vertical:
                             processedGraph.removeHorizontalCursor();
                             processedGraph.addVerticalCursorAtViewportPosition(graphPosition.x());
                             break;
                         case SqpApplication::PlotsCursorMode::Temporal:
                             processedGraph.addVerticalCursor(plotPosition.x());
                             processedGraph.removeHorizontalCursor();
                             break;
                         case SqpApplication::PlotsCursorMode::Horizontal:
                             processedGraph.removeVerticalCursor();
                             if (&processedGraph == graphWidget) {
                                 processedGraph.addHorizontalCursorAtViewportPosition(graphPosition.y());
                             }
                             else {
                                 processedGraph.removeHorizontalCursor();
                             }
                             break;
                         case SqpApplication::PlotsCursorMode::Cross:
                             if (&processedGraph == graphWidget) {
                                 processedGraph.addVerticalCursorAtViewportPosition(graphPosition.x());
                                 processedGraph.addHorizontalCursorAtViewportPosition(graphPosition.y());
                             }
                             else {
                                 processedGraph.removeHorizontalCursor();
                                 processedGraph.removeVerticalCursor();
                             }
                             break;
                         case SqpApplication::PlotsCursorMode::NoCursor:
                             processedGraph.removeHorizontalCursor();
                             processedGraph.removeVerticalCursor();
                             break;
                     }
                 });
             }
             void VisualizationZoneWidget::notifyMouseLeaveGraph(VisualizationGraphWidget *graphWidget)
             {
                 processGraphs(*ui->dragDropContainer->layout(), [](VisualizationGraphWidget &processedGraph) {
                     processedGraph.removeHorizontalCursor();
                     processedGraph.removeVerticalCursor();
                 });
             }
             void VisualizationZoneWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes graphs in the zone
                 processGraphs(*ui->dragDropContainer->layout(),
                               [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
                 // Delete synchronization group from variable controller
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onRemoveSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
                 QWidget::closeEvent(event);
             }
             void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
                                           Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "desynchronize", Qt::QueuedConnection,
                                           Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::dropMimeData(int index, const QMimeData *mimeData)
             {
                 if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
                     impl->dropGraph(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     impl->dropVariables(variables, index, this);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeData, unknown MIME data received.");
                 }
             }
             void VisualizationZoneWidget::dropMimeDataOnGraph(VisualizationDragWidget *dragWidget,
                                                               const QMimeData *mimeData)
             {
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(dragWidget);
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeDataOnGraph, dropping in an unknown widget, "
                               "drop aborted");
                     Q_ASSERT(false);
                     return;
                 }
                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     for (const auto &var : variables) {
                         graphWidget->addVariable(var, graphWidget->graphRange());
                     }
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_TIME_RANGE)) {
                     auto range = TimeController::timeRangeForMimeData(mimeData->data(MIME_TYPE_TIME_RANGE));
                     graphWidget->setGraphRange(range);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeDataOnGraph, unknown MIME data received.");
                 }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropGraph(
                 int index, VisualizationZoneWidget *zoneWidget)
             {
                 auto &helper = sqpApp->dragDropGuiController();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the dropped graph is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the parent container of "
                               "the dropped graph is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 const auto &variables = graphWidget->variables();
                 if (parentDragDropContainer != zoneWidget->ui->dragDropContainer && !variables.isEmpty()) {
                     // The drop didn't occur in the same zone
                     // Abort the requests for the variables (if any)
                     // Commented, because it's not sure if it's needed or not
                     // for (const auto& var : variables)
                     //{
                     //    sqpApp->variableController().onAbortProgressRequested(var);
                     //}
                     auto previousParentZoneWidget = graphWidget->parentZoneWidget();
                     auto nbGraph = parentDragDropContainer->countDragWidget();
                     if (nbGraph == 1) {
                         // This is the only graph in the previous zone, close the zone
                         helper.delayedCloseWidget(previousParentZoneWidget);
                     }
                     else {
                         // Close the graph
                         helper.delayedCloseWidget(graphWidget);
                     }
                     // Creates the new graph in the zone
                     auto newGraphWidget = zoneWidget->createGraph(variables, index);
                     newGraphWidget->addSelectionZones(graphWidget->selectionZoneRanges());
                 }
                 else {
                     // The drop occurred in the same zone or the graph is empty
                     // Simple move of the graph, no variable operation associated
                     parentDragDropContainer->layout()->removeWidget(graphWidget);
                     if (variables.isEmpty() && parentDragDropContainer != zoneWidget->ui->dragDropContainer) {
                         // The graph is empty and dropped in a different zone.
                         // Take the range of the first graph in the zone (if existing).
                         auto layout = zoneWidget->ui->dragDropContainer->layout();
                         if (layout->count() > 0) {
                             if (auto visualizationGraphWidget
                                 = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                                 graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
                             }
                         }
                     }
                     zoneWidget->ui->dragDropContainer->insertDragWidget(index, graphWidget);
                 }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropVariables(
                 const QList<std::shared_ptr<Variable> > &variables, int index,
                 VisualizationZoneWidget *zoneWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
                 if (variables.count() > 1) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropVariables, dropping multiple variables, operation "
                               "aborted.");
                     return;
                 }
                 zoneWidget->createGraph(variables, index);
             }

gui/src/Visualization/operations/RescaleAxeOperation.cpp +4 -2

             #include "Visualization/operations/RescaleAxeOperation.h"
             #include "Visualization/VisualizationGraphWidget.h"
             Q_LOGGING_CATEGORY(LOG_RescaleAxeOperation, "RescaleAxeOperation")
             struct RescaleAxeOperation::RescaleAxeOperationPrivate {
                 explicit RescaleAxeOperationPrivate(std::shared_ptr<Variable> variable, const SqpRange &range)
                         : m_Variable{variable}, m_Range{range}
                 {
                 }
                 std::shared_ptr<Variable> m_Variable;
                 SqpRange m_Range;
             };
             RescaleAxeOperation::RescaleAxeOperation(std::shared_ptr<Variable> variable, const SqpRange &range)
                     : impl{spimpl::make_unique_impl<RescaleAxeOperationPrivate>(variable, range)}
             {
             }
             void RescaleAxeOperation::visitEnter(VisualizationWidget *widget)
             {
                 // VisualizationWidget is not intended to contain a variable
                 Q_UNUSED(widget)
             }
             void RescaleAxeOperation::visitLeave(VisualizationWidget *widget)
             {
                 // VisualizationWidget is not intended to contain a variable
                 Q_UNUSED(widget)
             }
             void RescaleAxeOperation::visitEnter(VisualizationTabWidget *tabWidget)
             {
                 // VisualizationTabWidget is not intended to contain a variable
                 Q_UNUSED(tabWidget)
             }
             void RescaleAxeOperation::visitLeave(VisualizationTabWidget *tabWidget)
             {
                 // VisualizationTabWidget is not intended to contain a variable
                 Q_UNUSED(tabWidget)
             }
             void RescaleAxeOperation::visitEnter(VisualizationZoneWidget *zoneWidget)
             {
                 // VisualizationZoneWidget is not intended to contain a variable
                 Q_UNUSED(zoneWidget)
             }
             void RescaleAxeOperation::visitLeave(VisualizationZoneWidget *zoneWidget)
             {
                 // VisualizationZoneWidget is not intended to contain a variable
                 Q_UNUSED(zoneWidget)
             }
             void RescaleAxeOperation::visit(VisualizationGraphWidget *graphWidget)
             {
                 if (graphWidget) {
                     // If the widget contains the variable, rescale it
                     if (impl->m_Variable && graphWidget->contains(*impl->m_Variable)) {
-                        graphWidget->enableAcquisition(false);
+                        // During rescale, acquisition for the graph is disabled but synchronization is still
+                        // enabled
+                        graphWidget->setFlags(GraphFlag::EnableSynchronization);
                         graphWidget->setGraphRange(impl->m_Range);
-                        graphWidget->enableAcquisition(true);
+                        graphWidget->setFlags(GraphFlag::EnableAll);
                     }
                 }
                 else {
                     qCCritical(LOG_RescaleAxeOperation(),
                                "Can't visit VisualizationGraphWidget : the widget is null");
                 }
             }

plugins/amda/tests/FuzzingDefs.cpp +18 -9

             #include "FuzzingDefs.h"
             const QString ACQUISITION_TIMEOUT_PROPERTY = QStringLiteral("acquisitionTimeout");
             const QString NB_MAX_OPERATIONS_PROPERTY = QStringLiteral("component");
             const QString NB_MAX_SYNC_GROUPS_PROPERTY = QStringLiteral("nbSyncGroups");
             const QString NB_MAX_VARIABLES_PROPERTY = QStringLiteral("nbMaxVariables");
             const QString AVAILABLE_OPERATIONS_PROPERTY = QStringLiteral("availableOperations");
             const QString CACHE_TOLERANCE_PROPERTY = QStringLiteral("cacheTolerance");
             const QString INITIAL_RANGE_PROPERTY = QStringLiteral("initialRange");
             const QString MAX_RANGE_PROPERTY = QStringLiteral("maxRange");
             const QString METADATA_POOL_PROPERTY = QStringLiteral("metadataPool");
             const QString PROVIDER_PROPERTY = QStringLiteral("provider");
             const QString OPERATION_DELAY_BOUNDS_PROPERTY = QStringLiteral("operationDelays");
             const QString VALIDATORS_PROPERTY = QStringLiteral("validators");
             const QString VALIDATION_FREQUENCY_BOUNDS_PROPERTY = QStringLiteral("validationFrequencyBounds");
             // //////////// //
             // FuzzingState //
             // //////////// //
             const SyncGroup &FuzzingState::syncGroup(SyncGroupId id) const
             {
                 return m_SyncGroupsPool.at(id);
             }
             SyncGroup &FuzzingState::syncGroup(SyncGroupId id)
             {
                 return m_SyncGroupsPool.at(id);
             }
             const VariableState &FuzzingState::variableState(VariableId id) const
             {
                 return m_VariablesPool.at(id);
             }
             VariableState &FuzzingState::variableState(VariableId id)
             {
                 return m_VariablesPool.at(id);
             }
             SyncGroupId FuzzingState::syncGroupId(VariableId variableId) const
             {
                 auto end = m_SyncGroupsPool.cend();
                 auto it
                     = std::find_if(m_SyncGroupsPool.cbegin(), end, [&variableId](const auto &syncGroupEntry) {
                           const auto &syncGroup = syncGroupEntry.second;
                           return syncGroup.m_Variables.find(variableId) != syncGroup.m_Variables.end();
                       });
                 return it != end ? it->first : SyncGroupId{};
             }
             std::vector<SyncGroupId> FuzzingState::syncGroupsIds() const
             {
                 std::vector<SyncGroupId> result{};
                 for (const auto &entry : m_SyncGroupsPool) {
                     result.push_back(entry.first);
                 }
                 return result;
             }
             void FuzzingState::synchronizeVariable(VariableId variableId, SyncGroupId syncGroupId)
             {
                 if (syncGroupId.isNull()) {
                     return;
                 }
-                // Registers variable into sync group: if it's the first variable, sets the variable range as
+                // Registers variable into sync group
-                // the sync group range
                 auto &syncGroup = m_SyncGroupsPool.at(syncGroupId);
+                auto &variableState = m_VariablesPool.at(variableId);
                 syncGroup.m_Variables.insert(variableId);
                 if (syncGroup.m_Variables.size() == 1) {
-                    auto &variableState = m_VariablesPool.at(variableId);
+                    // If it's the first variable, sets the variable range as the sync group range
                     syncGroup.m_Range = variableState.m_Range;
                 }
+                else {
+                    // If a variable is added to an existing group, sets its range to the group's range
+                    variableState.m_Range = syncGroup.m_Range;
+                }
             }
             void FuzzingState::desynchronizeVariable(VariableId variableId, SyncGroupId syncGroupId)
             {
                 if (syncGroupId.isNull()) {
                     return;
                 }
                 // Unregisters variable from sync group: if there is no more variable in the group, resets the
                 // range
                 auto &syncGroup = m_SyncGroupsPool.at(syncGroupId);
                 syncGroup.m_Variables.erase(variableId);
                 if (syncGroup.m_Variables.empty()) {
                     syncGroup.m_Range = INVALID_RANGE;
                 }
             }
             void FuzzingState::updateRanges(VariableId variableId, const SqpRange &newRange)
             {
                 auto syncGroupId = this->syncGroupId(variableId);
                 // Retrieves the variables to update:
-                // - if the variable is synchronized to others, updates all synchronized variables
+                // - if the variable is synchronized to others, updates the range of the group and of all
+                // synchronized variables
                 // - otherwise, updates only the variable
-                auto variablesToUpdate = syncGroupId.isNull() ? std::set<VariableId>{variableId}
+                if (syncGroupId.isNull()) {
-                                                              : m_SyncGroupsPool.at(syncGroupId).m_Variables;
-                // Sets new range
-                for (const auto &variableId : variablesToUpdate) {
                     m_VariablesPool.at(variableId).m_Range = newRange;
                 }
+                else {
+                    auto &syncGroup = m_SyncGroupsPool.at(syncGroupId);
+                    syncGroup.m_Range = newRange;
+                    for (const auto &variableId : syncGroup.m_Variables) {
+                        m_VariablesPool.at(variableId).m_Range = newRange;
+                    }
+                }
             }

plugins/amda/tests/FuzzingOperations.cpp +4 -1

             #include "FuzzingOperations.h"
             #include "FuzzingUtils.h"
             #include <Data/IDataProvider.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <QUuid>
             #include <functional>
             Q_LOGGING_CATEGORY(LOG_FuzzingOperations, "FuzzingOperations")
             namespace {
             struct CreateOperation : public IFuzzingOperation {
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     // A variable can be created only if it doesn't exist yet
                     return fuzzingState.variableState(variableId).m_Variable == nullptr;
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController,
                              const Properties &properties) const override
                 {
                     // Retrieves metadata pool from properties, and choose one of the metadata entries to
                     // associate it with the variable
                     auto metaDataPool = properties.value(METADATA_POOL_PROPERTY).value<MetadataPool>();
                     auto variableMetadata = RandomGenerator::instance().randomChoice(metaDataPool);
                     // Retrieves provider
                     auto variableProvider
                         = properties.value(PROVIDER_PROPERTY).value<std::shared_ptr<IDataProvider> >();
                     auto variableName = QString{"Var_%1"}.arg(QUuid::createUuid().toString());
                     qCInfo(LOG_FuzzingOperations()).noquote() << "Creating variable" << variableName
                                                               << "(metadata:" << variableMetadata << ")...";
                     auto newVariable
                         = variableController.createVariable(variableName, variableMetadata, variableProvider);
                     // Updates variable's state
                     auto &variableState = fuzzingState.variableState(variableId);
                     variableState.m_Range = properties.value(INITIAL_RANGE_PROPERTY).value<SqpRange>();
                     std::swap(variableState.m_Variable, newVariable);
                 }
             };
             struct DeleteOperation : public IFuzzingOperation {
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     // A variable can be delete only if it exists
                     return fuzzingState.variableState(variableId).m_Variable != nullptr;
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController, const Properties &) const override
                 {
                     auto &variableState = fuzzingState.variableState(variableId);
                     qCInfo(LOG_FuzzingOperations()).noquote() << "Deleting variable"
                                                               << variableState.m_Variable->name() << "...";
                     variableController.deleteVariable(variableState.m_Variable);
                     // Updates variable's state
                     variableState.m_Range = INVALID_RANGE;
                     variableState.m_Variable = nullptr;
                     // Desynchronizes the variable if it was in a sync group
                     auto syncGroupId = fuzzingState.syncGroupId(variableId);
                     fuzzingState.desynchronizeVariable(variableId, syncGroupId);
                 }
             };
             /**
              * Defines a move operation through a range.
              *
              * A move operation is determined by three functions:
              * - Two 'move' functions, used to indicate in which direction the beginning and the end of a range
              * are going during the operation. These functions will be:
              * -- {<- / <-} for pan left
              * -- {-> / ->} for pan right
              * -- {-> / <-} for zoom in
              * -- {<- / ->} for zoom out
              * - One 'max move' functions, used to compute the max delta at which the operation can move a
              * range, according to a max range. For exemple, for a range of {1, 5} and a max range of {0, 10},
              * max deltas will be:
              * -- {0, 4} for pan left
              * -- {6, 10} for pan right
              * -- {3, 3} for zoom in
              * -- {0, 6} for zoom out (same spacing left and right)
              */
             struct MoveOperation : public IFuzzingOperation {
                 using MoveFunction = std::function<double(double currentValue, double maxValue)>;
                 using MaxMoveFunction = std::function<double(const SqpRange &range, const SqpRange &maxRange)>;
                 explicit MoveOperation(MoveFunction rangeStartMoveFun, MoveFunction rangeEndMoveFun,
                                        MaxMoveFunction maxMoveFun,
                                        const QString &label = QStringLiteral("Move operation"))
                         : m_RangeStartMoveFun{std::move(rangeStartMoveFun)},
                           m_RangeEndMoveFun{std::move(rangeEndMoveFun)},
                           m_MaxMoveFun{std::move(maxMoveFun)},
                           m_Label{label}
                 {
                 }
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     return fuzzingState.variableState(variableId).m_Variable != nullptr;
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController,
                              const Properties &properties) const override
                 {
                     auto &variableState = fuzzingState.variableState(variableId);
                     auto variable = variableState.m_Variable;
                     // Gets the max range defined
                     auto maxRange = properties.value(MAX_RANGE_PROPERTY, QVariant::fromValue(INVALID_RANGE))
                                         .value<SqpRange>();
                     auto variableRange = variableState.m_Range;
                     if (maxRange == INVALID_RANGE || variableRange.m_TStart < maxRange.m_TStart
                         || variableRange.m_TEnd > maxRange.m_TEnd) {
                         qCWarning(LOG_FuzzingOperations()) << "Can't execute operation: invalid max range";
                         return;
                     }
                     // Computes the max delta at which the variable can move, up to the limits of the max range
                     auto deltaMax = m_MaxMoveFun(variableRange, maxRange);
                     // Generates random delta that will be used to move variable
                     auto delta = RandomGenerator::instance().generateDouble(0, deltaMax);
                     // Moves variable to its new range
                     auto isSynchronized = !fuzzingState.syncGroupId(variableId).isNull();
                     auto newVariableRange = SqpRange{m_RangeStartMoveFun(variableRange.m_TStart, delta),
                                                      m_RangeEndMoveFun(variableRange.m_TEnd, delta)};
                     qCInfo(LOG_FuzzingOperations()).noquote() << "Performing" << m_Label << "on"
                                                               << variable->name() << "(from" << variableRange
                                                               << "to" << newVariableRange << ")...";
                     variableController.onRequestDataLoading({variable}, newVariableRange, isSynchronized);
                     // Updates state
                     fuzzingState.updateRanges(variableId, newVariableRange);
                 }
                 MoveFunction m_RangeStartMoveFun;
                 MoveFunction m_RangeEndMoveFun;
                 MaxMoveFunction m_MaxMoveFun;
                 QString m_Label;
             };
             struct SynchronizeOperation : public IFuzzingOperation {
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     auto variable = fuzzingState.variableState(variableId).m_Variable;
                     return variable != nullptr && !fuzzingState.m_SyncGroupsPool.empty()
                            && fuzzingState.syncGroupId(variableId).isNull();
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController, const Properties &) const override
                 {
                     auto &variableState = fuzzingState.variableState(variableId);
                     // Chooses a random synchronization group and adds the variable into sync group
                     auto syncGroupId = RandomGenerator::instance().randomChoice(fuzzingState.syncGroupsIds());
                     qCInfo(LOG_FuzzingOperations()).noquote() << "Adding" << variableState.m_Variable->name()
                                                               << "into synchronization group" << syncGroupId
                                                               << "...";
                     variableController.onAddSynchronized(variableState.m_Variable, syncGroupId);
                     // Updates state
                     fuzzingState.synchronizeVariable(variableId, syncGroupId);
+                    variableController.onRequestDataLoading({variableState.m_Variable}, variableState.m_Range,
+                                                            false);
                 }
             };
             struct DesynchronizeOperation : public IFuzzingOperation {
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     auto variable = fuzzingState.variableState(variableId).m_Variable;
                     return variable != nullptr && !fuzzingState.syncGroupId(variableId).isNull();
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController, const Properties &) const override
                 {
                     auto &variableState = fuzzingState.variableState(variableId);
                     // Gets the sync group of the variable
                     auto syncGroupId = fuzzingState.syncGroupId(variableId);
                     qCInfo(LOG_FuzzingOperations()).noquote() << "Removing" << variableState.m_Variable->name()
                                                               << "from synchronization group" << syncGroupId
                                                               << "...";
-                    variableController.onAddSynchronized(variableState.m_Variable, syncGroupId);
+                    variableController.desynchronize(variableState.m_Variable, syncGroupId);
                     // Updates state
                     fuzzingState.desynchronizeVariable(variableId, syncGroupId);
                 }
             };
             struct UnknownOperation : public IFuzzingOperation {
                 bool canExecute(VariableId, const FuzzingState &) const override { return false; }
                 void execute(VariableId, FuzzingState &, VariableController &,
                              const Properties &) const override
                 {
                 }
             };
             } // namespace
             std::unique_ptr<IFuzzingOperation> FuzzingOperationFactory::create(FuzzingOperationType type)
             {
                 switch (type) {
                     case FuzzingOperationType::CREATE:
                         return std::make_unique<CreateOperation>();
                     case FuzzingOperationType::DELETE:
                         return std::make_unique<DeleteOperation>();
                     case FuzzingOperationType::PAN_LEFT:
                         return std::make_unique<MoveOperation>(
                             std::minus<double>(), std::minus<double>(),
                             [](const SqpRange &range, const SqpRange &maxRange) {
                                 return range.m_TStart - maxRange.m_TStart;
                             },
                             QStringLiteral("Pan left operation"));
                     case FuzzingOperationType::PAN_RIGHT:
                         return std::make_unique<MoveOperation>(
                             std::plus<double>(), std::plus<double>(),
                             [](const SqpRange &range, const SqpRange &maxRange) {
                                 return maxRange.m_TEnd - range.m_TEnd;
                             },
                             QStringLiteral("Pan right operation"));
                     case FuzzingOperationType::ZOOM_IN:
                         return std::make_unique<MoveOperation>(
                             std::plus<double>(), std::minus<double>(),
                             [](const SqpRange &range, const SqpRange &maxRange) {
                                 Q_UNUSED(maxRange)
                                 return range.m_TEnd - (range.m_TStart + range.m_TEnd) / 2.;
                             },
                             QStringLiteral("Zoom in operation"));
                     case FuzzingOperationType::ZOOM_OUT:
                         return std::make_unique<MoveOperation>(
                             std::minus<double>(), std::plus<double>(),
                             [](const SqpRange &range, const SqpRange &maxRange) {
                                 return std::min(range.m_TStart - maxRange.m_TStart,
                                                 maxRange.m_TEnd - range.m_TEnd);
                             },
                             QStringLiteral("Zoom out operation"));
                     case FuzzingOperationType::SYNCHRONIZE:
                         return std::make_unique<SynchronizeOperation>();
                     case FuzzingOperationType::DESYNCHRONIZE:
                         return std::make_unique<DesynchronizeOperation>();
                     default:
                         // Default case returns unknown operation
                         break;
                 }
                 return std::make_unique<UnknownOperation>();
             }

plugins/amda/tests/FuzzingValidators.cpp +1 -1

             #include "FuzzingValidators.h"
             #include "FuzzingDefs.h"
             #include <Data/DataSeries.h>
             #include <Variable/Variable.h>
             #include <QTest>
             #include <functional>
             Q_LOGGING_CATEGORY(LOG_FuzzingValidators, "FuzzingValidators")
             namespace {
             // ////////////// //
             // DATA VALIDATOR //
             // ////////////// //
             /// Singleton used to validate data of a variable
             class DataValidatorHelper {
             public:
                 /// @return the single instance of the helper
                 static DataValidatorHelper &instance();
                 virtual ~DataValidatorHelper() noexcept = default;
                 virtual void validate(const VariableState &variableState) const = 0;
             };
             /**
              * Default implementation of @sa DataValidatorHelper
              */
             class DefaultDataValidatorHelper : public DataValidatorHelper {
             public:
                 void validate(const VariableState &variableState) const override
                 {
                     Q_UNUSED(variableState);
                     qCWarning(LOG_FuzzingValidators()).noquote() << "Checking variable's data... WARN: no data "
                                                                     "verification is available for this server";
                 }
             };
             /// Data resolution in local server's files
             const auto LOCALHOST_SERVER_RESOLUTION = 4;
             /// Reference value used to generate the data on the local server (a value is the number of seconds
             /// between the data date and this reference date)
             const auto LOCALHOST_REFERENCE_VALUE
                 = DateUtils::secondsSinceEpoch(QDateTime{QDate{2000, 1, 1}, QTime{}, Qt::UTC});
             /**
              * Implementation of @sa DataValidatorHelper for the local AMDA server
              */
             class LocalhostServerDataValidatorHelper : public DataValidatorHelper {
             public:
                 void validate(const VariableState &variableState) const override
                 {
                     // Don't check data for null variable
                     if (!variableState.m_Variable || variableState.m_Range == INVALID_RANGE) {
                         return;
                     }
                     auto message = "Checking variable's data...";
                     auto toDateString = [](double value) { return DateUtils::dateTime(value).toString(); };
                     // Checks that data are defined
                     auto variableDataSeries = variableState.m_Variable->dataSeries();
                     if (variableDataSeries == nullptr && variableState.m_Range != INVALID_RANGE) {
                         qCInfo(LOG_FuzzingValidators()).noquote()
                             << message << "FAIL: the variable has no data while a range is defined";
                         QFAIL("");
                     }
                     auto dataIts = variableDataSeries->xAxisRange(variableState.m_Range.m_TStart,
                                                                   variableState.m_Range.m_TEnd);
                     // Checks that the data are well defined in the range:
                     // - there is at least one data
                     // - the data are consistent (no data holes)
                     if (std::distance(dataIts.first, dataIts.second) == 0) {
                         qCInfo(LOG_FuzzingValidators()).noquote() << message
                                                                   << "FAIL: the variable has no data";
                         QFAIL("");
                     }
                     auto firstXAxisData = dataIts.first->x();
                     auto lastXAxisData = (dataIts.second - 1)->x();
                     if (std::abs(firstXAxisData - variableState.m_Range.m_TStart) > LOCALHOST_SERVER_RESOLUTION
                         || std::abs(lastXAxisData - variableState.m_Range.m_TEnd)
                                > LOCALHOST_SERVER_RESOLUTION) {
                         qCInfo(LOG_FuzzingValidators()).noquote()
                             << message << "FAIL: the data in the defined range are inconsistent (data hole "
                                           "found at the beginning or the end)";
                         QFAIL("");
                     }
                     auto dataHoleIt = std::adjacent_find(
                         dataIts.first, dataIts.second, [](const auto &it1, const auto &it2) {
                             /// @todo: validate resolution
-                            return std::abs(it1.x() - it2.x()) > 2 * (LOCALHOST_SERVER_RESOLUTION - 1);
+                            return std::abs(it1.x() - it2.x()) > 2 * LOCALHOST_SERVER_RESOLUTION;
                         });
                     if (dataHoleIt != dataIts.second) {
                         qCInfo(LOG_FuzzingValidators()).noquote()
                             << message << "FAIL: the data in the defined range are inconsistent (data hole "
                                           "found between times "
                             << toDateString(dataHoleIt->x()) << "and " << toDateString((dataHoleIt + 1)->x())
                             << ")";
                         QFAIL("");
                     }
                     // Checks values
                     auto dataIndex = 0;
                     for (auto dataIt = dataIts.first; dataIt != dataIts.second; ++dataIt, ++dataIndex) {
                         auto xAxisData = dataIt->x();
                         auto valuesData = dataIt->values();
                         for (auto valueIndex = 0, valueEnd = valuesData.size(); valueIndex < valueEnd;
                              ++valueIndex) {
                             auto value = valuesData.at(valueIndex);
                             auto expectedValue = xAxisData + valueIndex * LOCALHOST_SERVER_RESOLUTION
                                                  - LOCALHOST_REFERENCE_VALUE;
                             if (value != expectedValue) {
                                 qCInfo(LOG_FuzzingValidators()).noquote()
                                     << message << "FAIL: incorrect value data at time"
                                     << toDateString(xAxisData) << ", index" << valueIndex << "(found:" << value
                                     << ", expected:" << expectedValue << ")";
                                 QFAIL("");
                             }
                         }
                     }
                     // At this step validation is OK
                     qCInfo(LOG_FuzzingValidators()).noquote() << message << "OK";
                 }
             };
             /// Creates the @sa DataValidatorHelper according to the server passed in parameter
             std::unique_ptr<DataValidatorHelper> createDataValidatorInstance(const QString &server)
             {
                 if (server == QString{"localhost"}) {
                     return std::make_unique<LocalhostServerDataValidatorHelper>();
                 }
                 else {
                     return std::make_unique<DefaultDataValidatorHelper>();
                 }
             }
             DataValidatorHelper &DataValidatorHelper::instance()
             {
                 // Creates instance depending on the SCIQLOP_AMDA_SERVER value at compile time
                 static auto instance = createDataValidatorInstance(SCIQLOP_AMDA_SERVER);
                 return *instance;
             }
             // /////////////// //
             // RANGE VALIDATOR //
             // /////////////// //
             /**
              * Checks that a range of a variable matches the expected range passed as a parameter
              * @param variable the variable for which to check the range
              * @param expectedRange the expected range
              * @param getVariableRangeFun the function to retrieve the range from the variable
              * @remarks if the variable is null, checks that the expected range is the invalid range
              */
             void validateRange(std::shared_ptr<Variable> variable, const SqpRange &expectedRange,
                                std::function<SqpRange(const Variable &)> getVariableRangeFun)
             {
                 auto compare = [](const auto &range, const auto &expectedRange, const auto &message) {
                     if (range == expectedRange) {
                         qCInfo(LOG_FuzzingValidators()).noquote() << message << "OK";
                     }
                     else {
                         qCInfo(LOG_FuzzingValidators()).noquote() << message << "FAIL (current range:" << range
                                                                   << ", expected range:" << expectedRange
                                                                   << ")";
                         QFAIL("");
                     }
                 };
                 if (variable) {
                     compare(getVariableRangeFun(*variable), expectedRange, "Checking variable's range...");
                 }
                 else {
                     compare(INVALID_RANGE, expectedRange, "Checking that there is no range set...");
                 }
             }
             /**
              * Default implementation of @sa IFuzzingValidator. This validator takes as parameter of its
              * construction a function of validation which is called in the validate() method
              */
             class FuzzingValidator : public IFuzzingValidator {
             public:
                 /// Signature of a validation function
                 using ValidationFunction = std::function<void(const VariableState &variableState)>;
                 explicit FuzzingValidator(ValidationFunction fun) : m_Fun(std::move(fun)) {}
                 void validate(const VariableState &variableState) const override { m_Fun(variableState); }
             private:
                 ValidationFunction m_Fun;
             };
             } // namespace
             std::unique_ptr<IFuzzingValidator> FuzzingValidatorFactory::create(FuzzingValidatorType type)
             {
                 switch (type) {
                     case FuzzingValidatorType::DATA:
                         return std::make_unique<FuzzingValidator>([](const VariableState &variableState) {
                             DataValidatorHelper::instance().validate(variableState);
                         });
                     case FuzzingValidatorType::RANGE:
                         return std::make_unique<FuzzingValidator>([](const VariableState &variableState) {
                             auto getVariableRange = [](const Variable &variable) { return variable.range(); };
                             validateRange(variableState.m_Variable, variableState.m_Range, getVariableRange);
                         });
                     default:
                         // Default case returns invalid validator
                         break;
                 }
                 // Invalid validator
                 return std::make_unique<FuzzingValidator>(
                     [](const VariableState &) { QFAIL("Invalid validator"); });
             }

plugins/amda/tests/TestAmdaFuzzing.cpp +4 0

             #include "FuzzingDefs.h"
             #include "FuzzingOperations.h"
             #include "FuzzingUtils.h"
             #include "FuzzingValidators.h"
             #include "AmdaProvider.h"
             #include <Common/SignalWaiter.h>
             #include <Network/NetworkController.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <QtTest>
             #include <memory>
             Q_LOGGING_CATEGORY(LOG_TestAmdaFuzzing, "TestAmdaFuzzing")
             /**
              * Macro used to generate a getter for a property in @sa FuzzingTest. The macro generates a static
              * attribute that is initialized by searching in properties the property and use a default value if
              * it's not present. Macro arguments are:
              * - GETTER_NAME : name of the getter
              * - PROPERTY_NAME: used to generate constants for property's name ({PROPERTY_NAME}_PROPERTY) and
              * default value ({PROPERTY_NAME}_DEFAULT_VALUE)
              * - TYPE : return type of the getter
              */
             // clang-format off
             #define DECLARE_PROPERTY_GETTER(GETTER_NAME, PROPERTY_NAME, TYPE)  \
             TYPE GETTER_NAME() const \
             { \
                 static auto result = m_Properties.value(PROPERTY_NAME##_PROPERTY, PROPERTY_NAME##_DEFAULT_VALUE).value<TYPE>(); \
                 return result; \
             } \
             // clang-format on
             namespace {
             // /////// //
             // Aliases //
             // /////// //
             using IntPair = std::pair<int, int>;
             using Weight = double;
             using Weights = std::vector<Weight>;
             struct OperationProperty {
                 Weight m_Weight{1.};
                 bool m_WaitAcquisition{false};
             };
             using VariableOperation = std::pair<VariableId, std::shared_ptr<IFuzzingOperation> >;
             using VariablesOperations = std::vector<VariableOperation>;
             using OperationsTypes = std::map<FuzzingOperationType, OperationProperty>;
             using OperationsPool = std::map<std::shared_ptr<IFuzzingOperation>, OperationProperty>;
             using Validators = std::vector<std::shared_ptr<IFuzzingValidator> >;
             // ///////// //
             // Constants //
             // ///////// //
             // Defaults values used when the associated properties have not been set for the test
             const auto ACQUISITION_TIMEOUT_DEFAULT_VALUE = 30000;
             const auto NB_MAX_OPERATIONS_DEFAULT_VALUE = 100;
             const auto NB_MAX_SYNC_GROUPS_DEFAULT_VALUE = 1;
             const auto NB_MAX_VARIABLES_DEFAULT_VALUE = 1;
             const auto AVAILABLE_OPERATIONS_DEFAULT_VALUE = QVariant::fromValue(
                 OperationsTypes{{FuzzingOperationType::CREATE, {1., true}},
                                 {FuzzingOperationType::DELETE, {0.1}}, // Delete operation is less frequent
                                 {FuzzingOperationType::PAN_LEFT, {1.}},
                                 {FuzzingOperationType::PAN_RIGHT, {1.}},
                                 {FuzzingOperationType::ZOOM_IN, {1.}},
                                 {FuzzingOperationType::ZOOM_OUT, {1.}},
                                 {FuzzingOperationType::SYNCHRONIZE, {0.8}},
                                 {FuzzingOperationType::DESYNCHRONIZE, {0.4}}});
             const auto CACHE_TOLERANCE_DEFAULT_VALUE = 0.2;
             /// Min/max delays between each operation (in ms)
             const auto OPERATION_DELAY_BOUNDS_DEFAULT_VALUE = QVariant::fromValue(std::make_pair(100, 3000));
             /// Validators for the tests (executed in the order in which they're defined)
             const auto VALIDATORS_DEFAULT_VALUE = QVariant::fromValue(
                 ValidatorsTypes{{FuzzingValidatorType::RANGE, FuzzingValidatorType::DATA}});
             /// Min/max number of operations to execute before calling validation
             const auto VALIDATION_FREQUENCY_BOUNDS_DEFAULT_VALUE = QVariant::fromValue(std::make_pair(1, 10));
             // /////// //
             // Methods //
             // /////// //
             /// Goes through the variables pool and operations pool to determine the set of {variable/operation}
             /// pairs that are valid (i.e. operation that can be executed on variable)
             std::pair<VariablesOperations, Weights> availableOperations(const FuzzingState &fuzzingState,
                                                                         const OperationsPool &operationsPool)
             {
                 VariablesOperations result{};
                 Weights weights{};
                 for (const auto &variablesPoolEntry : fuzzingState.m_VariablesPool) {
                     auto variableId = variablesPoolEntry.first;
                     for (const auto &operationsPoolEntry : operationsPool) {
                         auto operation = operationsPoolEntry.first;
                         auto operationProperty = operationsPoolEntry.second;
                         // A pair is valid if the current operation can be executed on the current variable
                         if (operation->canExecute(variableId, fuzzingState)) {
                             result.push_back({variableId, operation});
                             weights.push_back(operationProperty.m_Weight);
                         }
                     }
                 }
                 return {result, weights};
             }
             OperationsPool createOperationsPool(const OperationsTypes &types)
             {
                 OperationsPool result{};
                 std::transform(
                     types.cbegin(), types.cend(), std::inserter(result, result.end()), [](const auto &type) {
                         return std::make_pair(FuzzingOperationFactory::create(type.first), type.second);
                     });
                 return result;
             }
             Validators createValidators(const ValidatorsTypes &types)
             {
                 Validators result{};
                 std::transform(types.cbegin(), types.cend(), std::inserter(result, result.end()),
                                [](const auto &type) { return FuzzingValidatorFactory::create(type); });
                 return result;
             }
             /**
              * Validates all the variables' states passed in parameter, according to a set of validators
              * @param variablesPool the variables' states
              * @param validators the validators used for validation
              */
             void validate(const VariablesPool &variablesPool, const Validators &validators)
             {
                 for (const auto &variablesPoolEntry : variablesPool) {
                     auto variableId = variablesPoolEntry.first;
                     const auto &variableState = variablesPoolEntry.second;
                     auto variableMessage = variableState.m_Variable ? variableState.m_Variable->name()
                                                                     : QStringLiteral("null variable");
                     qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Validating state of variable at index"
                                                             << variableId << "(" << variableMessage << ")...";
                     for (const auto &validator : validators) {
                         validator->validate(VariableState{variableState});
                     }
                     qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Validation completed.";
                 }
             }
             /**
              * Class to run random tests
              */
             class FuzzingTest {
             public:
                 explicit FuzzingTest(VariableController &variableController, Properties properties)
                         : m_VariableController{variableController},
                           m_Properties{std::move(properties)},
                           m_FuzzingState{}
                 {
                     // Inits variables pool: at init, all variables are null
                     for (auto variableId = 0; variableId < nbMaxVariables(); ++variableId) {
                         m_FuzzingState.m_VariablesPool[variableId] = VariableState{};
                     }
                     // Inits sync groups and registers them into the variable controller
                     for (auto i = 0; i < nbMaxSyncGroups(); ++i) {
                         auto syncGroupId = SyncGroupId::createUuid();
                         variableController.onAddSynchronizationGroupId(syncGroupId);
                         m_FuzzingState.m_SyncGroupsPool[syncGroupId] = SyncGroup{};
                     }
                 }
                 void execute()
                 {
                     qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Running" << nbMaxOperations() << "operations on"
                                                             << nbMaxVariables() << "variable(s)...";
                     // Inits the count of the number of operations before the next validation
                     int nextValidationCounter = 0;
                     auto updateValidationCounter = [this, &nextValidationCounter]() {
                         nextValidationCounter = RandomGenerator::instance().generateInt(
                             validationFrequencies().first, validationFrequencies().second);
                         qCInfo(LOG_TestAmdaFuzzing()).noquote()
                             << "Next validation in " << nextValidationCounter << "operation(s)...";
                     };
                     updateValidationCounter();
                     auto canExecute = true;
                     for (auto i = 0; i < nbMaxOperations() && canExecute; ++i) {
                         // Retrieves all operations that can be executed in the current context
                         VariablesOperations variableOperations{};
                         Weights weights{};
                         std::tie(variableOperations, weights)
                             = availableOperations(m_FuzzingState, operationsPool());
                         canExecute = !variableOperations.empty();
                         if (canExecute) {
                             --nextValidationCounter;
                             // Of the operations available, chooses a random operation and executes it
                             auto variableOperation
                                 = RandomGenerator::instance().randomChoice(variableOperations, weights);
                             auto variableId = variableOperation.first;
                             auto fuzzingOperation = variableOperation.second;
                             auto waitAcquisition = nextValidationCounter == 0
                                                    || operationsPool().at(fuzzingOperation).m_WaitAcquisition;
                             fuzzingOperation->execute(variableId, m_FuzzingState, m_VariableController,
                                                       m_Properties);
                             if (waitAcquisition) {
                                 qCDebug(LOG_TestAmdaFuzzing()) << "Waiting for acquisition to finish...";
                                 SignalWaiter{m_VariableController, SIGNAL(acquisitionFinished())}.wait(
                                     acquisitionTimeout());
                                 // Validates variables
                                 if (nextValidationCounter == 0) {
                                     validate(m_FuzzingState.m_VariablesPool, validators());
                                     updateValidationCounter();
                                 }
                             }
                             else {
                                 // Delays the next operation with a randomly generated time
                                 auto delay = RandomGenerator::instance().generateInt(operationDelays().first,
                                                                                      operationDelays().second);
                                 qCDebug(LOG_TestAmdaFuzzing())
                                     << "Waiting " << delay << "ms before the next operation...";
                                 QTest::qWait(delay);
                             }
                         }
                         else {
                             qCInfo(LOG_TestAmdaFuzzing()).noquote()
                                 << "No more operations are available, the execution of the test will stop...";
                         }
                     }
                     qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Execution of the test completed.";
                 }
             private:
                 OperationsPool operationsPool() const
                 {
                     static auto result = createOperationsPool(
                         m_Properties.value(AVAILABLE_OPERATIONS_PROPERTY, AVAILABLE_OPERATIONS_DEFAULT_VALUE)
                             .value<OperationsTypes>());
                     return result;
                 }
                 Validators validators() const
                 {
                     static auto result
                         = createValidators(m_Properties.value(VALIDATORS_PROPERTY, VALIDATORS_DEFAULT_VALUE)
                                                .value<ValidatorsTypes>());
                     return result;
                 }
                 DECLARE_PROPERTY_GETTER(nbMaxOperations, NB_MAX_OPERATIONS, int)
                 DECLARE_PROPERTY_GETTER(nbMaxSyncGroups, NB_MAX_SYNC_GROUPS, int)
                 DECLARE_PROPERTY_GETTER(nbMaxVariables, NB_MAX_VARIABLES, int)
                 DECLARE_PROPERTY_GETTER(operationDelays, OPERATION_DELAY_BOUNDS, IntPair)
                 DECLARE_PROPERTY_GETTER(validationFrequencies, VALIDATION_FREQUENCY_BOUNDS, IntPair)
                 DECLARE_PROPERTY_GETTER(acquisitionTimeout, ACQUISITION_TIMEOUT, int)
                 VariableController &m_VariableController;
                 Properties m_Properties;
                 FuzzingState m_FuzzingState;
             };
             } // namespace
             Q_DECLARE_METATYPE(OperationsTypes)
             class TestAmdaFuzzing : public QObject {
                 Q_OBJECT
             private slots:
                 /// Input data for @sa testFuzzing()
                 void testFuzzing_data();
                 void testFuzzing();
             };
             void TestAmdaFuzzing::testFuzzing_data()
             {
                 // Note: Comment this line to run fuzzing tests
                 QSKIP("Fuzzing tests are disabled by default");
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 QTest::addColumn<Properties>("properties"); // Properties for random test
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 auto maxRange = SqpRange::fromDateTime({2017, 1, 1}, {0, 0}, {2017, 1, 5}, {0, 0});
                 MetadataPool metadataPool{{{"dataType", "vector"}, {"xml:id", "imf"}}};
                 // Note: we don't use auto here as we want to pass std::shared_ptr<IDataProvider> as is in the
                 // QVariant
                 std::shared_ptr<IDataProvider> provider = std::make_shared<AmdaProvider>();
                 QTest::newRow("fuzzingTest") << Properties{
                     {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
                     {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
                     {PROVIDER_PROPERTY, QVariant::fromValue(provider)}};
             }
             void TestAmdaFuzzing::testFuzzing()
             {
                 QFETCH(Properties, properties);
                 // Sets cache property
                 QSettings settings{};
                 auto cacheTolerance = properties.value(CACHE_TOLERANCE_PROPERTY, CACHE_TOLERANCE_DEFAULT_VALUE);
                 settings.setValue(GENERAL_TOLERANCE_AT_INIT_KEY, cacheTolerance);
                 settings.setValue(GENERAL_TOLERANCE_AT_UPDATE_KEY, cacheTolerance);
                 auto &variableController = sqpApp->variableController();
                 auto &timeController = sqpApp->timeController();
                 // Generates random initial range (bounded to max range)
                 auto maxRange = properties.value(MAX_RANGE_PROPERTY, QVariant::fromValue(INVALID_RANGE))
                                     .value<SqpRange>();
                 QVERIFY(maxRange != INVALID_RANGE);
                 auto initialRangeStart
                     = RandomGenerator::instance().generateDouble(maxRange.m_TStart, maxRange.m_TEnd);
                 auto initialRangeEnd
                     = RandomGenerator::instance().generateDouble(maxRange.m_TStart, maxRange.m_TEnd);
                 if (initialRangeStart > initialRangeEnd) {
                     std::swap(initialRangeStart, initialRangeEnd);
                 }
                 // Sets initial range on time controller
                 SqpRange initialRange{initialRangeStart, initialRangeEnd};
                 qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Setting initial range to" << initialRange << "...";
                 timeController.onTimeToUpdate(initialRange);
                 properties.insert(INITIAL_RANGE_PROPERTY, QVariant::fromValue(initialRange));
                 FuzzingTest test{variableController, properties};
                 test.execute();
             }
             int main(int argc, char *argv[])
             {
+                // Increases the test function timeout (which is 5 minutes by default) to 12 hours
+                // https://stackoverflow.com/questions/42655932/setting-timeout-to-qt-test
+                qputenv("QTEST_FUNCTION_TIMEOUT", QByteArray::number(12*60*60*1000));
                 QLoggingCategory::setFilterRules(
                     "*.warning=false\n"
                     "*.info=false\n"
                     "*.debug=false\n"
                     "FuzzingOperations.info=true\n"
                     "FuzzingValidators.info=true\n"
                     "TestAmdaFuzzing.info=true\n");
                 SqpApplication app{argc, argv};
                 SqpApplication::setOrganizationName("LPP");
                 SqpApplication::setOrganizationDomain("lpp.fr");
                 SqpApplication::setApplicationName("SciQLop-TestFuzzing");
                 app.setAttribute(Qt::AA_Use96Dpi, true);
                 TestAmdaFuzzing testObject{};
                 QTEST_SET_MAIN_SOURCE_PATH
                 return QTest::qExec(&testObject, argc, argv);
             }
             #include "TestAmdaFuzzing.moc"

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages