HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1388:0dd8127294f3

sync...

jeandet -

r1388:0dd8127294f3

parent child

Context file:

r1388:0dd8127294f3

core +1 -1

	@@ -1,1 +1,1
	1	Subproject commit 65c558a3025bc4ab1701c51a15427ccbf9d86cd3		1	Subproject commit 139d5f0a7d64d6d6d1d20862d922cada26ed8df3

gui/src/Catalogue/CatalogueEventsWidget.cpp +1 -1

             #include "Catalogue/CatalogueEventsWidget.h"
             #include "ui_CatalogueEventsWidget.h"
             #include <Catalogue/CatalogueController.h>
             #include <Catalogue/CatalogueEventsModel.h>
             #include <Catalogue/CatalogueExplorerHelper.h>
             #include <CatalogueDao.h>
             #include <DBCatalogue.h>
             #include <DBEventProduct.h>
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController2.h>
             #include <Visualization/VisualizationGraphWidget.h>
             #include <Visualization/VisualizationTabWidget.h>
             #include <Visualization/VisualizationWidget.h>
             #include <Visualization/VisualizationZoneWidget.h>
             #include <QActionGroup>
             #include <QDialog>
             #include <QDialogButtonBox>
             #include <QKeyEvent>
             #include <QListWidget>
             #include <QMenu>
             #include <QMessageBox>
             Q_LOGGING_CATEGORY(LOG_CatalogueEventsWidget, "CatalogueEventsWidget")
             /// Percentage added to the range of a event when it is displayed
             const auto EVENT_RANGE_MARGE = 30; // in %
             const QString NEW_ZONE_TEXT = QStringLiteral("New Zone");
             struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
                 CatalogueEventsModel *m_Model = nullptr;
                 QStringList m_ZonesForTimeMode;
                 QString m_ZoneForGraphMode;
                 QVector<std::shared_ptr<DBCatalogue> > m_DisplayedCatalogues;
                 bool m_AllEventDisplayed = false;
                 QVector<VisualizationGraphWidget *> m_CustomGraphs;
                 VisualizationWidget *m_VisualizationWidget = nullptr;
                 void setEvents(const QVector<std::shared_ptr<DBEvent> > &events, CatalogueEventsWidget *widget)
                 {
                     widget->ui->treeView->setSortingEnabled(false);
                     m_Model->setSourceCatalogues(m_DisplayedCatalogues);
                     m_Model->setEvents(events);
                     widget->ui->treeView->setSortingEnabled(true);
                     for (auto event : events) {
                         if (sqpApp->catalogueController().eventHasChanges(event)) {
                             auto index = m_Model->indexOf(event);
                             widget->setEventChanges(event, true);
                         }
                     }
                 }
                 void addEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
                 {
                     treeView->setSortingEnabled(false);
                     m_Model->addEvent(event);
                     treeView->setSortingEnabled(true);
                 }
                 void removeEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
                 {
                     treeView->setSortingEnabled(false);
                     m_Model->removeEvent(event);
                     treeView->setSortingEnabled(true);
                 }
                 QStringList getAvailableVisualizationZoneList() const
                 {
                     if (m_VisualizationWidget) {
                         if (auto tab = m_VisualizationWidget->currentTabWidget()) {
                             return tab->availableZoneWidgets();
                         }
                     }
                     return QStringList{};
                 }
                 QStringList selectZone(QWidget *parent, const QStringList &selectedZones,
                                        bool allowMultiSelection, bool addNewZoneOption, const QPoint &location)
                 {
                     auto availableZones = getAvailableVisualizationZoneList();
                     if (!addNewZoneOption && availableZones.isEmpty()) {
                         return QStringList{};
                     }
                     QActionGroup actionGroup{parent};
                     actionGroup.setExclusive(!allowMultiSelection);
                     QVector<QAction *> zoneActions;
                     QMenu selectionMenu{parent};
                     if (addNewZoneOption) {
                         availableZones.prepend(NEW_ZONE_TEXT);
                     }
                     selectionMenu.addSeparator();
                     for (auto zone : availableZones) {
                         auto zoneAction = selectionMenu.addAction(zone);
                         zoneAction->setCheckable(true);
                         zoneAction->setChecked(selectedZones.contains(zone));
                         actionGroup.addAction(zoneAction);
                         zoneActions << zoneAction;
                     }
                     auto resultAction = selectionMenu.exec(QCursor::pos());
                     QStringList result;
                     if (resultAction == nullptr) {
                         result = selectedZones;
                     }
                     else {
                         for (auto zoneAction : zoneActions) {
                             if (zoneAction->isChecked()) {
                                 result << zoneAction->text();
                             }
                         }
                     }
                     return result;
                 }
                 void updateForTimeMode(QTreeView *treeView)
                 {
                     auto selectedRows = treeView->selectionModel()->selectedRows();
                     if (selectedRows.count() == 1) {
                         auto event = m_Model->getEvent(selectedRows.first());
                         if (event) {
                             if (m_VisualizationWidget) {
                                 if (auto tab = m_VisualizationWidget->currentTabWidget()) {
                                     for (auto zoneName : m_ZonesForTimeMode) {
                                         if (auto zone = tab->getZoneWithName(zoneName)) {
                                             DateTimeRange eventRange;
                                             eventRange.m_TStart = event->getTStart();
                                             eventRange.m_TEnd = event->getTEnd();
                                             zone->setZoneRange(eventRange);
                                         }
                                     }
                                 }
                                 else {
                                     qCWarning(LOG_CatalogueEventsWidget())
                                         << "updateTimeZone: no tab found in the visualization";
                                 }
                             }
                             else {
                                 qCWarning(LOG_CatalogueEventsWidget())
                                     << "updateTimeZone: visualization widget not found";
                             }
                         }
                     }
                     else {
                         qCWarning(LOG_CatalogueEventsWidget())
                             << "updateTimeZone: not compatible with multiple events selected";
                     }
                 }
                 QVector<DateTimeRange> getGraphRanges(const std::shared_ptr<DBEvent> &event)
                 {
                     // Retrieves the range of each product and the maximum size
                     QVector<DateTimeRange> graphRanges;
                     double maxDt = 0;
                     for (auto eventProduct : event->getEventProducts()) {
                         DateTimeRange eventRange;
                         eventRange.m_TStart = eventProduct.getTStart();
                         eventRange.m_TEnd = eventProduct.getTEnd();
                         graphRanges << eventRange;
                         auto dt = eventRange.m_TEnd - eventRange.m_TStart;
                         if (dt > maxDt) {
                             maxDt = dt;
                         }
                     }
                     // Adds the marge
                     maxDt *= (100.0 + EVENT_RANGE_MARGE) / 100.0;
                     // Corrects the graph ranges so that they all have the same size
                     QVector<DateTimeRange> correctedGraphRanges;
                     for (auto range : graphRanges) {
                         auto dt = range.m_TEnd - range.m_TStart;
                         auto diff = qAbs((maxDt - dt) / 2.0);
                         DateTimeRange correctedRange;
                         correctedRange.m_TStart = range.m_TStart - diff;
                         correctedRange.m_TEnd = range.m_TEnd + diff;
                         correctedGraphRanges << correctedRange;
                     }
                     return correctedGraphRanges;
                 }
                 void updateForGraphMode(CatalogueEventsWidget *catalogueEventWidget)
                 {
                     auto selectedRows = catalogueEventWidget->ui->treeView->selectionModel()->selectedRows();
                     if (selectedRows.count() != 1) {
                         qCWarning(LOG_CatalogueEventsWidget())
                             << "updateGraphMode: not compatible with multiple events selected";
                         return;
                     }
                     if (!m_VisualizationWidget) {
                         qCWarning(LOG_CatalogueEventsWidget())
                             << "updateGraphMode: visualization widget not found";
                         return;
                     }
                     auto event = m_Model->getEvent(selectedRows.first());
                     if (!event) {
                         // A event product is probably selected
                         qCInfo(LOG_CatalogueEventsWidget()) << "updateGraphMode: no events are selected";
                         return;
                     }
                     auto tab = m_VisualizationWidget->currentTabWidget();
                     if (!tab) {
                         qCWarning(LOG_CatalogueEventsWidget())
                             << "updateGraphMode: no tab found in the visualization";
                         return;
                     }
                     auto isNewZone = m_ZoneForGraphMode == NEW_ZONE_TEXT;
                     auto zone = tab->getZoneWithName(m_ZoneForGraphMode);
                     if (!isNewZone && !zone) {
                         qCWarning(LOG_CatalogueEventsWidget()) << "updateGraphMode: zone not found";
                         return;
                     }
                     // Closes the previous graph and delete the asociated variables
                     for (auto graph : m_CustomGraphs) {
                         graph->close();
                         auto variables = graph->variables();
                         for(const auto& variable:variables)
                             sqpApp->variableController().deleteVariable(variable);
                     }
                     m_CustomGraphs.clear();
                     // Closes the remaining graphs inside the zone
                     if (zone) {
                         zone->closeAllGraphs();
                     }
                     // Creates the zone if needed
                     if (isNewZone) {
                         zone = tab->createEmptyZone(0);
                         m_ZoneForGraphMode = zone->name();
                     }
                     // Calculates the range of each graph which will be created
                     auto graphRange = getGraphRanges(event);
                     // Loops through the event products and create the graph
                     auto itRange = graphRange.cbegin();
                     for (auto eventProduct : event->getEventProducts()) {
                         auto productId = eventProduct.getProductId();
                         auto range = *itRange;
                         ++itRange;
                         DateTimeRange productRange;
                         productRange.m_TStart = eventProduct.getTStart();
                         productRange.m_TEnd = eventProduct.getTEnd();
                         auto context = new QObject{catalogueEventWidget};
                         QObject::connect(
                             &sqpApp->variableController(), &VariableController2::variableAdded, context,
                             [this, catalogueEventWidget, zone, context, event, range, productRange,
                              productId](auto variable) {
                                 if (variable->metadata().value(DataSourceItem::ID_DATA_KEY).toString()
                                     == productId) {
                                     auto graph = zone->createGraph(variable);
                                     graph->setAutoRangeOnVariableInitialization(false);
                                     auto selectionZone
                                         = graph->addSelectionZone(event->getName(), productRange);
                                     emit catalogueEventWidget->selectionZoneAdded(event, productId,
                                                                                   selectionZone);
                                     m_CustomGraphs << graph;
-                                    graph->setGraphRange(range, true);
+                                    graph->setGraphRange(range, true, true);
                                     // Removes the graph from the graph list if it is closed manually
                                     QObject::connect(graph, &VisualizationGraphWidget::destroyed,
                                                      [this, graph]() { m_CustomGraphs.removeAll(graph); });
                                     delete context; // removes the connection
                                 }
                             },
                             Qt::QueuedConnection);
                         QMetaObject::invokeMethod(&sqpApp->dataSourceController(),
                                                   "requestVariableFromProductIdKey", Qt::QueuedConnection,
                                                   Q_ARG(QString, productId));
                     }
                 }
                 void getSelectedItems(
                     QTreeView *treeView, QVector<std::shared_ptr<DBEvent> > &events,
                     QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > &eventProducts)
                 {
                     for (auto rowIndex : treeView->selectionModel()->selectedRows()) {
                         auto itemType = m_Model->itemTypeOf(rowIndex);
                         if (itemType == CatalogueEventsModel::ItemType::Event) {
                             events << m_Model->getEvent(rowIndex);
                         }
                         else if (itemType == CatalogueEventsModel::ItemType::EventProduct) {
                             eventProducts << qMakePair(m_Model->getParentEvent(rowIndex),
                                                        m_Model->getEventProduct(rowIndex));
                         }
                     }
                 }
             };
             CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
                     : QWidget(parent),
                       ui(new Ui::CatalogueEventsWidget),
                       impl{spimpl::make_unique_impl<CatalogueEventsWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 impl->m_Model = new CatalogueEventsModel{this};
                 ui->treeView->setModel(impl->m_Model);
                 ui->treeView->setSortingEnabled(true);
                 ui->treeView->setDragDropMode(QAbstractItemView::DragDrop);
                 ui->treeView->setDragEnabled(true);
                 connect(ui->btnTime, &QToolButton::clicked, [this](auto checked) {
                     if (checked) {
                         ui->btnChart->setChecked(false);
                         impl->m_ZonesForTimeMode
                             = impl->selectZone(this, impl->m_ZonesForTimeMode, true, false,
                                                this->mapToGlobal(ui->btnTime->frameGeometry().center()));
                         impl->updateForTimeMode(ui->treeView);
                     }
                 });
                 connect(ui->btnChart, &QToolButton::clicked, [this](auto checked) {
                     if (checked) {
                         ui->btnTime->setChecked(false);
                         impl->m_ZoneForGraphMode
                             = impl->selectZone(this, {impl->m_ZoneForGraphMode}, false, true,
                                                this->mapToGlobal(ui->btnChart->frameGeometry().center()))
                                   .value(0);
                         impl->updateForGraphMode(this);
                     }
                 });
                 connect(ui->btnRemove, &QToolButton::clicked, [this]() {
                     QVector<std::shared_ptr<DBEvent> > events;
                     QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
                     impl->getSelectedItems(ui->treeView, events, eventProducts);
                     if (!events.isEmpty() && eventProducts.isEmpty()) {
                         auto canRemoveEvent
                             = !this->isAllEventsDisplayed()
                               || (QMessageBox::warning(
                                       this, tr("Remove Event(s)"),
                                       tr("The selected event(s) will be permanently removed "
                                          "from the repository!\nAre you sure you want to continue?"),
                                       QMessageBox::Yes | QMessageBox::No, QMessageBox::No)
                                   == QMessageBox::Yes);
                         if (canRemoveEvent) {
                             for (auto event : events) {
                                 if (this->isAllEventsDisplayed()) {
                                     sqpApp->catalogueController().removeEvent(event);
                                     impl->removeEvent(event, ui->treeView);
                                 }
                                 else {
                                     QVector<std::shared_ptr<DBCatalogue> > modifiedCatalogues;
                                     for (auto catalogue : this->displayedCatalogues()) {
                                         if (catalogue->removeEvent(event->getUniqId())) {
                                             sqpApp->catalogueController().updateCatalogue(catalogue);
                                             modifiedCatalogues << catalogue;
                                         }
                                     }
                                     if (!modifiedCatalogues.empty()) {
                                         emit eventCataloguesModified(modifiedCatalogues);
                                     }
                                 }
                                 impl->m_Model->removeEvent(event);
                             }
                             emit this->eventsRemoved(events);
                         }
                     }
                 });
                 connect(ui->treeView, &QTreeView::clicked, this, &CatalogueEventsWidget::emitSelection);
                 connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, this,
                         &CatalogueEventsWidget::emitSelection);
                 ui->btnRemove->setEnabled(false); // Disabled by default when nothing is selected
                 connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, [this]() {
                     auto isNotMultiSelection = ui->treeView->selectionModel()->selectedRows().count() <= 1;
                     ui->btnChart->setEnabled(isNotMultiSelection);
                     ui->btnTime->setEnabled(isNotMultiSelection);
                     if (isNotMultiSelection && ui->btnTime->isChecked()) {
                         impl->updateForTimeMode(ui->treeView);
                     }
                     else if (isNotMultiSelection && ui->btnChart->isChecked()) {
                         impl->updateForGraphMode(this);
                     }
                     QVector<std::shared_ptr<DBEvent> > events;
                     QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
                     impl->getSelectedItems(ui->treeView, events, eventProducts);
                     ui->btnRemove->setEnabled(!events.isEmpty() && eventProducts.isEmpty());
                 });
                 ui->treeView->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
                 ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Tags,
                                                              QHeaderView::Stretch);
                 ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Validation,
                                                              QHeaderView::ResizeToContents);
                 ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Name,
                                                              QHeaderView::Interactive);
                 ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::TStart,
                                                              QHeaderView::ResizeToContents);
                 ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::TEnd,
                                                              QHeaderView::ResizeToContents);
                 ui->treeView->header()->setSortIndicatorShown(true);
                 connect(impl->m_Model, &CatalogueEventsModel::modelSorted, [this]() {
                     auto allEvents = impl->m_Model->events();
                     for (auto event : allEvents) {
                         setEventChanges(event, sqpApp->catalogueController().eventHasChanges(event));
                     }
                 });
                 populateWithAllEvents();
             }
             CatalogueEventsWidget::~CatalogueEventsWidget()
             {
                 delete ui;
             }
             void CatalogueEventsWidget::setVisualizationWidget(VisualizationWidget *visualization)
             {
                 impl->m_VisualizationWidget = visualization;
             }
             void CatalogueEventsWidget::addEvent(const std::shared_ptr<DBEvent> &event)
             {
                 impl->addEvent(event, ui->treeView);
             }
             void CatalogueEventsWidget::setEventChanges(const std::shared_ptr<DBEvent> &event, bool hasChanges)
             {
                 impl->m_Model->refreshEvent(event);
                 auto eventIndex = impl->m_Model->indexOf(event);
                 auto validationIndex
                     = eventIndex.sibling(eventIndex.row(), (int)CatalogueEventsModel::Column::Validation);
                 if (validationIndex.isValid()) {
                     if (hasChanges) {
                         if (ui->treeView->indexWidget(validationIndex) == nullptr) {
                             auto widget = CatalogueExplorerHelper::buildValidationWidget(
                                 ui->treeView,
                                 [this, event]() {
                                     sqpApp->catalogueController().saveEvent(event);
                                     setEventChanges(event, false);
                                 },
                                 [this, event]() {
                                     bool removed = false;
                                     sqpApp->catalogueController().discardEvent(event, removed);
                                     if (removed) {
                                         impl->m_Model->removeEvent(event);
                                     }
                                     else {
                                         setEventChanges(event, false);
                                         impl->m_Model->refreshEvent(event, true);
                                     }
                                     emitSelection();
                                 });
                             ui->treeView->setIndexWidget(validationIndex, widget);
                             ui->treeView->header()->resizeSection((int)CatalogueEventsModel::Column::Validation,
                                                                   QHeaderView::ResizeToContents);
                         }
                     }
                     else {
                         // Note: the widget is destroyed
                         ui->treeView->setIndexWidget(validationIndex, nullptr);
                     }
                 }
                 else {
                     qCWarning(LOG_CatalogueEventsWidget())
                         << "setEventChanges: the event is not displayed in the model.";
                 }
             }
             QVector<std::shared_ptr<DBCatalogue> > CatalogueEventsWidget::displayedCatalogues() const
             {
                 return impl->m_DisplayedCatalogues;
             }
             bool CatalogueEventsWidget::isAllEventsDisplayed() const
             {
                 return impl->m_AllEventDisplayed;
             }
             bool CatalogueEventsWidget::isEventDisplayed(const std::shared_ptr<DBEvent> &event) const
             {
                 return impl->m_Model->indexOf(event).isValid();
             }
             void CatalogueEventsWidget::refreshEvent(const std::shared_ptr<DBEvent> &event)
             {
                 impl->m_Model->refreshEvent(event, true);
             }
             void CatalogueEventsWidget::populateWithCatalogues(
                 const QVector<std::shared_ptr<DBCatalogue> > &catalogues)
             {
                 impl->m_DisplayedCatalogues = catalogues;
                 impl->m_AllEventDisplayed = false;
                 QSet<QUuid> eventIds;
                 QVector<std::shared_ptr<DBEvent> > events;
                 for (auto catalogue : catalogues) {
                     auto catalogueEvents = sqpApp->catalogueController().retrieveEventsFromCatalogue(catalogue);
                     for (auto event : catalogueEvents) {
                         if (!eventIds.contains(event->getUniqId())) {
                             events << event;
                             eventIds.insert(event->getUniqId());
                         }
                     }
                 }
                 impl->setEvents(events, this);
             }
             void CatalogueEventsWidget::populateWithAllEvents()
             {
                 impl->m_DisplayedCatalogues.clear();
                 impl->m_AllEventDisplayed = true;
                 auto allEvents = sqpApp->catalogueController().retrieveAllEvents();
                 QVector<std::shared_ptr<DBEvent> > events;
                 for (auto event : allEvents) {
                     events << event;
                 }
                 impl->setEvents(events, this);
             }
             void CatalogueEventsWidget::clear()
             {
                 impl->m_DisplayedCatalogues.clear();
                 impl->m_AllEventDisplayed = false;
                 impl->setEvents({}, this);
             }
             void CatalogueEventsWidget::refresh()
             {
                 if (isAllEventsDisplayed()) {
                     populateWithAllEvents();
                 }
                 else if (!impl->m_DisplayedCatalogues.isEmpty()) {
                     populateWithCatalogues(impl->m_DisplayedCatalogues);
                 }
             }
             void CatalogueEventsWidget::emitSelection()
             {
                 QVector<std::shared_ptr<DBEvent> > events;
                 QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
                 impl->getSelectedItems(ui->treeView, events, eventProducts);
                 if (!events.isEmpty() && eventProducts.isEmpty()) {
                     emit eventsSelected(events);
                 }
                 else if (events.isEmpty() && !eventProducts.isEmpty()) {
                     emit eventProductsSelected(eventProducts);
                 }
                 else {
                     emit selectionCleared();
                 }
             }
             void CatalogueEventsWidget::keyPressEvent(QKeyEvent *event)
             {
                 switch (event->key()) {
                     case Qt::Key_Delete: {
                         ui->btnRemove->click();
                     }
                     default:
                         break;
                 }
             }

gui/src/Visualization/VisualizationGraphWidget.cpp +4 -3

             #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 <Actions/FilteringAction.h>
             #include <Common/MimeTypesDef.h>
             #include <Common/containers.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/VariableController2.h>
             #include <Data/DateTimeRangeHelper.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_Flags{GraphFlag::EnableAll},
                           m_IsCalibration{false},
                           m_RenderingDelegate{nullptr}
                 {
                     m_plot = new QCustomPlot();
                     // Necessary for all platform since Qt::AA_EnableHighDpiScaling is enable.
                     m_plot->setPlottingHint(QCP::phFastPolylines, true);
                 }
                 void updateData(PlottablesMap &plottables, std::shared_ptr<Variable> variable,
                                 const DateTimeRange &range)
                 {
                     VisualizationGraphHelper::updateData(plottables, variable, 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;
                 GraphFlags m_Flags;
                 bool m_IsCalibration;
                 QCustomPlot* m_plot;
                 QPoint m_lastMousePos;
                 QCPRange m_lastXRange;
                 QCPRange m_lastYRange;
                 /// 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
                 bool m_VariableAutoRangeOnInit = true;
                 inline void enterPlotDrag(const QPoint& position)
                 {
                     m_lastMousePos = m_plot->mapFromParent(position);
                     m_lastXRange = m_plot->xAxis->range();
                     m_lastYRange = m_plot->yAxis->range();
                 }
                 inline bool isDrawingZoomRect(){return m_DrawingZoomRect!=nullptr;}
                 void updateZoomRect(const QPoint& newPos)
                 {
                     QPointF pos{m_plot->xAxis->pixelToCoord(newPos.x()), m_plot->yAxis->pixelToCoord(newPos.y())};
                     m_DrawingZoomRect->bottomRight->setCoords(pos);
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                 void applyZoomRect()
                 {
                     auto axisX = m_plot->axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = m_plot->axisRect()->axis(QCPAxis::atLeft);
                     auto newAxisXRange = QCPRange{m_DrawingZoomRect->topLeft->coords().x(),
                                                   m_DrawingZoomRect->bottomRight->coords().x()};
                     auto newAxisYRange = QCPRange{m_DrawingZoomRect->topLeft->coords().y(),
                                                   m_DrawingZoomRect->bottomRight->coords().y()};
                     removeDrawingRect();
                     if (newAxisXRange.size() > axisX->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0)
                         && newAxisYRange.size() > axisY->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0)) {
                         m_ZoomStack.push(qMakePair(axisX->range(), axisY->range()));
                         axisX->setRange(newAxisXRange);
                         axisY->setRange(newAxisYRange);
                         m_plot->replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 inline bool isDrawingZoneRect(){return m_DrawingZone!=nullptr;}
                 void updateZoneRect(const QPoint& newPos)
                 {
                     m_DrawingZone->setEnd(m_plot->xAxis->pixelToCoord(newPos.x()));
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                 void startDrawingRect(const QPoint &pos)
                 {
                     removeDrawingRect();
                     auto axisPos = posToAxisPos(pos);
                     m_DrawingZoomRect = new QCPItemRect{m_plot};
                     QPen p;
                     p.setWidth(2);
                     m_DrawingZoomRect->setPen(p);
                     m_DrawingZoomRect->topLeft->setCoords(axisPos);
                     m_DrawingZoomRect->bottomRight->setCoords(axisPos);
                 }
                 void removeDrawingRect()
                 {
                     if (m_DrawingZoomRect) {
                         m_plot->removeItem(m_DrawingZoomRect); // the item is deleted by QCustomPlot
                         m_DrawingZoomRect = nullptr;
                         m_plot->replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 void selectZone(const QPoint &pos)
                 {
                     auto zoneAtPos = selectionZoneAt(pos);
                     setSelectionZonesEditionEnabled(sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones);
                 }
                 void startDrawingZone(const QPoint &pos)
                 {
                     endDrawingZone();
                     auto axisPos = posToAxisPos(pos);
                     m_DrawingZone = new VisualizationSelectionZoneItem{m_plot};
                     m_DrawingZone->setRange(axisPos.x(), axisPos.x());
                     m_DrawingZone->setEditionEnabled(false);
                 }
                 void endDrawingZone()
                 {
                     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 {
                             m_plot->removeItem(m_DrawingZone);
                         }
                         m_plot->replot(QCustomPlot::rpQueuedReplot);
                         m_DrawingZone = nullptr;
                     }
                 }
                 void moveSelectionZone(const QPoint& destination)
                 {
                     /*
                      * I give up on this for now
                      * @TODO implement this, the difficulty is that selection zones have their own
                      * event handling code which seems to rely on QCP GUI event handling propagation
                      * which was a realy bad design choice.
                     */
                 }
                 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
                 {
                     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 < m_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) const
                 {
                     auto axisX = m_plot->axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = m_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());
                 }
                 inline QCPRange _pixDistanceToRange(double pos1, double pos2, QCPAxis *axis)
                 {
                     if (axis->scaleType() == QCPAxis::stLinear)
                     {
                         auto diff = axis->pixelToCoord(pos1) - axis->pixelToCoord(pos2);
                         return QCPRange{axis->range().lower + diff, axis->range().upper + diff};
                     }
                     else
                     {
                         auto diff = axis->pixelToCoord(pos1) / axis->pixelToCoord(pos2);
                         return QCPRange{axis->range().lower * diff, axis->range().upper * diff};
                     }
                 }
                 void setRange(const DateTimeRange &newRange, bool updateVar=true)
                 {
                     this->m_plot->xAxis->setRange(newRange.m_TStart, newRange.m_TEnd);
                     if(updateVar)
                     {
                         for (auto it = m_VariableToPlotMultiMap.begin(),
                              end = m_VariableToPlotMultiMap.end();
                              it != end; it = m_VariableToPlotMultiMap.upper_bound(it->first))
                         {
                             sqpApp->variableController().asyncChangeRange(it->first, newRange);
                         }
                     }
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                 void setRange(const QCPRange &newRange)
                 {
                     auto graphRange = DateTimeRange{newRange.lower, newRange.upper};
                     setRange(graphRange);
                 }
                 void rescaleY()
                 {
                     m_plot->yAxis->rescale(true);
                 }
                 std::tuple<double,double> moveGraph(const QPoint& destination)
                 {
                     auto currentPos = m_plot->mapFromParent(destination);
                     auto xAxis = m_plot->axisRect()->rangeDragAxis(Qt::Horizontal);
                     auto yAxis = m_plot->axisRect()->rangeDragAxis(Qt::Vertical);
                     auto oldXRange = xAxis->range();
                     auto oldYRange = yAxis->range();
                     double dx = xAxis->pixelToCoord(m_lastMousePos.x()) - xAxis->pixelToCoord(currentPos.x());
                     xAxis->setRange(m_lastXRange.lower+dx, m_lastXRange.upper+dx);
                     if(yAxis->scaleType() == QCPAxis::stLinear)
                     {
                         double dy = yAxis->pixelToCoord(m_lastMousePos.y()) - yAxis->pixelToCoord(currentPos.y());
                         yAxis->setRange(m_lastYRange.lower+dy, m_lastYRange.upper+dy);
                     }
                     else
                     {
                         double dy = yAxis->pixelToCoord(m_lastMousePos.y()) / yAxis->pixelToCoord(currentPos.y());
                         yAxis->setRange(m_lastYRange.lower*dy, m_lastYRange.upper*dy);
                     }
                     auto newXRange = xAxis->range();
                     auto newYRange = yAxis->range();
                     setRange(xAxis->range());
                     //m_lastMousePos = currentPos;
                     return {newXRange.lower - oldXRange.lower, newYRange.lower - oldYRange.lower};
                 }
                 void zoom(double factor, int center, Qt::Orientation orientation)
                 {
                     QCPAxis *axis = m_plot->axisRect()->rangeZoomAxis(orientation);
                     axis->scaleRange(factor, axis->pixelToCoord(center));
                     if (orientation == Qt::Horizontal)
                         setRange(axis->range());
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                 void transform(const DateTimeRangeTransformation &tranformation)
                 {
                     auto graphRange = m_plot->xAxis->range();
                     DateTimeRange range{graphRange.lower, graphRange.upper};
                     range = range.transform(tranformation);
                     setRange(range);
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                 void move(double dx, double dy)
                 {
                     auto xAxis = m_plot->axisRect()->rangeDragAxis(Qt::Horizontal);
                     auto yAxis = m_plot->axisRect()->rangeDragAxis(Qt::Vertical);
                     xAxis->setRange(QCPRange(xAxis->range().lower+dx, xAxis->range().upper+dx));
                     yAxis->setRange(QCPRange(yAxis->range().lower+dy, yAxis->range().upper+dy));
                     setRange(xAxis->range());
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                 void move(double factor, Qt::Orientation orientation)
                 {
                     auto oldRange = m_plot->xAxis->range();
                     QCPAxis *axis = m_plot->axisRect()->rangeDragAxis(orientation);
                     if (m_plot->xAxis->scaleType() == QCPAxis::stLinear) {
                         double rg = (axis->range().upper - axis->range().lower) * (factor / 10);
                         axis->setRange(axis->range().lower + (rg), axis->range().upper + (rg));
                     }
                     else if (m_plot->xAxis->scaleType() == QCPAxis::stLogarithmic) {
                         int start = 0, stop = 0;
                         double diff = 0.;
                         if (factor > 0.0) {
                             stop = m_plot->width() * factor / 10;
                             start = 2 * m_plot->width() * factor / 10;
                         }
                         if (factor < 0.0) {
                             factor *= -1.0;
                             start = m_plot->width() * factor / 10;
                             stop = 2 * m_plot->width() * factor / 10;
                         }
                         diff = axis->pixelToCoord(start) / axis->pixelToCoord(stop);
                         axis->setRange(m_plot->axisRect()->rangeDragAxis(orientation)->range().lower * diff,
                                        m_plot->axisRect()->rangeDragAxis(orientation)->range().upper * diff);
                     }
                     if (orientation == Qt::Horizontal)
                         setRange(axis->range());
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
                 this->layout()->addWidget(impl->m_plot);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 // 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);
                 this->setFocusPolicy(Qt::WheelFocus);
                 this->setMouseTracking(true);
                 impl->m_plot->setAttribute(Qt::WA_TransparentForMouseEvents);
                 impl->m_plot->setContextMenuPolicy(Qt::CustomContextMenu);
                 impl->m_plot->setParent(this);
                 connect(&sqpApp->variableController(), &VariableController2::variableDeleted, this, &VisualizationGraphWidget::variableDeleted);
             }
             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::setFlags(GraphFlags flags)
             {
                 impl->m_Flags = std::move(flags);
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, DateTimeRange range)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *impl->m_plot);
                 // Sets graph properties
                 impl->m_RenderingDelegate->setGraphProperties(*variable, createdPlottables);
                 impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
                 setGraphRange(range);
                 // If the variable already has its data loaded, load its units and its range in the graph
                 if (variable->dataSeries() != nullptr) {
                     impl->m_RenderingDelegate->setAxesUnits(*variable);
                 }
                 else
                 {
                     auto context = new QObject{this};
                     connect(variable.get(), &Variable::updated, context,
                             [this, variable, context, range](QUuid)
                                 {
                                     this->impl->m_RenderingDelegate->setAxesUnits(*variable);
                                     this->impl->m_plot->replot(QCustomPlot::rpQueuedReplot);
                                     delete context;
                                 }
                                 );
                 }
                 //@TODO this is bad! when variable is moved to another graph it still fires
                 // even if this has been deleted
                 connect(variable.get(), &Variable::updated, this, &VisualizationGraphWidget::variableUpdated);
                 this->onUpdateVarDisplaying(variable, range); // My bullshit
                 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;) {
                         impl->m_plot->removePlottable(plottableIt->second);
                         plottableIt = plottablesMap.erase(plottableIt);
                     }
                     impl->m_VariableToPlotMultiMap.erase(variableIt);
                 }
                 // Updates graph
                 impl->m_plot->replot(QCustomPlot::rpQueuedReplot);
             }
             std::vector<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
             {
                 auto variables = std::vector<std::shared_ptr<Variable> >{};
                 for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap);
                      it != std::cend(impl->m_VariableToPlotMultiMap); ++it) {
                     variables.push_back(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, *impl->m_plot);
             }
             DateTimeRange VisualizationGraphWidget::graphRange() const noexcept
             {
                 auto graphRange = impl->m_plot->xAxis->range();
                 return DateTimeRange{graphRange.lower, graphRange.upper};
             }
             void VisualizationGraphWidget::setGraphRange(const DateTimeRange &range, bool updateVar, bool forward)
             {
                 impl->setRange(range, updateVar);
                 if(forward)
                 {
                     emit this->setrange_sig(this->graphRange(), true, false);
                 }
             }
             void VisualizationGraphWidget::setAutoRangeOnVariableInitialization(bool value)
             {
                 impl->m_VariableAutoRangeOnInit = value;
             }
             QVector<DateTimeRange> VisualizationGraphWidget::selectionZoneRanges() const
             {
                 QVector<DateTimeRange> ranges;
                 for (auto zone : impl->m_SelectionZones) {
                     ranges << zone->range();
                 }
                 return ranges;
             }
             void VisualizationGraphWidget::addSelectionZones(const QVector<DateTimeRange> &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);
             }
             VisualizationSelectionZoneItem *
             VisualizationGraphWidget::addSelectionZone(const QString &name, const DateTimeRange &range)
             {
                 // note: ownership is transfered to QCustomPlot
                 auto zone = new VisualizationSelectionZoneItem(&plot());
                 zone->setName(name);
                 zone->setRange(range.m_TStart, range.m_TEnd);
                 impl->addSelectionZone(zone);
                 plot().replot(QCustomPlot::rpQueuedReplot);
                 return zone;
             }
             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::zoom(double factor, int center, Qt::Orientation orientation, bool forward)
             {
                 impl->zoom(factor, center, orientation);
                 if(forward && orientation==Qt::Horizontal)
                     emit this->setrange_sig(this->graphRange(), true, false);
             }
             void VisualizationGraphWidget::move(double factor, Qt::Orientation orientation, bool forward)
             {
                 impl->move(factor, orientation);
                 if(forward)
                     emit this->setrange_sig(this->graphRange(), true, false);
             }
             void VisualizationGraphWidget::move(double dx, double dy, bool forward)
             {
                 impl->move(dx, dy);
                 if(forward)
                     emit this->setrange_sig(this->graphRange(), true, false);
             }
             void VisualizationGraphWidget::transform(const DateTimeRangeTransformation &tranformation, bool forward)
             {
                 impl->transform(tranformation);
                 if(forward)
                     emit this->setrange_sig(this->graphRange(), true, false);
             }
             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);
                 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);
                 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);
                 for (auto i : impl->m_SelectionZones) {
                     parentVisualizationWidget()->selectionZoneManager().setSelected(i, false);
                 }
                 // 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;
                 }
             }
             void VisualizationGraphWidget::wheelEvent(QWheelEvent *event)
             {
                 double factor;
                 double wheelSteps = event->delta() / 120.0; // a single step delta is +/-120 usually
                 if (event->modifiers() == Qt::ControlModifier) {
                     if (event->orientation() == Qt::Vertical) // mRangeZoom.testFlag(Qt::Vertical))
                     {
                         setCursor(Qt::SizeVerCursor);
                         factor = pow(impl->m_plot->axisRect()->rangeZoomFactor(Qt::Vertical), wheelSteps);
                         zoom(factor, event->pos().y(), Qt::Vertical);
                     }
                 }
                 else if (event->modifiers() == Qt::ShiftModifier) {
                     if (event->orientation() == Qt::Vertical) // mRangeZoom.testFlag(Qt::Vertical))
                     {
                         setCursor(Qt::SizeHorCursor);
                         factor = pow(impl->m_plot->axisRect()->rangeZoomFactor(Qt::Horizontal), wheelSteps);
                         zoom(factor, event->pos().x(), Qt::Horizontal);
                     }
                 }
                 else {
                     move(wheelSteps, Qt::Horizontal);
                 }
                 event->accept();
             }
             void VisualizationGraphWidget::mouseMoveEvent(QMouseEvent *event)
             {
                 if(impl->isDrawingZoomRect())
                 {
                     impl->updateZoomRect(event->pos());
                 }
                 else if (impl->isDrawingZoneRect())
                 {
                     impl->updateZoneRect(event->pos());
                 }
                 else if (event->buttons() == Qt::LeftButton)
                 {
                     if(sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::None)
                     {
                         auto [dx,dy] = impl->moveGraph(event->pos());
                         emit this->setrange_sig(this->graphRange(), true, false);
                     }
                     else if(sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones)
                     {
-                        if(auto item = impl->m_plot->itemAt(event->pos()))
+                        auto posInPlot = this->impl->m_plot->mapFromParent(event->pos());
+                        if(auto item = impl->m_plot->itemAt(posInPlot))
                         {
                             if(qobject_cast<VisualizationSelectionZoneItem*>(item))
                             {
-                                QMouseEvent e{QEvent::MouseMove,this->impl->m_plot->mapFromParent(event->pos()),event->button(),event->buttons(),event->modifiers()};
+                                QMouseEvent e{QEvent::MouseMove, posInPlot, event->button(),event->buttons(),event->modifiers()};
                                 sqpApp->sendEvent(this->impl->m_plot, &e);
-                                this->impl->m_plot->replot(QCustomPlot::rpQueuedReplot);
+                                this->impl->m_plot->replot(QCustomPlot::rpImmediateRefresh);
                             }
                         }
                     }
                 }
                 else
                 {
                     impl->m_RenderingDelegate->updateTooltip(event);
                 }
                 //event->accept();
                 QWidget::mouseMoveEvent(event);
             }
             void VisualizationGraphWidget::mouseReleaseEvent(QMouseEvent *event)
             {
                 if(impl->isDrawingZoomRect())
                 {
                     auto oldRange = this->graphRange();
                     impl->applyZoomRect();
                     auto newRange = this->graphRange();
                     if(auto tf = DateTimeRangeHelper::computeTransformation(oldRange,newRange))
                         emit this->transform_sig(tf.value(), false);
                 }
                 else if(impl->isDrawingZoneRect())
                 {
                     impl->endDrawingZone();
                 }
                 else
                 {
                     setCursor(Qt::ArrowCursor);
                 }
                 auto posInPlot = this->impl->m_plot->mapFromParent(event->pos());
                 if(auto item = impl->m_plot->itemAt(posInPlot))
                 {
                     if(qobject_cast<VisualizationSelectionZoneItem*>(item))
                     {
                         QMouseEvent e{QEvent::MouseButtonRelease, posInPlot, event->button(), event->buttons(), event->modifiers()};
                         sqpApp->sendEvent(this->impl->m_plot, &e);
                     }
                 }
                 event->accept();
             }
             void VisualizationGraphWidget::mousePressEvent(QMouseEvent *event)
             {
                 if (event->button()==Qt::RightButton)
                 {
                     onGraphMenuRequested(event->pos());
                 }
                 else
                 {
                     auto selectedZone = impl->selectionZoneAt(event->pos());
                     switch (sqpApp->plotsInteractionMode())
                     {
                     case SqpApplication::PlotsInteractionMode::DragAndDrop :
                         break;
                     case SqpApplication::PlotsInteractionMode::SelectionZones :
                         impl->setSelectionZonesEditionEnabled(true);
                         if ((event->modifiers() == Qt::ControlModifier) && (selectedZone != nullptr))
                         {
                                 auto alreadySelectedZones = parentVisualizationWidget()->selectionZoneManager().selectedItems();
                                 selectedZone->setAssociatedEditedZones(alreadySelectedZones);
                                 if(SciQLop::containers::contains(alreadySelectedZones, selectedZone))
                                 {
                                     alreadySelectedZones.removeOne(selectedZone);
                                 }
                                 else
                                 {
                                     alreadySelectedZones.append(selectedZone);
                                 }
                                 parentVisualizationWidget()->selectionZoneManager().select(alreadySelectedZones);
                         }
                         else
                         {
                             if (!selectedZone)
                             {
                                 parentVisualizationWidget()->selectionZoneManager().clearSelection();
                                 impl->startDrawingZone(event->pos());
                             }
                             else
                             {
                                 parentVisualizationWidget()->selectionZoneManager().select({ selectedZone });
                             }
                         }
                         {
                             auto posInPlot = this->impl->m_plot->mapFromParent(event->pos());
                             if(auto item = impl->m_plot->itemAt(posInPlot))
                             {
                                 if(qobject_cast<VisualizationSelectionZoneItem*>(item))
                                 {
                                     QMouseEvent e{QEvent::MouseButtonPress, posInPlot, event->button(), event->buttons(), event->modifiers()};
                                     sqpApp->sendEvent(this->impl->m_plot, &e);
                                 }
                             }
                         }
                         break;
                     case SqpApplication::PlotsInteractionMode::ZoomBox :
                         impl->startDrawingRect(event->pos());
                         break;
                     default:
                         if(auto item = impl->m_plot->itemAt(event->pos()))
                         {
                             emit impl->m_plot->itemClick(item,event);
                             if(qobject_cast<VisualizationSelectionZoneItem*>(item))
                             {
                                 setCursor(Qt::ClosedHandCursor);
                                 impl->enterPlotDrag(event->pos());
                             }
                         }
                         else
                         {
                             setCursor(Qt::ClosedHandCursor);
                             impl->enterPlotDrag(event->pos());
                         }
                     }
                 }
                 //event->accept();
                 QWidget::mousePressEvent(event);
             }
             void VisualizationGraphWidget::mouseDoubleClickEvent(QMouseEvent *event)
             {
                 impl->m_RenderingDelegate->onMouseDoubleClick(event);
             }
             void VisualizationGraphWidget::keyReleaseEvent(QKeyEvent *event)
             {
                 switch (event->key()) {
                     case Qt::Key_Control:
                         event->accept();
                         break;
                     case Qt::Key_Shift:
                         event->accept();
                         break;
                     default:
                         QWidget::keyReleaseEvent(event);
                         break;
                 }
                 setCursor(Qt::ArrowCursor);
                 //event->accept();
             }
             void VisualizationGraphWidget::keyPressEvent(QKeyEvent *event)
             {
                 switch (event->key()) {
                     case Qt::Key_Control:
                         setCursor(Qt::CrossCursor);
                         break;
                     case Qt::Key_Shift:
                         break;
                     case Qt::Key_M:
                         impl->rescaleY();
                         impl->m_plot->replot(QCustomPlot::rpQueuedReplot);
                         break;
                     case Qt::Key_Left:
                         if (event->modifiers() != Qt::ControlModifier) {
                             move(-0.1, Qt::Horizontal);
                         }
                         else {
                             zoom(2, this->width() / 2, Qt::Horizontal);
                         }
                         break;
                     case Qt::Key_Right:
                         if (event->modifiers() != Qt::ControlModifier) {
                             move(0.1, Qt::Horizontal);
                         }
                         else {
                             zoom(0.5, this->width() / 2, Qt::Horizontal);
                         }
                         break;
                     case Qt::Key_Up:
                         if (event->modifiers() != Qt::ControlModifier) {
                             move(0.1, Qt::Vertical);
                         }
                         else {
                             zoom(0.5, this->height() / 2, Qt::Vertical);
                         }
                         break;
                     case Qt::Key_Down:
                         if (event->modifiers() != Qt::ControlModifier) {
                             move(-0.1, Qt::Vertical);
                         }
                         else {
                             zoom(2, this->height() / 2, Qt::Vertical);
                         }
                         break;
                     default:
                         QWidget::keyPressEvent(event);
                         break;
                 }
             }
             QCustomPlot &VisualizationGraphWidget::plot() const noexcept
             {
                 return *impl->m_plot;
             }
             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);
                 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;
                     QHash<QString, FilteringAction *> filteredMenu;
                     for (auto zoneAction : zoneActions) {
                         auto isEnabled = zoneAction->isEnabled(selectedItems);
                         auto menu = &graphMenu;
                         QString menuPath;
                         for (auto subMenuName : zoneAction->subMenuList()) {
                             menuPath += '/';
                             menuPath += subMenuName;
                             if (!subMenus.contains(menuPath)) {
                                 menu = menu->addMenu(subMenuName);
                                 subMenus[menuPath] = menu;
                                 subMenusEnabled[menuPath] = isEnabled;
                             }
                             else {
                                 menu = subMenus.value(menuPath);
                                 if (isEnabled) {
                                     // The sub menu is enabled if at least one of its actions is enabled
                                     subMenusEnabled[menuPath] = true;
                                 }
                             }
                         }
                         FilteringAction *filterAction = nullptr;
                         if (sqpApp->actionsGuiController().isMenuFiltered(zoneAction->subMenuList())) {
                             filterAction = filteredMenu.value(menuPath);
                             if (!filterAction) {
                                 filterAction = new FilteringAction{this};
                                 filteredMenu[menuPath] = filterAction;
                                 menu->addAction(filterAction);
                             }
                         }
                         auto action = menu->addAction(zoneAction->name());
                         action->setEnabled(isEnabled);
                         action->setShortcut(zoneAction->displayedShortcut());
                         QObject::connect(action, &QAction::triggered,
                                          [zoneAction, selectedItems]() { zoneAction->execute(selectedItems); });
                         if (filterAction && zoneAction->isFilteringAllowed()) {
                             filterAction->addActionToFilter(action);
                         }
                     }
                     for (auto it = subMenus.cbegin(); it != subMenus.cend(); ++it) {
                         it.value()->setEnabled(subMenusEnabled[it.key()]);
                     }
                 }
                 if (!graphMenu.isEmpty()) {
                     graphMenu.exec(QCursor::pos());
                 }
             }
             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->updateTooltip(event);
                 auto axisPos = impl->posToAxisPos(event->pos());
                 // 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);
                     }
                 }
                 // Search for the selection zone under the mouse
                 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos());
                 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
             {
                 // Processes event only if the wheel occurs on axis rect
                 if (!dynamic_cast<QCPAxisRect *>(impl->m_plot->layoutElementAt(event->posF()))) {
                     return;
                 }
                 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);
                     impl->m_plot->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());
                     }
                     else if (isSelectionZoneMode && impl->m_DrawingZone == nullptr) {
                         // Starts a new selection zone
                         auto zoneAtPos = impl->selectionZoneAt(event->pos());
                         if (!zoneAtPos) {
                             impl->startDrawingZone(event->pos());
                         }
                     }
                 }
                 // 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());
                     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();
                     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();
                 // 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());
                     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 = impl->m_plot->xAxis->range();
                 auto dateTime = DateTimeRange{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, variable->range());
                     }
                 }
             }
             void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,
                                                                  const DateTimeRange &range)
             {
                 auto it = impl->m_VariableToPlotMultiMap.find(variable);
                 if (it != impl->m_VariableToPlotMultiMap.end()) {
                     impl->updateData(it->second, variable, range);
                 }
             }
             void VisualizationGraphWidget::variableUpdated(QUuid id)
             {
                 for (auto &[var, plotables] : impl->m_VariableToPlotMultiMap) {
                     if (var->ID() == id) {
                         impl->updateData(plotables, var, this->graphRange());
                     }
                 }
             }
             void VisualizationGraphWidget::variableDeleted(const std::shared_ptr<Variable> & variable)
             {
                 this->removeVariable(variable);
             }

gui/src/Visualization/VisualizationZoneWidget.cpp +68 -83

             #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/DateTimeRange.h>
             #include <Data/DateTimeRangeHelper.h>
             #include <DataSource/DataSourceController.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController2.h>
             #include <Visualization/operations/FindVariableOperation.h>
             #include <DragAndDrop/DragDropGuiController.h>
             #include <QUuid>
             #include <SqpApplication.h>
             #include <cmath>
             #include <QLayout>
             #include <QStyle>
             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 std::vector<std::shared_ptr<Variable> > &variables, int index,
                                    VisualizationZoneWidget *zoneWidget);
                 void dropProducts(const QVariantList &productsData, 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_PRODUCT_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().variables(
                             Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                         if (variables.size() != 1) {
                             return false;
                         }
                         auto variable = variables.front();
                         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 DateTimeRange &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);
                 insertGraph(0,graphWidget);
             }
             void VisualizationZoneWidget::insertGraph(int index, VisualizationGraphWidget *graphWidget)
             {
                 DEPRECATE(
-                auto layout = ui->dragDropContainer->layout();
+                    auto layout = ui->dragDropContainer->layout();
-                for(int i=0;i<layout->count();i++)
+                    for(int i=0;i<layout->count();i++)
+                    {
-                    auto graph = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(i)->widget());
+                        auto graph = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(i)->widget());
-                    connect(graphWidget, &VisualizationGraphWidget::setrange_sig, graph, &VisualizationGraphWidget::setGraphRange);
+                        connect(graphWidget, &VisualizationGraphWidget::setrange_sig, graph, &VisualizationGraphWidget::setGraphRange);
-                    connect(graph, &VisualizationGraphWidget::setrange_sig, graphWidget, &VisualizationGraphWidget::setGraphRange);
+                        connect(graph, &VisualizationGraphWidget::setrange_sig, graphWidget, &VisualizationGraphWidget::setGraphRange);
-            //        connect(graphWidget, &VisualizationGraphWidget::zoom_sig, graph, &VisualizationGraphWidget::zoom);
-            //        connect(graphWidget, &VisualizationGraphWidget::transform_sig, graph, &VisualizationGraphWidget::transform);
+                    if(auto graph = firstGraph())
+                    {
-            //        connect(graphWidget, qOverload<double,Qt::Orientation,bool>(&VisualizationGraphWidget::move_sig),
+                        graphWidget->setGraphRange(graph->graphRange(), true);
-            //                graph,       qOverload<double,Qt::Orientation,bool>(&VisualizationGraphWidget::move));
-            //        connect(graphWidget, qOverload<double,double,bool>(&VisualizationGraphWidget::move_sig),
-            //                graph,       qOverload<double,double,bool>(&VisualizationGraphWidget::move));
-            //        connect(graph, &VisualizationGraphWidget::zoom_sig, graphWidget, &VisualizationGraphWidget::zoom);
-            //        connect(graph, &VisualizationGraphWidget::transform_sig, graphWidget, &VisualizationGraphWidget::transform);
-            //        connect(graph,       qOverload<double,Qt::Orientation,bool>(&VisualizationGraphWidget::move_sig),
-            //                graphWidget, qOverload<double,Qt::Orientation,bool>(&VisualizationGraphWidget::move));
-            //        connect(graph,       qOverload<double,double,bool>(&VisualizationGraphWidget::move_sig),
-            //                graphWidget, qOverload<double,double,bool>(&VisualizationGraphWidget::move));
-                if(auto graph = firstGraph())
-                    graphWidget->setGraphRange(graph->graphRange(), true);
                 )
                 // 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 DateTimeRange &graphRange,
+            //    auto synchronizeZoneWidget = [this, graphWidget](const DateTimeRange &graphRange,
-                                                                 const DateTimeRange &oldGraphRange) {
+            //                                                     const DateTimeRange &oldGraphRange) {
-                    auto zoomType = DateTimeRangeHelper::getTransformationType(oldGraphRange, graphRange);
+            //        auto zoomType = DateTimeRangeHelper::getTransformationType(oldGraphRange, graphRange);
-                    auto frameLayout = ui->dragDropContainer->layout();
+            //        auto frameLayout = ui->dragDropContainer->layout();
-                    for (auto i = 0; i < frameLayout->count(); ++i) {
+            //        for (auto i = 0; i < frameLayout->count(); ++i) {
-                        auto graphChild
+            //            auto graphChild
-                            = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
+            //                = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
-                        if (graphChild && (graphChild != graphWidget)) {
+            //            if (graphChild && (graphChild != graphWidget)) {
-                            auto graphChildRange = graphChild->graphRange();
+            //                auto graphChildRange = graphChild->graphRange();
-                            switch (zoomType) {
+            //                switch (zoomType) {
-                                case TransformationType::ZoomIn: {
+            //                    case TransformationType::ZoomIn: {
-                                    auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
+            //                        auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
-                                    auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
+            //                        auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
-                                    graphChildRange.m_TStart += deltaLeft;
+            //                        graphChildRange.m_TStart += deltaLeft;
-                                    graphChildRange.m_TEnd -= deltaRight;
+            //                        graphChildRange.m_TEnd -= deltaRight;
-                                    break;
+            //                        break;
+            //                    }
-                                case TransformationType::ZoomOut: {
+            //                    case TransformationType::ZoomOut: {
-                                    auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
+            //                        auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
-                                    auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
+            //                        auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
-                                    graphChildRange.m_TStart -= deltaLeft;
+            //                        graphChildRange.m_TStart -= deltaLeft;
-                                    graphChildRange.m_TEnd += deltaRight;
+            //                        graphChildRange.m_TEnd += deltaRight;
-                                    break;
+            //                        break;
+            //                    }
-                                case TransformationType::PanRight: {
+            //                    case TransformationType::PanRight: {
-                                    auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
+            //                        auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
-                                    auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
+            //                        auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
-                                    graphChildRange.m_TStart += deltaLeft;
+            //                        graphChildRange.m_TStart += deltaLeft;
-                                    graphChildRange.m_TEnd += deltaRight;
+            //                        graphChildRange.m_TEnd += deltaRight;
-                                    break;
+            //                        break;
+            //                    }
-                                case TransformationType::PanLeft: {
+            //                    case TransformationType::PanLeft: {
-                                    auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
+            //                        auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
-                                    auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
+            //                        auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
-                                    graphChildRange.m_TStart -= deltaLeft;
+            //                        graphChildRange.m_TStart -= deltaLeft;
-                                    graphChildRange.m_TEnd -= deltaRight;
+            //                        graphChildRange.m_TEnd -= deltaRight;
-                                    break;
+            //                        break;
+            //                    }
-                                case TransformationType::Unknown: {
+            //                    case TransformationType::Unknown: {
-                                    break;
+            //                        break;
+            //                    }
-                                default:
+            //                    default:
-                                    qCCritical(LOG_VisualizationZoneWidget())
+            //                        qCCritical(LOG_VisualizationZoneWidget())
-                                        << tr("Impossible to synchronize: zoom type not take into account");
+            //                            << tr("Impossible to synchronize: zoom type not take into account");
-                                    // No action
+            //                        // No action
-                                    break;
+            //                        break;
+            //                }
-                            graphChild->setFlags(GraphFlag::DisableAll);
+            //                graphChild->setFlags(GraphFlag::DisableAll);
-                            graphChild->setGraphRange(graphChildRange);
+            //                graphChild->setGraphRange(graphChildRange, true);
-                            graphChild->setFlags(GraphFlag::EnableAll);
+            //                graphChild->setFlags(GraphFlag::EnableAll);
+            //            }
+            //        }
-                };
+            //    };
                 // connection for synchronization
-                connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
+                //connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
                 connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
                         &VisualizationZoneWidget::onVariableAdded);
                 connect(graphWidget, &VisualizationGraphWidget::variableAboutToBeRemoved, this,
                         &VisualizationZoneWidget::onVariableAboutToBeRemoved);
                 auto range = DateTimeRange{};
                 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 std::vector<std::shared_ptr<Variable> > variables, int index)
             {
                 if (variables.empty()) {
                     return nullptr;
                 }
                 auto graphWidget = createGraph(variables.front(), 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::closeAllGraphs()
             {
                 processGraphs(*ui->dragDropContainer->layout(),
                               [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
             }
             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().variables(
                         Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                     impl->dropVariables(variables, index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
                     auto products = sqpApp->dataSourceController().productsDataForMimeData(
                         mimeData->data(MIME_TYPE_PRODUCT_LIST));
                     impl->dropProducts(products, 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().variables(
                         Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                     for (const auto &var : variables) {
                         graphWidget->addVariable(var, graphWidget->graphRange());
                     }
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
                     auto products = sqpApp->dataSourceController().productsDataForMimeData(
                         mimeData->data(MIME_TYPE_PRODUCT_LIST));
                     auto context = new QObject{this};
                     auto range = TimeController::timeRangeForMimeData(mimeData->data(MIME_TYPE_TIME_RANGE));
                     // BTW this is really dangerous, this assumes the next created variable will be this one...
                     connect(&sqpApp->variableController(), &VariableController2::variableAdded, context,
                             [this, graphWidget, context, range](auto variable) {
                                 if(sqpApp->variableController().isReady(variable))
                                 {
                                     graphWidget->addVariable(variable, range);
                                     delete context;
                                 }
                                 else
                                 {
                                     // -> this is pure insanity! this is a workaround to make a bad design work
                                     QObject::connect(variable.get(), &Variable::updated,context,
                                         [graphWidget, context, range, variable]()
                                         {
                                             graphWidget->addVariable(variable, range);
                                             delete context;
                                         });
                                 }
                             },
                             Qt::QueuedConnection);
                     auto productData = products.first().toHash();
                     QMetaObject::invokeMethod(&sqpApp->dataSourceController(), "requestVariable",
                                               Qt::QueuedConnection, Q_ARG(QVariantHash, productData));
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_TIME_RANGE)) {
                     auto range = TimeController::timeRangeForMimeData(mimeData->data(MIME_TYPE_TIME_RANGE));
                     graphWidget->setGraphRange(range, true, true);
                 }
                 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.empty()) {
                     // 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.empty() && 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 std::vector<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.size() > 1) {
                     return;
                 }
                 zoneWidget->createGraph(variables, index);
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropProducts(
                 const QVariantList &productsData, int index, VisualizationZoneWidget *zoneWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
                 if (productsData.count() != 1) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropProducts, dropping multiple products, operation "
                               "aborted.");
                     return;
                 }
                 auto context = new QObject{zoneWidget};
                 connect(&sqpApp->variableController(), &VariableController2::variableAdded, context,
                         [this, index, zoneWidget, context](auto variable) {
                             zoneWidget->createGraph(variable, index);
                             delete context; // removes the connection
                         },
                         Qt::QueuedConnection);
                 auto productData = productsData.first().toHash();
                 QMetaObject::invokeMethod(&sqpApp->dataSourceController(), "requestVariable",
                                           Qt::QueuedConnection, Q_ARG(QVariantHash, productData));
             }

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