HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1422:a323cf6b7201

Removed old Variable impl...

jeandet -

r1422:a323cf6b7201

parent child

Context file:

r1422:a323cf6b7201

app/src/MainWindow.cpp 0 -1

             /*------------------------------------------------------------------------------
             -- This file is a part of the SciQLop Software
             -- Copyright (C) 2017, Plasma Physics Laboratory - CNRS
             --
             -- This program is free software; you can redistribute it and/or modify
             -- it under the terms of the GNU General Public License as published by
             -- the Free Software Foundation; either version 2 of the License, or
             -- (at your option) any later version.
             --
             -- This program is distributed in the hope that it will be useful,
             -- but WITHOUT ANY WARRANTY; without even the implied warranty of
             -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
             -- GNU General Public License for more details.
             --
             -- You should have received a copy of the GNU General Public License
             -- along with this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "MainWindow.h"
             #include "ui_MainWindow.h"
             #include <Catalogue/CatalogueController.h>
             //#include <Catalogue/CatalogueExplorer.h>
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceWidget.h>
             #include <Settings/SqpSettingsDialog.h>
             #include <Settings/SqpSettingsGeneralWidget.h>
             #include <SidePane/SqpSidePane.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <TimeWidget/TimeWidget.h>
-            #include <Variable/Variable.h>
             #include <Visualization/VisualizationController.h>
             #include <QAction>
             #include <QCloseEvent>
             #include <QDate>
             #include <QDir>
             #include <QFileDialog>
             #include <QMessageBox>
             #include <QToolBar>
             #include <QToolButton>
             #include <memory.h>
             #include "iostream"
             Q_LOGGING_CATEGORY(LOG_MainWindow, "MainWindow")
             namespace
             {
             const auto LEFTMAININSPECTORWIDGETSPLITTERINDEX = 0;
             const auto LEFTINSPECTORSIDEPANESPLITTERINDEX = 1;
             const auto VIEWPLITTERINDEX = 2;
             const auto RIGHTINSPECTORSIDEPANESPLITTERINDEX = 3;
             const auto RIGHTMAININSPECTORWIDGETSPLITTERINDEX = 4;
             }
             class MainWindow::MainWindowPrivate
             {
             public:
                 explicit MainWindowPrivate(MainWindow* mainWindow)
                         : m_LastOpenLeftInspectorSize {}
                         , m_LastOpenRightInspectorSize {}
                         , m_GeneralSettingsWidget { new SqpSettingsGeneralWidget { mainWindow } }
                         , m_SettingsDialog { new SqpSettingsDialog { mainWindow } }
                 //, m_CatalogExplorer { new CatalogueExplorer { mainWindow } }
                 {
                 }
                 QSize m_LastOpenLeftInspectorSize;
                 QSize m_LastOpenRightInspectorSize;
                 /// General settings widget. MainWindow has the ownership
                 SqpSettingsGeneralWidget* m_GeneralSettingsWidget;
                 /// Settings dialog. MainWindow has the ownership
                 SqpSettingsDialog* m_SettingsDialog;
                 /// Catalogue dialog. MainWindow has the ownership
                 // CatalogueExplorer* m_CatalogExplorer;
                 bool checkDataToSave(QWidget* parentWidget);
             };
             MainWindow::MainWindow(QWidget* parent)
                     : QMainWindow { parent }
                     , m_Ui { new Ui::MainWindow }
                     , impl { spimpl::make_unique_impl<MainWindowPrivate>(this) }
             {
                 m_Ui->setupUi(this);
                 m_Ui->splitter->setCollapsible(LEFTINSPECTORSIDEPANESPLITTERINDEX, false);
                 m_Ui->splitter->setCollapsible(RIGHTINSPECTORSIDEPANESPLITTERINDEX, false);
                 // impl->m_CatalogExplorer->setVisualizationWidget(m_Ui->view);
                 auto spacerLeftTop = new QWidget {};
                 spacerLeftTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerLeftBottom = new QWidget {};
                 spacerLeftBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerRightTop = new QWidget {};
                 spacerRightTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerRightBottom = new QWidget {};
                 spacerRightBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto openInspector = [this](bool checked, bool right, auto action) {
                     action->setIcon(
                         QIcon { (checked ^ right) ? ":/icones/next.png" : ":/icones/previous.png" });
                     auto& lastInspectorSize
                         = right ? impl->m_LastOpenRightInspectorSize : impl->m_LastOpenLeftInspectorSize;
                     auto nextInspectorSize = right ? m_Ui->rightMainInspectorWidget->size()
                                                    : m_Ui->leftMainInspectorWidget->size();
                     // Update of the last opened geometry
                     if (checked)
                     {
                         lastInspectorSize = nextInspectorSize;
                     }
                     auto startSize = lastInspectorSize;
                     auto endSize = startSize;
                     endSize.setWidth(0);
                     auto splitterInspectorIndex
                         = right ? RIGHTMAININSPECTORWIDGETSPLITTERINDEX : LEFTMAININSPECTORWIDGETSPLITTERINDEX;
                     auto currentSizes = m_Ui->splitter->sizes();
                     if (checked)
                     {
                         // adjust sizes individually here, e.g.
                         currentSizes[splitterInspectorIndex] -= lastInspectorSize.width();
                         currentSizes[VIEWPLITTERINDEX] += lastInspectorSize.width();
                         m_Ui->splitter->setSizes(currentSizes);
                     }
                     else
                     {
                         // adjust sizes individually here, e.g.
                         currentSizes[splitterInspectorIndex] += lastInspectorSize.width();
                         currentSizes[VIEWPLITTERINDEX] -= lastInspectorSize.width();
                         m_Ui->splitter->setSizes(currentSizes);
                     }
                 };
                 // //////////////// //
                 // Menu and Toolbar //
                 // //////////////// //
                 this->menuBar()->addAction(tr("File"));
                 auto toolsMenu = this->menuBar()->addMenu(tr("Tools"));
                 toolsMenu->addAction(tr("Settings..."), [this]() {
                     // Loads settings
                     impl->m_SettingsDialog->loadSettings();
                     // Open settings dialog and save settings if the dialog is accepted
                     if (impl->m_SettingsDialog->exec() == QDialog::Accepted)
                     {
                         impl->m_SettingsDialog->saveSettings();
                     }
                 });
                 auto mainToolBar = this->addToolBar(QStringLiteral("MainToolBar"));
                 auto timeWidget = new TimeWidget {};
                 mainToolBar->addWidget(timeWidget);
                 // Interaction modes
                 auto actionPointerMode = new QAction { QIcon(":/icones/pointer.png"), "Move", this };
                 actionPointerMode->setCheckable(true);
                 actionPointerMode->setChecked(
                     sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::None);
                 connect(actionPointerMode, &QAction::triggered,
                     []() { sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::None); });
                 auto actionZoomMode = new QAction { QIcon(":/icones/zoom.png"), "Zoom", this };
                 actionZoomMode->setCheckable(true);
                 actionZoomMode->setChecked(
                     sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::ZoomBox);
                 connect(actionZoomMode, &QAction::triggered,
                     []() { sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::ZoomBox); });
                 auto actionOrganisationMode = new QAction { QIcon(":/icones/drag.png"), "Organize", this };
                 actionOrganisationMode->setCheckable(true);
                 actionOrganisationMode->setChecked(
                     sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::DragAndDrop);
                 connect(actionOrganisationMode, &QAction::triggered, []() {
                     sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::DragAndDrop);
                 });
                 auto actionZonesMode = new QAction { QIcon(":/icones/rectangle.png"), "Zones", this };
                 actionZonesMode->setCheckable(true);
                 actionZonesMode->setChecked(
                     sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones);
                 connect(actionZonesMode, &QAction::triggered, []() {
                     sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::SelectionZones);
                 });
                 auto modeActionGroup = new QActionGroup { this };
                 modeActionGroup->addAction(actionZoomMode);
                 modeActionGroup->addAction(actionZonesMode);
                 modeActionGroup->addAction(actionOrganisationMode);
                 modeActionGroup->addAction(actionPointerMode);
                 modeActionGroup->setExclusive(true);
                 mainToolBar->addSeparator();
                 mainToolBar->addAction(actionPointerMode);
                 mainToolBar->addAction(actionZoomMode);
                 mainToolBar->addAction(actionOrganisationMode);
                 mainToolBar->addAction(actionZonesMode);
                 mainToolBar->addSeparator();
                 // Cursors
                 auto btnCursor = new QToolButton { this };
                 btnCursor->setIcon(QIcon(":/icones/cursor.png"));
                 btnCursor->setText("Cursor");
                 btnCursor->setToolTip("Cursor");
                 btnCursor->setPopupMode(QToolButton::InstantPopup);
                 auto cursorMenu = new QMenu("CursorMenu", this);
                 btnCursor->setMenu(cursorMenu);
                 auto noCursorAction = cursorMenu->addAction("No Cursor");
                 noCursorAction->setCheckable(true);
                 noCursorAction->setChecked(
                     sqpApp->plotsCursorMode() == SqpApplication::PlotsCursorMode::NoCursor);
                 connect(noCursorAction, &QAction::triggered,
                     []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::NoCursor); });
                 cursorMenu->addSeparator();
                 auto verticalCursorAction = cursorMenu->addAction("Vertical Cursor");
                 verticalCursorAction->setCheckable(true);
                 verticalCursorAction->setChecked(
                     sqpApp->plotsCursorMode() == SqpApplication::PlotsCursorMode::Vertical);
                 connect(verticalCursorAction, &QAction::triggered,
                     []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Vertical); });
                 auto temporalCursorAction = cursorMenu->addAction("Temporal Cursor");
                 temporalCursorAction->setCheckable(true);
                 temporalCursorAction->setChecked(
                     sqpApp->plotsCursorMode() == SqpApplication::PlotsCursorMode::Temporal);
                 connect(temporalCursorAction, &QAction::triggered,
                     []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Temporal); });
                 auto horizontalCursorAction = cursorMenu->addAction("Horizontal Cursor");
                 horizontalCursorAction->setCheckable(true);
                 horizontalCursorAction->setChecked(
                     sqpApp->plotsCursorMode() == SqpApplication::PlotsCursorMode::Horizontal);
                 connect(horizontalCursorAction, &QAction::triggered,
                     []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Horizontal); });
                 auto crossCursorAction = cursorMenu->addAction("Cross Cursor");
                 crossCursorAction->setCheckable(true);
                 crossCursorAction->setChecked(
                     sqpApp->plotsCursorMode() == SqpApplication::PlotsCursorMode::Cross);
                 connect(crossCursorAction, &QAction::triggered,
                     []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Cross); });
                 mainToolBar->addWidget(btnCursor);
                 auto cursorModeActionGroup = new QActionGroup { this };
                 cursorModeActionGroup->setExclusive(true);
                 cursorModeActionGroup->addAction(noCursorAction);
                 cursorModeActionGroup->addAction(verticalCursorAction);
                 cursorModeActionGroup->addAction(temporalCursorAction);
                 cursorModeActionGroup->addAction(horizontalCursorAction);
                 cursorModeActionGroup->addAction(crossCursorAction);
                 // Catalog
                 mainToolBar->addSeparator();
                 //    mainToolBar->addAction(QIcon(":/icones/catalogue.png"), "Catalogues",
                 //        [this]() { impl->m_CatalogExplorer->show(); });
                 // //////// //
                 // Settings //
                 // //////// //
                 // Registers "general settings" widget to the settings dialog
                 impl->m_SettingsDialog->registerWidget(
                     QStringLiteral("General"), impl->m_GeneralSettingsWidget);
                 // /////////// //
                 // Connections //
                 // /////////// //
                 // Controllers / controllers connections
                 //    connect(&sqpApp->timeController(), SIGNAL(timeUpdated(DateTimeRange)),
                 //    &sqpApp->variableController(),
                 //            SLOT(onDateTimeOnSelection(DateTimeRange)));
                 // Widgets / controllers connections
                 // DataSource
                 connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem*)),
                     m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem*)));
                 // Time
                 connect(timeWidget, SIGNAL(timeUpdated(DateTimeRange)), &sqpApp->timeController(),
                     SLOT(onTimeToUpdate(DateTimeRange)));
                 // Visualization
                 connect(&sqpApp->visualizationController(),
                     SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), m_Ui->view,
                     SLOT(onVariableAboutToBeDeleted(std::shared_ptr<Variable>)));
                 connect(&sqpApp->visualizationController(),
                     SIGNAL(rangeChanged(std::shared_ptr<Variable>, const DateTimeRange&)), m_Ui->view,
                     SLOT(onRangeChanged(std::shared_ptr<Variable>, const DateTimeRange&)));
                 // Widgets / widgets connections
                 // For the following connections, we use DirectConnection to allow each widget that can
                 // potentially attach a menu to the variable's menu to do so before this menu is displayed.
                 // The order of connections is also important, since it determines the order in which each
                 // widget will attach its menu
                 connect(m_Ui->variableInspectorWidget,
                     SIGNAL(tableMenuAboutToBeDisplayed(QMenu*, const QVector<std::shared_ptr<Variable>>&)),
                     m_Ui->view, SLOT(attachVariableMenu(QMenu*, const QVector<std::shared_ptr<Variable>>&)),
                     Qt::DirectConnection);
             }
             MainWindow::~MainWindow() {}
             void MainWindow::changeEvent(QEvent* e)
             {
                 QMainWindow::changeEvent(e);
                 switch (e->type())
                 {
                     case QEvent::LanguageChange:
                         m_Ui->retranslateUi(this);
                         break;
                     default:
                         break;
                 }
             }
             void MainWindow::closeEvent(QCloseEvent* event)
             {
                 if (!impl->checkDataToSave(this))
                 {
                     event->ignore();
                 }
                 else
                 {
                     event->accept();
                 }
             }
             void MainWindow::keyPressEvent(QKeyEvent* event)
             {
                 switch (event->key())
                 {
                     case Qt::Key_F11:
                         if (this->isFullScreen())
                         {
                             this->showNormal();
                         }
                         else
                         {
                             this->showFullScreen();
                         }
                         break;
                     default:
                         break;
                 }
             }
             bool MainWindow::MainWindowPrivate::checkDataToSave(QWidget* parentWidget)
             {
                 //    auto hasChanges = sqpApp->catalogueController().hasChanges();
                 //    if (hasChanges)
                 //    {
                 //        // There are some unsaved changes
                 //        switch (QMessageBox::question(parentWidget, tr("Save changes"),
                 //            tr("The catalogue controller has unsaved changes.\nDo you want to save them ?"),
                 //            QMessageBox::SaveAll | QMessageBox::Discard | QMessageBox::Cancel,
                 //            QMessageBox::SaveAll))
                 //        {
                 //            case QMessageBox::SaveAll:
                 //                sqpApp->catalogueController().saveAll();
                 //                break;
                 //            case QMessageBox::Discard:
                 //                break;
                 //            case QMessageBox::Cancel:
                 //            default:
                 //                return false;
                 //        }
                 //    }
                 return true;
             }

core +1 -1

	@@ -1,1 +1,1
	1	Subproject commit ae48b17833443bc2730a7511f964569dc7cdb1df		1	Subproject commit cc26524fb5d10feca3820e6921c9cd3cfb1a3591

gui/src/DragAndDrop/DragDropGuiController.cpp +1 -2

             #include "DragAndDrop/DragDropGuiController.h"
             #include "DragAndDrop/DragDropScroller.h"
             #include "DragAndDrop/DragDropTabSwitcher.h"
             #include "SqpApplication.h"
             #include "Visualization/VisualizationDragDropContainer.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/operations/FindVariableOperation.h"
             #include "DataSource/DataSourceController.h"
-            #include "Variable/Variable.h"
             #include "Variable/VariableController2.h"
             #include "Common/MimeTypesDef.h"
             #include "Common/VisualizationDef.h"
             #include <QDir>
             #include <QLabel>
             #include <QUrl>
             #include <QVBoxLayout>
             Q_LOGGING_CATEGORY(LOG_DragDropGuiController, "DragDropGuiController")
             struct DragDropGuiController::DragDropGuiControllerPrivate
             {
                 VisualizationDragWidget* m_CurrentDragWidget = nullptr;
                 std::unique_ptr<QWidget> m_PlaceHolder = nullptr;
                 QLabel* m_PlaceHolderLabel;
                 QWidget* m_PlaceBackground;
                 std::unique_ptr<DragDropScroller> m_DragDropScroller = nullptr;
                 std::unique_ptr<DragDropTabSwitcher> m_DragDropTabSwitcher = nullptr;
                 QString m_ImageTempUrl; // Temporary file for image url generated by the drag & drop. Not using
                                         // QTemporaryFile to have a name which is not generated.
                 VisualizationDragWidget* m_HighlightedDragWidget = nullptr;
                 QMetaObject::Connection m_DragWidgetDestroyedConnection;
                 QMetaObject::Connection m_HighlightedWidgetDestroyedConnection;
                 QList<QWidget*> m_WidgetToClose;
                 explicit DragDropGuiControllerPrivate()
                         : m_PlaceHolder { std::make_unique<QWidget>() }
                         , m_DragDropScroller { std::make_unique<DragDropScroller>() }
                         , m_DragDropTabSwitcher { std::make_unique<DragDropTabSwitcher>() }
                 {
                     auto layout = new QVBoxLayout { m_PlaceHolder.get() };
                     layout->setSpacing(0);
                     layout->setContentsMargins(0, 0, 0, 0);
                     m_PlaceHolderLabel = new QLabel { "", m_PlaceHolder.get() };
                     m_PlaceHolderLabel->setMinimumHeight(25);
                     layout->addWidget(m_PlaceHolderLabel);
                     m_PlaceBackground = new QWidget { m_PlaceHolder.get() };
                     m_PlaceBackground->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                     layout->addWidget(m_PlaceBackground);
                     sqpApp->installEventFilter(m_DragDropScroller.get());
                     sqpApp->installEventFilter(m_DragDropTabSwitcher.get());
                     m_ImageTempUrl = QDir::temp().absoluteFilePath("Sciqlop_graph.png");
                 }
                 void preparePlaceHolder(
                     DragDropGuiController::PlaceHolderType type, const QString& topLabelText) const
                 {
                     if (m_CurrentDragWidget)
                     {
                         m_PlaceHolder->setMinimumSize(m_CurrentDragWidget->size());
                         m_PlaceHolder->setSizePolicy(m_CurrentDragWidget->sizePolicy());
                     }
                     else
                     {
                         // Configuration of the placeHolder when there is no dragWidget
                         // (for instance with a drag from a variable)
                         m_PlaceHolder->setMinimumSize(0, GRAPH_MINIMUM_HEIGHT);
                         m_PlaceHolder->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                     }
                     switch (type)
                     {
                         case DragDropGuiController::PlaceHolderType::Graph:
                             m_PlaceBackground->setStyleSheet(
                                 "background-color: #BBD5EE; border: 1px solid #2A7FD4");
                             break;
                         case DragDropGuiController::PlaceHolderType::Zone:
                         case DragDropGuiController::PlaceHolderType::Default:
                             m_PlaceBackground->setStyleSheet(
                                 "background-color: #BBD5EE; border: 2px solid #2A7FD4");
                             m_PlaceHolderLabel->setStyleSheet("color: #2A7FD4");
                             break;
                     }
                     m_PlaceHolderLabel->setText(topLabelText);
                     m_PlaceHolderLabel->setVisible(!topLabelText.isEmpty());
                 }
             };
             DragDropGuiController::DragDropGuiController()
                     : impl { spimpl::make_unique_impl<DragDropGuiControllerPrivate>() }
             {
             }
             DragDropGuiController::~DragDropGuiController()
             {
                 QFile::remove(impl->m_ImageTempUrl);
             }
             void DragDropGuiController::resetDragAndDrop()
             {
                 setCurrentDragWidget(nullptr);
                 impl->m_HighlightedDragWidget = nullptr;
             }
             void DragDropGuiController::setCurrentDragWidget(VisualizationDragWidget* dragWidget)
             {
                 if (impl->m_CurrentDragWidget)
                 {
                     QObject::disconnect(impl->m_DragWidgetDestroyedConnection);
                 }
                 if (dragWidget)
                 {
                     // ensures the impl->m_CurrentDragWidget is reset when the widget is destroyed
                     impl->m_DragWidgetDestroyedConnection = QObject::connect(dragWidget,
                         &VisualizationDragWidget::destroyed, [this]() { impl->m_CurrentDragWidget = nullptr; });
                 }
                 impl->m_CurrentDragWidget = dragWidget;
             }
             VisualizationDragWidget* DragDropGuiController::getCurrentDragWidget() const
             {
                 return impl->m_CurrentDragWidget;
             }
             QWidget& DragDropGuiController::placeHolder() const
             {
                 return *impl->m_PlaceHolder;
             }
             void DragDropGuiController::insertPlaceHolder(
                 QVBoxLayout* layout, int index, PlaceHolderType type, const QString& topLabelText)
             {
                 removePlaceHolder();
                 impl->preparePlaceHolder(type, topLabelText);
                 layout->insertWidget(index, impl->m_PlaceHolder.get());
                 impl->m_PlaceHolder->show();
             }
             void DragDropGuiController::removePlaceHolder()
             {
                 auto parentWidget = impl->m_PlaceHolder->parentWidget();
                 if (parentWidget)
                 {
                     parentWidget->layout()->removeWidget(impl->m_PlaceHolder.get());
                     impl->m_PlaceHolder->setParent(nullptr);
                     impl->m_PlaceHolder->hide();
                 }
             }
             bool DragDropGuiController::isPlaceHolderSet() const
             {
                 return impl->m_PlaceHolder->parentWidget();
             }
             void DragDropGuiController::addDragDropScrollArea(QScrollArea* scrollArea)
             {
                 impl->m_DragDropScroller->addScrollArea(scrollArea);
             }
             void DragDropGuiController::removeDragDropScrollArea(QScrollArea* scrollArea)
             {
                 impl->m_DragDropScroller->removeScrollArea(scrollArea);
             }
             void DragDropGuiController::addDragDropTabBar(QTabBar* tabBar)
             {
                 impl->m_DragDropTabSwitcher->addTabBar(tabBar);
             }
             void DragDropGuiController::removeDragDropTabBar(QTabBar* tabBar)
             {
                 impl->m_DragDropTabSwitcher->removeTabBar(tabBar);
             }
             QUrl DragDropGuiController::imageTemporaryUrl(const QImage& image) const
             {
                 image.save(impl->m_ImageTempUrl);
                 return QUrl::fromLocalFile(impl->m_ImageTempUrl);
             }
             void DragDropGuiController::setHightlightedDragWidget(VisualizationDragWidget* dragWidget)
             {
                 if (impl->m_HighlightedDragWidget)
                 {
                     impl->m_HighlightedDragWidget->highlightForMerge(false);
                     QObject::disconnect(impl->m_HighlightedWidgetDestroyedConnection);
                 }
                 if (dragWidget)
                 {
                     dragWidget->highlightForMerge(true);
                     // ensures the impl->m_HighlightedDragWidget is reset when the widget is destroyed
                     impl->m_DragWidgetDestroyedConnection
                         = QObject::connect(dragWidget, &VisualizationDragWidget::destroyed,
                             [this]() { impl->m_HighlightedDragWidget = nullptr; });
                 }
                 impl->m_HighlightedDragWidget = dragWidget;
             }
             VisualizationDragWidget* DragDropGuiController::getHightlightedDragWidget() const
             {
                 return impl->m_HighlightedDragWidget;
             }
             void DragDropGuiController::delayedCloseWidget(QWidget* widget)
             {
                 widget->hide();
                 impl->m_WidgetToClose << widget;
             }
             void DragDropGuiController::doCloseWidgets()
             {
                 for (auto widget : impl->m_WidgetToClose)
                 {
                     widget->close();
                 }
                 impl->m_WidgetToClose.clear();
             }
             bool DragDropGuiController::checkMimeDataForVisualization(
                 const QMimeData* mimeData, VisualizationDragDropContainer* dropContainer)
             {
                 if (!mimeData || !dropContainer)
                 {
                     qCWarning(LOG_DragDropGuiController()) << QObject::tr(
                         "DragDropGuiController::checkMimeDataForVisualization, invalid input parameters.");
                     Q_ASSERT(false);
                     return false;
                 }
                 auto result = false;
                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST))
                 {
                     auto variables = sqpApp->variableController().variables(
-                        Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
+                        Variable2::IDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                     if (variables.size() == 1)
                     {
                         auto variable = variables[0];
                         if (variable->data() != nullptr)
                         {
                             // Check that the variable is not already in a graph
                             auto parent = dropContainer->parentWidget();
                             while (parent && qobject_cast<VisualizationWidget*>(parent) == nullptr)
                             {
                                 parent = parent->parentWidget(); // Search for the top level VisualizationWidget
                             }
                             if (parent)
                             {
                                 auto visualizationWidget = static_cast<VisualizationWidget*>(parent);
                                 FindVariableOperation findVariableOperation { variable };
                                 visualizationWidget->accept(&findVariableOperation);
                                 auto variableContainers = findVariableOperation.result();
                                 if (variableContainers.empty())
                                 {
                                     result = true;
                                 }
                                 else
                                 {
                                     // result = false: the variable already exist in the visualisation
                                 }
                             }
                             else
                             {
                                 qCWarning(LOG_DragDropGuiController()) << QObject::tr(
                                     "DragDropGuiController::checkMimeDataForVisualization, the parent "
                                     "VisualizationWidget cannot be found. Cannot check if the variable is "
                                     "already used or not.");
                             }
                         }
                         else
                         {
                             // result = false: the variable is not fully loaded
                         }
                     }
                     else
                     {
                         // result = false: cannot drop multiple variables in the visualisation
                     }
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST))
                 {
                     auto productDataList = sqpApp->dataSourceController().productsDataForMimeData(
                         mimeData->data(MIME_TYPE_PRODUCT_LIST));
                     if (productDataList.count() == 1)
                     {
                         result = true;
                     }
                     else
                     {
                         // result = false: cannot drop multiple products in the visualisation
                     }
                 }
                 else
                 {
                     // Other MIME data
                     // no special rules, accepted by default
                     result = true;
                 }
                 return result;
             }

gui/src/SqpApplication.cpp 0 -1

             #include "SqpApplication.h"
             #include <Actions/ActionsGuiController.h>
             #include <Catalogue/CatalogueController.h>
             #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
             #include <DragAndDrop/DragDropGuiController.h>
             #include <Network/NetworkController.h>
             #include <QThread>
             #include <Time/TimeController.h>
-            #include <Variable/Variable.h>
             #include <Variable/VariableController2.h>
             #include <Variable/VariableModel2.h>
             #include <Visualization/VisualizationController.h>
             Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
             class SqpApplication::SqpApplicationPrivate
             {
             public:
                 SqpApplicationPrivate()
                         : m_VariableController { std::make_shared<VariableController2>() }
                         , m_PlotInterractionMode(SqpApplication::PlotsInteractionMode::None)
                         , m_PlotCursorMode(SqpApplication::PlotsCursorMode::NoCursor)
                 {
                     // /////////////////////////////// //
                     // Connections between controllers //
                     // /////////////////////////////// //
                     // VariableController <-> DataSourceController
                     connect(&m_DataSourceController, &DataSourceController::createVariable,
                         [](const QString& variableName, const QVariantHash& variableMetadata,
                             std::shared_ptr<IDataProvider> variableProvider) {
                             sqpApp->variableController().createVariable(variableName, variableMetadata,
                                 variableProvider, sqpApp->timeController().dateTime());
                         });
                     // VariableController <-> VisualizationController
                     //        connect(m_VariableController.get(),
                     //                SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
                     //                m_VisualizationController.get(),
                     //                SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
                     //                Qt::DirectConnection);
                     //        connect(m_VariableController.get(),
                     //                SIGNAL(rangeChanged(std::shared_ptr<Variable>, const DateTimeRange &)),
                     //                m_VisualizationController.get(),
                     //                SIGNAL(rangeChanged(std::shared_ptr<Variable>, const DateTimeRange &)));
                     m_DataSourceController.moveToThread(&m_DataSourceControllerThread);
                     m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
                     m_NetworkController.moveToThread(&m_NetworkControllerThread);
                     m_NetworkControllerThread.setObjectName("NetworkControllerThread");
                     m_VisualizationController.moveToThread(&m_VisualizationControllerThread);
                     m_VisualizationControllerThread.setObjectName("VsualizationControllerThread");
                     // Additionnal init
                     // m_VariableController->setTimeController(m_TimeController.get());
                 }
                 virtual ~SqpApplicationPrivate()
                 {
                     m_DataSourceControllerThread.quit();
                     m_DataSourceControllerThread.wait();
                     m_NetworkControllerThread.quit();
                     m_NetworkControllerThread.wait();
                     m_VisualizationControllerThread.quit();
                     m_VisualizationControllerThread.wait();
                 }
                 DataSourceController m_DataSourceController;
                 std::shared_ptr<VariableController2> m_VariableController;
                 TimeController m_TimeController;
                 NetworkController m_NetworkController;
                 VisualizationController m_VisualizationController;
                 CatalogueController m_CatalogueController;
                 QThread m_DataSourceControllerThread;
                 QThread m_NetworkControllerThread;
                 QThread m_VisualizationControllerThread;
                 DragDropGuiController m_DragDropGuiController;
                 ActionsGuiController m_ActionsGuiController;
                 SqpApplication::PlotsInteractionMode m_PlotInterractionMode;
                 SqpApplication::PlotsCursorMode m_PlotCursorMode;
             };
             SqpApplication::SqpApplication(int& argc, char** argv)
                     : QApplication { argc, argv }, impl { spimpl::make_unique_impl<SqpApplicationPrivate>() }
             {
                 qCDebug(LOG_SqpApplication()) << tr("SqpApplication construction") << QThread::currentThread();
                 QGuiApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
                 connect(&impl->m_DataSourceControllerThread, &QThread::started, &impl->m_DataSourceController,
                     &DataSourceController::initialize);
                 connect(&impl->m_DataSourceControllerThread, &QThread::finished, &impl->m_DataSourceController,
                     &DataSourceController::finalize);
                 connect(&impl->m_NetworkControllerThread, &QThread::started, &impl->m_NetworkController,
                     &NetworkController::initialize);
                 connect(&impl->m_NetworkControllerThread, &QThread::finished, &impl->m_NetworkController,
                     &NetworkController::finalize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::started,
                     &impl->m_VisualizationController, &VisualizationController::initialize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
                     &impl->m_VisualizationController, &VisualizationController::finalize);
                 impl->m_DataSourceControllerThread.start();
                 impl->m_NetworkControllerThread.start();
                 impl->m_VisualizationControllerThread.start();
                 // impl->m_CatalogueController.initialize();
             }
             SqpApplication::~SqpApplication() {}
             void SqpApplication::initialize() {}
             DataSourceController& SqpApplication::dataSourceController() noexcept
             {
                 return impl->m_DataSourceController;
             }
             NetworkController& SqpApplication::networkController() noexcept
             {
                 return impl->m_NetworkController;
             }
             TimeController& SqpApplication::timeController() noexcept
             {
                 return impl->m_TimeController;
             }
             VariableController2& SqpApplication::variableController() noexcept
             {
                 return *impl->m_VariableController;
             }
             std::shared_ptr<VariableController2> SqpApplication::variableControllerOwner() noexcept
             {
                 return impl->m_VariableController;
             }
             // VariableModel2 &SqpApplication::variableModel() noexcept
             //{
             //    return impl->m_VariableModel;
             //}
             VisualizationController& SqpApplication::visualizationController() noexcept
             {
                 return impl->m_VisualizationController;
             }
             CatalogueController& SqpApplication::catalogueController() noexcept
             {
                 return impl->m_CatalogueController;
             }
             DragDropGuiController& SqpApplication::dragDropGuiController() noexcept
             {
                 return impl->m_DragDropGuiController;
             }
             ActionsGuiController& SqpApplication::actionsGuiController() noexcept
             {
                 return impl->m_ActionsGuiController;
             }
             SqpApplication::PlotsInteractionMode SqpApplication::plotsInteractionMode() const
             {
                 return impl->m_PlotInterractionMode;
             }
             void SqpApplication::setPlotsInteractionMode(SqpApplication::PlotsInteractionMode mode)
             {
                 impl->m_PlotInterractionMode = mode;
             }
             SqpApplication::PlotsCursorMode SqpApplication::plotsCursorMode() const
             {
                 return impl->m_PlotCursorMode;
             }
             void SqpApplication::setPlotsCursorMode(SqpApplication::PlotsCursorMode mode)
             {
                 impl->m_PlotCursorMode = mode;
             }

gui/src/Variable/VariableInspectorWidget.cpp 0 -1

             #include <DataSource/DataSourceController.h>
             #include <Variable/RenameVariableDialog.h>
-            #include <Variable/Variable.h>
             #include <Variable/VariableController2.h>
             #include <Variable/VariableInspectorWidget.h>
             #include <Variable/VariableMenuHeaderWidget.h>
             #include <Variable/VariableModel2.h>
             #include <ui_VariableInspectorWidget.h>
             #include <QMouseEvent>
             #include <QSortFilterProxyModel>
             #include <QStyledItemDelegate>
             #include <QWidgetAction>
             #include <DragAndDrop/DragDropGuiController.h>
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_VariableInspectorWidget, "VariableInspectorWidget")
             class QProgressBarItemDelegate : public QStyledItemDelegate
             {
             public:
                 QProgressBarItemDelegate(QObject* parent) : QStyledItemDelegate { parent } {}
                 void paint(
                     QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const
                 {
                     auto data = index.data(Qt::DisplayRole);
                     auto progressData = index.data(VariableRoles::ProgressRole);
                     if (data.isValid() && progressData.isValid())
                     {
                         auto name = data.value<QString>();
                         auto progress = progressData.value<double>();
                         if (progress > 0)
                         {
                             auto cancelButtonWidth = 20;
                             auto progressBarOption = QStyleOptionProgressBar {};
                             auto progressRect = option.rect;
                             progressRect.setWidth(progressRect.width() - cancelButtonWidth);
                             progressBarOption.rect = progressRect;
                             progressBarOption.minimum = 0;
                             progressBarOption.maximum = 100;
                             progressBarOption.progress = progress;
                             progressBarOption.text
                                 = QString("%1 %2").arg(name).arg(QString::number(progress, 'f', 2) + "%");
                             progressBarOption.textVisible = true;
                             progressBarOption.textAlignment = Qt::AlignCenter;
                             QApplication::style()->drawControl(
                                 QStyle::CE_ProgressBar, &progressBarOption, painter);
                             // Cancel button
                             auto buttonRect = QRect(progressRect.right(), option.rect.top(), cancelButtonWidth,
                                 option.rect.height());
                             auto buttonOption = QStyleOptionButton {};
                             buttonOption.rect = buttonRect;
                             buttonOption.text = "X";
                             QApplication::style()->drawControl(QStyle::CE_PushButton, &buttonOption, painter);
                         }
                         else
                         {
                             QStyledItemDelegate::paint(painter, option, index);
                         }
                     }
                     else
                     {
                         QStyledItemDelegate::paint(painter, option, index);
                     }
                 }
                 bool editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option,
                     const QModelIndex& index)
                 {
                     if (event->type() == QEvent::MouseButtonRelease)
                     {
                         auto data = index.data(Qt::DisplayRole);
                         auto progressData = index.data(VariableRoles::ProgressRole);
                         if (data.isValid() && progressData.isValid())
                         {
                             auto cancelButtonWidth = 20;
                             auto progressRect = option.rect;
                             progressRect.setWidth(progressRect.width() - cancelButtonWidth);
                             // Cancel button
                             auto buttonRect = QRect(progressRect.right(), option.rect.top(), cancelButtonWidth,
                                 option.rect.height());
                             auto e = (QMouseEvent*)event;
                             auto clickX = e->x();
                             auto clickY = e->y();
                             auto x = buttonRect.left(); // the X coordinate
                             auto y = buttonRect.top(); // the Y coordinate
                             auto w = buttonRect.width(); // button width
                             auto h = buttonRect.height(); // button height
                             if (clickX > x && clickX < x + w)
                             {
                                 if (clickY > y && clickY < y + h)
                                 {
                                     // auto& variableModel = sqpApp->variableModel();
                                     // variableModel->abortProgress(index);
                                 }
                                 return true;
                             }
                             else
                             {
                                 return QStyledItemDelegate::editorEvent(event, model, option, index);
                             }
                         }
                         else
                         {
                             return QStyledItemDelegate::editorEvent(event, model, option, index);
                         }
                     }
                     else
                     {
                         return QStyledItemDelegate::editorEvent(event, model, option, index);
                     }
                     return QStyledItemDelegate::editorEvent(event, model, option, index);
                 }
             };
             VariableInspectorWidget::VariableInspectorWidget(QWidget* parent)
                     : QWidget { parent }
                     , ui { new Ui::VariableInspectorWidget }
                     , m_ProgressBarItemDelegate { new QProgressBarItemDelegate { this } }
             {
                 ui->setupUi(this);
                 // Sets model for table
                 //    auto sortFilterModel = new QSortFilterProxyModel{this};
                 //    sortFilterModel->setSourceModel(sqpApp->variableController().variableModel());
                 m_model = new VariableModel2();
                 ui->tableView->setModel(m_model);
                 connect(m_model, &VariableModel2::createVariable, [](const QVariantHash& productData) {
                     sqpApp->dataSourceController().requestVariable(productData);
                 });
                 auto vc = &(sqpApp->variableController());
                 connect(vc, &VariableController2::variableAdded, m_model, &VariableModel2::variableAdded);
                 connect(vc, &VariableController2::variableDeleted, m_model, &VariableModel2::variableDeleted);
                 connect(m_model, &VariableModel2::asyncChangeRange, vc, &VariableController2::asyncChangeRange);
                 // Adds extra signal/slot between view and model, so the view can be updated instantly when
                 // there is a change of data in the model
                 // connect(m_model, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this,
                 //        SLOT(refresh()));
                 // ui->tableView->setSelectionModel(sqpApp->variableController().variableSelectionModel());
                 ui->tableView->setItemDelegateForColumn(0, m_ProgressBarItemDelegate);
                 // Fixes column sizes
                 auto model = ui->tableView->model();
                 const auto count = model->columnCount();
                 for (auto i = 0; i < count; ++i)
                 {
                     ui->tableView->setColumnWidth(
                         i, model->headerData(i, Qt::Horizontal, Qt::SizeHintRole).toSize().width());
                 }
                 // Sets selection options
                 ui->tableView->setSelectionBehavior(QTableView::SelectRows);
                 ui->tableView->setSelectionMode(QTableView::ExtendedSelection);
                 // Connection to show a menu when right clicking on the tree
                 ui->tableView->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->tableView, &QTableView::customContextMenuRequested, this,
                     &VariableInspectorWidget::onTableMenuRequested);
             }
             VariableInspectorWidget::~VariableInspectorWidget()
             {
                 delete ui;
             }
             void VariableInspectorWidget::onTableMenuRequested(const QPoint& pos) noexcept
             {
                 auto selectedRows = ui->tableView->selectionModel()->selectedRows();
                 auto selectedVariables = QVector<std::shared_ptr<Variable2>> {};
                 for (const auto& selectedRow : qAsConst(selectedRows))
                 {
                     if (auto selectedVariable = this->m_model->variables()[selectedRow.row()])
                     {
                         selectedVariables.push_back(selectedVariable);
                     }
                 }
                 QMenu tableMenu {};
                 // Emits a signal so that potential receivers can populate the menu before displaying it
                 emit tableMenuAboutToBeDisplayed(&tableMenu, selectedVariables);
                 // Adds menu-specific actions
                 if (!selectedVariables.isEmpty())
                 {
                     tableMenu.addSeparator();
                     // 'Rename' and 'Duplicate' actions (only if one variable selected)
                     if (selectedVariables.size() == 1)
                     {
                         auto selectedVariable = selectedVariables.front();
                         auto duplicateFun = [varW = std::weak_ptr<Variable2>(selectedVariable)]() {
                             if (auto var = varW.lock())
                             {
                                 sqpApp->variableController().cloneVariable(var);
                             }
                         };
                         tableMenu.addAction(tr("Duplicate"), duplicateFun);
                         auto renameFun = [varW = std::weak_ptr<Variable2>(selectedVariable), this]() {
                             if (auto var = varW.lock())
                             {
                                 // Generates forbidden names (names associated to existing variables)
                                 auto allVariables = sqpApp->variableController().variables();
                                 auto forbiddenNames = QVector<QString>(allVariables.size());
                                 std::transform(allVariables.cbegin(), allVariables.cend(),
                                     forbiddenNames.begin(),
                                     [](const auto& variable) { return variable->name(); });
                                 RenameVariableDialog dialog { var->name(), forbiddenNames, this };
                                 if (dialog.exec() == QDialog::Accepted)
                                 {
                                     var->setName(dialog.name());
                                 }
                             }
                         };
                         tableMenu.addAction(tr("Rename..."), renameFun);
                     }
                     // 'Delete' action
                     auto deleteFun = [&selectedVariables]() {
                         for (const auto& var : selectedVariables)
                             sqpApp->variableController().deleteVariable(var);
                     };
                     tableMenu.addAction(QIcon { ":/icones/delete.png" }, tr("Delete"), deleteFun);
                 }
                 if (!tableMenu.isEmpty())
                 {
                     // Generates menu header (inserted before first action)
                     auto firstAction = tableMenu.actions().first();
                     auto headerAction = new QWidgetAction { &tableMenu };
                     headerAction->setDefaultWidget(
                         new VariableMenuHeaderWidget { selectedVariables, &tableMenu });
                     tableMenu.insertAction(firstAction, headerAction);
                     // Displays menu
                     tableMenu.exec(QCursor::pos());
                 }
             }
             void VariableInspectorWidget::refresh() noexcept
             {
                 ui->tableView->viewport()->update();
             }

gui/src/Visualization/PlottablesRenderingUtils.cpp +1 -5

             #include "Visualization/PlottablesRenderingUtils.h"
             #include <Common/ColorUtils.h>
-            #include <Data/ScalarSeries.h>
-            #include <Data/SpectrogramSeries.h>
-            #include <Data/VectorSeries.h>
             #include <Variable/Variable2.h>
             #include <Visualization/qcustomplot.h>
             Q_LOGGING_CATEGORY(LOG_PlottablesRenderingUtils, "PlottablesRenderingUtils")
             namespace
             {
             /**
              * Delegate used to set plottables properties
              */
             template <typename T, typename Enabled = void>
             struct PlottablesSetter
             {
                 static void setProperties(PlottablesMap&)
                 {
                     // Default implementation does nothing
                     qCCritical(LOG_PlottablesRenderingUtils())
                         << "Can't set plottables properties: unmanaged type of data";
                 }
             };
             /**
              * Specialization of PlottablesSetter for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesSetter<T,
                 typename std::enable_if_t<std::is_base_of<ScalarTimeSerie, T>::value
                     or std::is_base_of<VectorTimeSerie, T>::value>>
             {
                 static void setProperties(PlottablesMap& plottables)
                 {
                     // Finds the plottable with the highest index to determine the number of colors to generate
                     auto end = plottables.cend();
                     auto maxPlottableIndexIt = std::max_element(plottables.cbegin(), end,
                         [](const auto& it1, const auto& it2) { return it1.first < it2.first; });
                     auto componentCount = maxPlottableIndexIt != end ? maxPlottableIndexIt->first + 1 : 0;
                     // Generates colors for each component
                     auto colors = ColorUtils::colors(Qt::blue, Qt::red, componentCount);
                     // For each component of the data series, creates a QCPGraph to add to the plot
                     for (auto i = 0; i < componentCount; ++i)
                     {
                         auto graphIt = plottables.find(i);
                         if (graphIt != end)
                         {
                             graphIt->second->setPen(QPen { colors.at(i) });
                         }
                     }
                 }
             };
             /**
              * Specialization of PlottablesSetter for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct PlottablesSetter<T,
                 typename std::enable_if_t<std::is_base_of<SpectrogramTimeSerie, T>::value>>
             {
                 static void setProperties(PlottablesMap& plottables)
                 {
                     // Checks that for a spectrogram there is only one plottable, that is a colormap
                     if (plottables.size() != 1)
                     {
                         return;
                     }
                     if (auto colormap = dynamic_cast<QCPColorMap*>(plottables.begin()->second))
                     {
                         colormap->setInterpolate(false); // No value interpolation
                         colormap->setTightBoundary(true);
                         // Finds color scale in the colormap's plot to associate with it
                         auto plot = colormap->parentPlot();
                         auto plotElements = plot->plotLayout()->elements(false);
                         for (auto plotElement : plotElements)
                         {
                             if (auto colorScale = dynamic_cast<QCPColorScale*>(plotElement))
                             {
                                 colormap->setColorScale(colorScale);
                             }
                         }
                         colormap->rescaleDataRange();
                     }
                     else
                     {
                         qCCritical(LOG_PlottablesRenderingUtils()) << "Can't get colormap of the spectrogram";
                     }
                 }
             };
             /**
              * Default implementation of IPlottablesHelper, which takes data series to set plottables properties
              * @tparam T the data series' type
              */
             template <typename T>
             struct PlottablesHelper : public IPlottablesHelper
             {
                 void setProperties(PlottablesMap& plottables) override
                 {
                     PlottablesSetter<T>::setProperties(plottables);
                 }
             };
             } // namespace
             std::unique_ptr<IPlottablesHelper> IPlottablesHelperFactory::create(Variable2& variable) noexcept
             {
                 switch (variable.type())
                 {
                     case DataSeriesType::SCALAR:
                         return std::make_unique<PlottablesHelper<ScalarTimeSerie>>();
                     case DataSeriesType::SPECTROGRAM:
                         return std::make_unique<PlottablesHelper<SpectrogramTimeSerie>>();
                     case DataSeriesType::VECTOR:
                         return std::make_unique<PlottablesHelper<VectorTimeSerie>>();
                     default:
                         // Returns default helper
                         break;
                 }
-                return std::make_unique<PlottablesHelper<IDataSeries>>();
+                return std::make_unique<PlottablesHelper<TimeSeries::ITimeSerie>>();
             }

gui/src/Visualization/SqpColorScale.cpp +20 -17

             #include "Visualization/SqpColorScale.h"
-            #include <Data/DataSeriesUtils.h>
             #include <Visualization/QCPColorMapIterator.h>
             Q_LOGGING_CATEGORY(LOG_SqpColorScale, "SqpColorScale")
-            namespace {
+            namespace
+            {
             const auto DEFAULT_GRADIENT_PRESET = QCPColorGradient::gpJet;
-            const auto DEFAULT_RANGE = QCPRange{1.0e3, 1.7e7};
+            const auto DEFAULT_RANGE = QCPRange { 1.0e3, 1.7e7 };
             } // namespace
-            std::pair<double, double> SqpColorScale::computeThresholds(const SqpColorScale &scale)
+            std::pair<double, double> SqpColorScale::computeThresholds(const SqpColorScale& scale)
             {
                 auto qcpScale = scale.m_Scale;
                 auto colorMaps = qcpScale->colorMaps();
-                if (colorMaps.size() != 1) {
+                if (colorMaps.size() != 1)
-                    return {std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()};
+                    return { std::numeric_limits<double>::quiet_NaN(),
+                        std::numeric_limits<double>::quiet_NaN() };
                 }
                 // Computes thresholds
                 auto isLogarithmicScale = qcpScale->dataScaleType() == QCPAxis::stLogarithmic;
                 auto colorMapData = colorMaps.first()->data();
-                QCPColorMapIterator begin{colorMapData, true};
+                QCPColorMapIterator begin { colorMapData, true };
-                QCPColorMapIterator end{colorMapData, false};
+                QCPColorMapIterator end { colorMapData, false };
-                return DataSeriesUtils::thresholds(begin, end, isLogarithmicScale);
+                return {}; // DataSeriesUtils::thresholds(begin, end, isLogarithmicScale);
             }
-            SqpColorScale::SqpColorScale(QCustomPlot &plot)
+            SqpColorScale::SqpColorScale(QCustomPlot& plot)
-                    : m_Scale{new QCPColorScale{&plot}},
+                    : m_Scale { new QCPColorScale { &plot } }
-                      m_AutomaticThreshold{false},
+                    , m_AutomaticThreshold { false }
-                      m_GradientPreset{DEFAULT_GRADIENT_PRESET}
+                    , m_GradientPreset { DEFAULT_GRADIENT_PRESET }
             {
                 m_Scale->setGradient(m_GradientPreset);
                 m_Scale->setDataRange(DEFAULT_RANGE);
             }
             void SqpColorScale::updateDataRange() noexcept
             {
                 // Updates data range only if mode is automatic
-                if (!m_AutomaticThreshold) {
+                if (!m_AutomaticThreshold)
+                {
                     return;
                 }
                 double minThreshold, maxThreshold;
                 std::tie(minThreshold, maxThreshold) = computeThresholds(*this);
-                if (std::isnan(minThreshold) || std::isnan(maxThreshold)) {
+                if (std::isnan(minThreshold) || std::isnan(maxThreshold))
+                {
                     qCCritical(LOG_SqpColorScale())
                         << "Can't update data range of color scale: thresholds computed are invalid";
                     return;
                 }
                 // Updates thresholds
-                m_Scale->setDataRange({minThreshold, maxThreshold});
+                m_Scale->setDataRange({ minThreshold, maxThreshold });
             }

gui/src/Visualization/VisualizationGraphHelper.cpp 0 -1

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
-            #include <Data/DataSeriesUtils.h>
             #include <Data/ScalarTimeSerie.h>
             #include <Data/SpectrogramTimeSerie.h>
             #include <Data/VectorTimeSerie.h>
             #include <Variable/Variable2.h>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
             namespace
             {
             class SqpDataContainer : public QCPGraphDataContainer
             {
             public:
                 void appendGraphData(const QCPGraphData& data) { mData.append(data); }
             };
             /**
              * Struct used to create plottables, depending on the type of the data series from which to create
              * them
              * @tparam T the data series' type
              * @remarks Default implementation can't create plottables
              */
             template <typename T, typename Enabled = void>
             struct PlottablesCreator
             {
                 static PlottablesMap createPlottables(QCustomPlot&) { return {}; }
             };
             PlottablesMap createGraphs(QCustomPlot& plot, int nbGraphs)
             {
                 PlottablesMap result {};
                 // Creates {nbGraphs} QCPGraph to add to the plot
                 for (auto i = 0; i < nbGraphs; ++i)
                 {
                     auto graph = plot.addGraph();
                     result.insert({ i, graph });
                 }
                 plot.replot();
                 return result;
             }
             /**
              * Specialization of PlottablesCreator for scalars
              * @sa ScalarSeries
              */
             template <typename T>
             struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<ScalarTimeSerie, T>::value>>
             {
                 static PlottablesMap createPlottables(QCustomPlot& plot) { return createGraphs(plot, 1); }
             };
             /**
              * Specialization of PlottablesCreator for vectors
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<VectorTimeSerie, T>::value>>
             {
                 static PlottablesMap createPlottables(QCustomPlot& plot) { return createGraphs(plot, 3); }
             };
             /**
              * Specialization of PlottablesCreator for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct PlottablesCreator<T,
                 typename std::enable_if_t<std::is_base_of<SpectrogramTimeSerie, T>::value>>
             {
                 static PlottablesMap createPlottables(QCustomPlot& plot)
                 {
                     PlottablesMap result {};
                     result.insert({ 0, new QCPColorMap { plot.xAxis, plot.yAxis } });
                     plot.replot();
                     return result;
                 }
             };
             /**
              * Struct used to update plottables, depending on the type of the data series from which to update
              * them
              * @tparam T the data series' type
              * @remarks Default implementation can't update plottables
              */
             template <typename T, typename Enabled = void>
             struct PlottablesUpdater
             {
                 static void setPlotYAxisRange(T&, const DateTimeRange&, QCustomPlot&)
                 {
                     qCCritical(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't set plot y-axis range: unmanaged data series type");
                 }
                 static void updatePlottables(T&, PlottablesMap&, const DateTimeRange&, bool)
                 {
                     qCCritical(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't update plottables: unmanaged data series type");
                 }
             };
             /**
              * Specialization of PlottablesUpdater for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesUpdater<T, typename std::enable_if_t<std::is_base_of<ScalarTimeSerie, T>::value>>
             {
                 static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
                 {
                     auto minValue = 0., maxValue = 0.;
                     if (auto serie = dynamic_cast<ScalarTimeSerie*>(&dataSeries))
                     {
                         maxValue = (*std::max_element(std::begin(*serie), std::end(*serie))).v();
                         minValue = (*std::min_element(std::begin(*serie), std::end(*serie))).v();
                     }
                     plot.yAxis->setRange(QCPRange { minValue, maxValue });
                 }
                 static void updatePlottables(
                     T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
                 {
                     // For each plottable to update, resets its data
                     for (const auto& plottable : plottables)
                     {
                         if (auto graph = dynamic_cast<QCPGraph*>(plottable.second))
                         {
                             auto dataContainer = QSharedPointer<SqpDataContainer>::create();
                             if (auto serie = dynamic_cast<ScalarTimeSerie*>(&dataSeries))
                             {
                                 std::for_each(
                                     std::begin(*serie), std::end(*serie), [&dataContainer](const auto& value) {
                                         dataContainer->appendGraphData(QCPGraphData(value.t(), value.v()));
                                     });
                             }
                             graph->setData(dataContainer);
                         }
                     }
                     if (!plottables.empty())
                     {
                         auto plot = plottables.begin()->second->parentPlot();
                         if (rescaleAxes)
                         {
                             plot->rescaleAxes();
                         }
                     }
                 }
             };
             template <typename T>
             struct PlottablesUpdater<T, typename std::enable_if_t<std::is_base_of<VectorTimeSerie, T>::value>>
             {
                 static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
                 {
                     double minValue = 0., maxValue = 0.;
                     if (auto serie = dynamic_cast<VectorTimeSerie*>(&dataSeries))
                     {
                         std::for_each(
                             std::begin(*serie), std::end(*serie), [&minValue, &maxValue](const auto& v) {
                                 minValue = std::min({ minValue, v.v().x, v.v().y, v.v().z });
                                 maxValue = std::max({ maxValue, v.v().x, v.v().y, v.v().z });
                             });
                     }
                     plot.yAxis->setRange(QCPRange { minValue, maxValue });
                 }
                 static void updatePlottables(
                     T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
                 {
                     // For each plottable to update, resets its data
                     for (const auto& plottable : plottables)
                     {
                         if (auto graph = dynamic_cast<QCPGraph*>(plottable.second))
                         {
                             auto dataContainer = QSharedPointer<SqpDataContainer>::create();
                             if (auto serie = dynamic_cast<VectorTimeSerie*>(&dataSeries))
                             {
                                 switch (plottable.first)
                                 {
                                     case 0:
                                         std::for_each(std::begin(*serie), std::end(*serie),
                                             [&dataContainer](const auto& value) {
                                                 dataContainer->appendGraphData(
                                                     QCPGraphData(value.t(), value.v().x));
                                             });
                                         break;
                                     case 1:
                                         std::for_each(std::begin(*serie), std::end(*serie),
                                             [&dataContainer](const auto& value) {
                                                 dataContainer->appendGraphData(
                                                     QCPGraphData(value.t(), value.v().y));
                                             });
                                         break;
                                     case 2:
                                         std::for_each(std::begin(*serie), std::end(*serie),
                                             [&dataContainer](const auto& value) {
                                                 dataContainer->appendGraphData(
                                                     QCPGraphData(value.t(), value.v().z));
                                             });
                                         break;
                                     default:
                                         break;
                                 }
                             }
                             graph->setData(dataContainer);
                         }
                     }
                     if (!plottables.empty())
                     {
                         auto plot = plottables.begin()->second->parentPlot();
                         if (rescaleAxes)
                         {
                             plot->rescaleAxes();
                         }
                     }
                 }
             };
             /**
              * Specialization of PlottablesUpdater for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct PlottablesUpdater<T,
                 typename std::enable_if_t<std::is_base_of<SpectrogramTimeSerie, T>::value>>
             {
                 static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
                 {
                     // TODO
                     //        double min, max;
                     //        std::tie(min, max) = dataSeries.yBounds();
                     //        if (!std::isnan(min) && !std::isnan(max))
                     //        {
                     //            plot.yAxis->setRange(QCPRange { min, max });
                     //        }
                 }
                 static void updatePlottables(
                     T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
                 {
                     // TODO
                     //        if (plottables.empty())
                     //        {
                     //            qCDebug(LOG_VisualizationGraphHelper())
                     //                << QObject::tr("Can't update spectrogram: no colormap has been
                     //                associated");
                     //            return;
                     //        }
                     //        // Gets the colormap to update (normally there is only one colormap)
                     //        Q_ASSERT(plottables.size() == 1);
                     //        auto colormap = dynamic_cast<QCPColorMap*>(plottables.at(0));
                     //        Q_ASSERT(colormap != nullptr);
                     //        dataSeries.lockRead();
                     //        // Processing spectrogram data for display in QCustomPlot
                     //        auto its = dataSeries.xAxisRange(range.m_TStart, range.m_TEnd);
                     //        // Computes logarithmic y-axis resolution for the spectrogram
                     //        auto yData = its.first->y();
                     //        auto yResolution = DataSeriesUtils::resolution(yData.begin(), yData.end(), true);
                     //        // Generates mesh for colormap
                     //        auto mesh = DataSeriesUtils::regularMesh(its.first, its.second,
                     //            DataSeriesUtils::Resolution { dataSeries.xResolution() }, yResolution);
                     //        dataSeries.unlock();
                     //        colormap->data()->setSize(mesh.m_NbX, mesh.m_NbY);
                     //        if (!mesh.isEmpty())
                     //        {
                     //            colormap->data()->setRange(QCPRange { mesh.m_XMin, mesh.xMax() },
                     //                // y-axis range is converted to linear values
                     //                QCPRange { std::pow(10, mesh.m_YMin), std::pow(10, mesh.yMax()) });
                     //            // Sets values
                     //            auto index = 0;
                     //            for (auto it = mesh.m_Data.begin(), end = mesh.m_Data.end(); it != end; ++it,
                     //            ++index)
                     //            {
                     //                auto xIndex = index % mesh.m_NbX;
                     //                auto yIndex = index / mesh.m_NbX;
                     //                colormap->data()->setCell(xIndex, yIndex, *it);
                     //                // Makes the NaN values to be transparent in the colormap
                     //                if (std::isnan(*it))
                     //                {
                     //                    colormap->data()->setAlpha(xIndex, yIndex, 0);
                     //                }
                     //            }
                     //        }
                     //        // Rescales axes
                     //        auto plot = colormap->parentPlot();
                     //        if (rescaleAxes)
                     //        {
                     //            plot->rescaleAxes();
                     //        }
                 }
             };
             /**
              * Helper used to create/update plottables
              */
             struct IPlottablesHelper
             {
                 virtual ~IPlottablesHelper() noexcept = default;
                 virtual PlottablesMap create(QCustomPlot& plot) const = 0;
                 virtual void setYAxisRange(const DateTimeRange& xAxisRange, QCustomPlot& plot) const = 0;
                 virtual void update(
                     PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes = false) const = 0;
             };
             /**
              * Default implementation of IPlottablesHelper, which takes data series to create/update plottables
              * @tparam T the data series' type
              */
             template <typename T>
             struct PlottablesHelper : public IPlottablesHelper
             {
                 explicit PlottablesHelper(std::shared_ptr<T> dataSeries) : m_DataSeries { dataSeries } {}
                 PlottablesMap create(QCustomPlot& plot) const override
                 {
                     return PlottablesCreator<T>::createPlottables(plot);
                 }
                 void update(
                     PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes) const override
                 {
                     if (m_DataSeries)
                     {
                         PlottablesUpdater<T>::updatePlottables(*m_DataSeries, plottables, range, rescaleAxes);
                     }
                     else
                     {
                         qCCritical(LOG_VisualizationGraphHelper()) << "Can't update plottables: inconsistency "
                                                                       "between the type of data series and the "
                                                                       "type supposed";
                     }
                 }
                 void setYAxisRange(const DateTimeRange& xAxisRange, QCustomPlot& plot) const override
                 {
                     if (m_DataSeries)
                     {
                         PlottablesUpdater<T>::setPlotYAxisRange(*m_DataSeries, xAxisRange, plot);
                     }
                     else
                     {
                         qCCritical(LOG_VisualizationGraphHelper()) << "Can't update plottables: inconsistency "
                                                                       "between the type of data series and the "
                                                                       "type supposed";
                     }
                 }
                 std::shared_ptr<T> m_DataSeries;
             };
             /// Creates IPlottablesHelper according to the type of data series a variable holds
             std::unique_ptr<IPlottablesHelper> createHelper(std::shared_ptr<Variable2> variable) noexcept
             {
                 switch (variable->type())
                 {
                     case DataSeriesType::SCALAR:
                         return std::make_unique<PlottablesHelper<ScalarTimeSerie>>(
                             std::dynamic_pointer_cast<ScalarTimeSerie>(variable->data()));
                     case DataSeriesType::SPECTROGRAM:
                         return std::make_unique<PlottablesHelper<SpectrogramTimeSerie>>(
                             std::dynamic_pointer_cast<SpectrogramTimeSerie>(variable->data()));
                     case DataSeriesType::VECTOR:
                         return std::make_unique<PlottablesHelper<VectorTimeSerie>>(
                             std::dynamic_pointer_cast<VectorTimeSerie>(variable->data()));
                     default:
                         // Creates default helper
                         break;
                 }
                 return std::make_unique<PlottablesHelper<TimeSeries::ITimeSerie>>(nullptr);
             }
             } // namespace
             PlottablesMap VisualizationGraphHelper::create(
                 std::shared_ptr<Variable2> variable, QCustomPlot& plot) noexcept
             {
                 if (variable)
                 {
                     auto helper = createHelper(variable);
                     auto plottables = helper->create(plot);
                     return plottables;
                 }
                 else
                 {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                     return PlottablesMap {};
                 }
             }
             void VisualizationGraphHelper::setYAxisRange(
                 std::shared_ptr<Variable2> variable, QCustomPlot& plot) noexcept
             {
                 if (variable)
                 {
                     auto helper = createHelper(variable);
                     helper->setYAxisRange(variable->range(), plot);
                 }
                 else
                 {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't set y-axis range of plot: the variable is null");
                 }
             }
             void VisualizationGraphHelper::updateData(
                 PlottablesMap& plottables, std::shared_ptr<Variable2> variable, const DateTimeRange& dateTime)
             {
                 auto helper = createHelper(variable);
                 helper->update(plottables, dateTime);
             }

gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp 0 -3

             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "Visualization/AxisRenderingUtils.h"
             #include "Visualization/ColorScaleEditor.h"
             #include "Visualization/PlottablesRenderingUtils.h"
             #include "Visualization/SqpColorScale.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/qcustomplot.h"
             #include <Common/DateUtils.h>
-            #include <Data/IDataSeries.h>
-            #include <Variable/Variable.h>
             #include <SqpApplication.h>
             namespace
             {
             /// Name of the axes layer in QCustomPlot
             const auto AXES_LAYER = QStringLiteral("axes");
             /// Icon used to show x-axis properties
             const auto HIDE_AXIS_ICON_PATH = QStringLiteral(":/icones/down.png");
             /// Name of the overlay layer in QCustomPlot
             const auto OVERLAY_LAYER = QStringLiteral("overlay");
             /// Pixmap used to show x-axis properties
             const auto SHOW_AXIS_ICON_PATH = QStringLiteral(":/icones/up.png");
             /// Tooltip format for graphs
             const auto GRAPH_TOOLTIP_FORMAT = QStringLiteral("key: %1\nvalue: %2");
             /// Tooltip format for colormaps
             const auto COLORMAP_TOOLTIP_FORMAT = QStringLiteral("x: %1\ny: %2\nvalue: %3");
             /// Offset used to shift the tooltip of the mouse
             const auto TOOLTIP_OFFSET = QPoint { 20, 20 };
             /// Tooltip display rectangle (the tooltip is hidden when the mouse leaves this rectangle)
             const auto TOOLTIP_RECT = QRect { 10, 10, 10, 10 };
             /// Timeout after which the tooltip is displayed
             const auto TOOLTIP_TIMEOUT = 500;
             void initPointTracerStyle(QCPItemTracer& tracer) noexcept
             {
                 tracer.setInterpolating(false);
                 tracer.setStyle(QCPItemTracer::tsCircle);
                 tracer.setSize(3);
                 tracer.setPen(QPen(Qt::black));
                 tracer.setBrush(Qt::black);
                 tracer.setSelectable(false);
             }
             QPixmap pixmap(const QString& iconPath) noexcept
             {
                 return QIcon { iconPath }.pixmap(QSize { 16, 16 });
             }
             void initClosePixmapStyle(QCPItemPixmap& pixmap) noexcept
             {
                 // Icon
                 pixmap.setPixmap(
                     sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton).pixmap(QSize { 16, 16 }));
                 // Position
                 pixmap.topLeft->setType(QCPItemPosition::ptAxisRectRatio);
                 pixmap.topLeft->setCoords(1, 0);
                 pixmap.setClipToAxisRect(false);
                 // Can be selected
                 pixmap.setSelectable(true);
             }
             void initXAxisPixmapStyle(QCPItemPixmap& itemPixmap) noexcept
             {
                 // Icon
                 itemPixmap.setPixmap(pixmap(HIDE_AXIS_ICON_PATH));
                 // Position
                 itemPixmap.topLeft->setType(QCPItemPosition::ptAxisRectRatio);
                 itemPixmap.topLeft->setCoords(0, 1);
                 itemPixmap.setClipToAxisRect(false);
                 // Can be selected
                 itemPixmap.setSelectable(true);
             }
             void initTitleTextStyle(QCPItemText& text) noexcept
             {
                 // Font and background styles
                 text.setColor(Qt::gray);
                 text.setBrush(Qt::white);
                 // Position
                 text.setPositionAlignment(Qt::AlignTop | Qt::AlignLeft);
                 text.position->setType(QCPItemPosition::ptAxisRectRatio);
                 text.position->setCoords(0.5, 0);
                 text.setSelectable(false);
             }
             /**
              * Returns the cell index (x or y) of a colormap according to the coordinate passed in parameter.
              * This method handles the fact that a colormap axis can be logarithmic or linear.
              * @param colormap the colormap for which to calculate the index
              * @param coord the coord to convert to cell index
              * @param xCoord calculates the x index if true, calculates y index if false
              * @return the cell index
              */
             int colorMapCellIndex(const QCPColorMap& colormap, double coord, bool xCoord)
             {
                 // Determines the axis of the colormap according to xCoord, and whether it is logarithmic or not
                 auto isLogarithmic = (xCoord ? colormap.keyAxis() : colormap.valueAxis())->scaleType()
                     == QCPAxis::stLogarithmic;
                 if (isLogarithmic)
                 {
                     // For a logarithmic axis we can't use the conversion method of colormap, so we calculate
                     // the index manually based on the position of the coordinate on the axis
                     // Gets the axis range and the number of values between range bounds to calculate the step
                     // between each value of the range
                     auto range = xCoord ? colormap.data()->keyRange() : colormap.data()->valueRange();
                     auto nbValues = (xCoord ? colormap.data()->keySize() : colormap.data()->valueSize()) - 1;
                     auto valueStep
                         = (std::log10(range.upper) - std::log10(range.lower)) / static_cast<double>(nbValues);
                     // According to the coord position, calculates the closest index in the range
                     return std::round((std::log10(coord) - std::log10(range.lower)) / valueStep);
                 }
                 else
                 {
                     // For a linear axis, we use the conversion method of colormap
                     int index;
                     if (xCoord)
                     {
                         colormap.data()->coordToCell(coord, 0., &index, nullptr);
                     }
                     else
                     {
                         colormap.data()->coordToCell(0., coord, nullptr, &index);
                     }
                     return index;
                 }
             }
             } // namespace
             struct VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegatePrivate
             {
                 explicit VisualizationGraphRenderingDelegatePrivate(VisualizationGraphWidget& graphWidget)
                         : m_Plot { graphWidget.plot() }
                         , m_PointTracer { new QCPItemTracer { &m_Plot } }
                         , m_TracerTimer {}
                         , m_ClosePixmap { new QCPItemPixmap { &m_Plot } }
                         , m_TitleText { new QCPItemText { &m_Plot } }
                         , m_XAxisPixmap { new QCPItemPixmap { &m_Plot } }
                         , m_ShowXAxis { true }
                         , m_XAxisLabel {}
                         , m_ColorScale { SqpColorScale { m_Plot } }
                 {
                     initPointTracerStyle(*m_PointTracer);
                     m_TracerTimer.setInterval(TOOLTIP_TIMEOUT);
                     m_TracerTimer.setSingleShot(true);
                     // Inits "close button" in plot overlay
                     m_ClosePixmap->setLayer(OVERLAY_LAYER);
                     initClosePixmapStyle(*m_ClosePixmap);
                     // Connects pixmap selection to graph widget closing
                     QObject::connect(
                         &m_Plot, &QCustomPlot::itemClick, [&graphWidget, this](auto item, auto mouseEvent) {
                             if (item == m_ClosePixmap)
                             {
                                 graphWidget.close();
                             }
                         });
                     // Inits graph name in plot overlay
                     m_TitleText->setLayer(OVERLAY_LAYER);
                     m_TitleText->setText(graphWidget.name());
                     initTitleTextStyle(*m_TitleText);
                     // Inits "show x-axis button" in plot overlay
                     m_XAxisPixmap->setLayer(OVERLAY_LAYER);
                     initXAxisPixmapStyle(*m_XAxisPixmap);
                     // Connects pixmap selection to graph x-axis showing/hiding
                     QObject::connect(&m_Plot, &QCustomPlot::itemClick, [this](auto item, auto mouseEvent) {
                         if (m_XAxisPixmap == item)
                         {
                             // Changes the selection state and refreshes the x-axis
                             m_ShowXAxis = !m_ShowXAxis;
                             this->updateXAxisState();
                             m_Plot.layer(AXES_LAYER)->replot();
                             // Deselects the x-axis pixmap and updates icon
                             m_XAxisPixmap->setPixmap(
                                 pixmap(m_ShowXAxis ? HIDE_AXIS_ICON_PATH : SHOW_AXIS_ICON_PATH));
                             m_Plot.layer(OVERLAY_LAYER)->replot();
                         }
                     });
                 }
                 /// Updates state of x-axis according to the current selection of x-axis pixmap
                 /// @remarks the method doesn't call plot refresh
                 void updateXAxisState() noexcept
                 {
                     m_Plot.xAxis->setTickLabels(m_ShowXAxis);
                     m_Plot.xAxis->setLabel(m_ShowXAxis ? m_XAxisLabel : QString {});
                 }
                 QCustomPlot& m_Plot;
                 QCPItemTracer* m_PointTracer;
                 QTimer m_TracerTimer;
                 QCPItemPixmap* m_ClosePixmap; /// Graph's close button
                 QCPItemText* m_TitleText; /// Graph's title
                 QCPItemPixmap* m_XAxisPixmap;
                 bool m_ShowXAxis; /// X-axis properties are shown or hidden
                 QString m_XAxisLabel;
                 SqpColorScale m_ColorScale; /// Color scale used for some types of graphs (as spectrograms)
             };
             VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegate(
                 VisualizationGraphWidget& graphWidget)
                     : impl { spimpl::make_unique_impl<VisualizationGraphRenderingDelegatePrivate>(graphWidget) }
             {
             }
             void VisualizationGraphRenderingDelegate::onMouseDoubleClick(QMouseEvent* event) noexcept
             {
                 // Opens color scale editor if color scale is double clicked
                 auto colorScale = static_cast<QCPColorScale*>(impl->m_Plot.layoutElementAt(event->pos()));
                 if (impl->m_ColorScale.m_Scale == colorScale)
                 {
                     if (ColorScaleEditor { impl->m_ColorScale }.exec() == QDialog::Accepted)
                     {
                         impl->m_Plot.replot();
                     }
                 }
             }
             void VisualizationGraphRenderingDelegate::updateTooltip(QMouseEvent* event) noexcept
             {
                 // Cancels pending refresh
                 impl->m_TracerTimer.disconnect();
                 // Reinits tracers
                 impl->m_PointTracer->setGraph(nullptr);
                 impl->m_PointTracer->setVisible(false);
                 impl->m_Plot.replot();
                 QString tooltip {};
                 // Gets the graph under the mouse position
                 auto eventPos = event->pos();
                 if (auto graph = qobject_cast<QCPGraph*>(impl->m_Plot.plottableAt(eventPos)))
                 {
                     auto mouseKey = graph->keyAxis()->pixelToCoord(eventPos.x());
                     auto graphData = graph->data();
                     // Gets the closest data point to the mouse
                     auto graphDataIt = graphData->findBegin(mouseKey);
                     if (graphDataIt != graphData->constEnd())
                     {
                         // Sets tooltip
                         auto key = formatValue(graphDataIt->key, *graph->keyAxis());
                         auto value = formatValue(graphDataIt->value, *graph->valueAxis());
                         tooltip = GRAPH_TOOLTIP_FORMAT.arg(key, value);
                         // Displays point tracer
                         impl->m_PointTracer->setGraph(graph);
                         impl->m_PointTracer->setGraphKey(graphDataIt->key);
                         impl->m_PointTracer->setLayer(
                             impl->m_Plot.layer("main")); // Tracer is set on top of the plot's main layer
                         impl->m_PointTracer->setVisible(true);
                         impl->m_Plot.replot();
                     }
                 }
                 else if (auto colorMap = qobject_cast<QCPColorMap*>(impl->m_Plot.plottableAt(eventPos)))
                 {
                     // Gets x and y coords
                     auto x = colorMap->keyAxis()->pixelToCoord(eventPos.x());
                     auto y = colorMap->valueAxis()->pixelToCoord(eventPos.y());
                     // Calculates x and y cell indexes, and retrieves the underlying value
                     auto xCellIndex = colorMapCellIndex(*colorMap, x, true);
                     auto yCellIndex = colorMapCellIndex(*colorMap, y, false);
                     auto value = colorMap->data()->cell(xCellIndex, yCellIndex);
                     // Sets tooltips
                     tooltip = COLORMAP_TOOLTIP_FORMAT.arg(formatValue(x, *colorMap->keyAxis()),
                         formatValue(y, *colorMap->valueAxis()),
                         formatValue(value, *colorMap->colorScale()->axis()));
                 }
                 if (!tooltip.isEmpty())
                 {
                     // Starts timer to show tooltip after timeout
                     auto showTooltip = [tooltip, eventPos, this]() {
                         QToolTip::showText(impl->m_Plot.mapToGlobal(eventPos) + TOOLTIP_OFFSET, tooltip,
                             &impl->m_Plot, TOOLTIP_RECT);
                     };
                     QObject::connect(&impl->m_TracerTimer, &QTimer::timeout, showTooltip);
                     impl->m_TracerTimer.start();
                 }
             }
             void VisualizationGraphRenderingDelegate::onPlotUpdated() noexcept
             {
                 // Updates color scale bounds
                 impl->m_ColorScale.updateDataRange();
                 impl->m_Plot.replot();
             }
             void VisualizationGraphRenderingDelegate::setAxesUnits(Variable2& variable) noexcept
             {
                 auto axisHelper = IAxisHelperFactory::create(variable);
                 axisHelper->setUnits(impl->m_Plot, impl->m_ColorScale);
                 // Stores x-axis label to be able to retrieve it when x-axis pixmap is unselected
                 impl->m_XAxisLabel = impl->m_Plot.xAxis->label();
                 // Updates x-axis state
                 impl->updateXAxisState();
                 impl->m_Plot.layer(AXES_LAYER)->replot();
             }
             void VisualizationGraphRenderingDelegate::setGraphProperties(
                 Variable2& variable, PlottablesMap& plottables) noexcept
             {
                 // Axes' properties
                 auto axisHelper = IAxisHelperFactory::create(variable);
                 axisHelper->setProperties(impl->m_Plot, impl->m_ColorScale);
                 // Plottables' properties
                 auto plottablesHelper = IPlottablesHelperFactory::create(variable);
                 plottablesHelper->setProperties(plottables);
             }
             void VisualizationGraphRenderingDelegate::showGraphOverlay(bool show) noexcept
             {
                 auto overlay = impl->m_Plot.layer(OVERLAY_LAYER);
                 overlay->setVisible(show);
                 overlay->replot();
             }

gui/src/Visualization/VisualizationGraphWidget.cpp 0 -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/DateTimeRangeHelper.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/Variable2.h>
             #include <Variable/VariableController2.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<Variable2> 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<Variable2>, 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<Variable2> 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->data() != nullptr)
                 {
                     impl->m_RenderingDelegate->setAxesUnits(*variable);
                 }
                 else
                 {
                     auto context = new QObject { this };
                     connect(
                         variable.get(), &Variable2::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(), &Variable2::updated, this, &VisualizationGraphWidget::variableUpdated);
                 this->onUpdateVarDisplaying(variable, range); // My bullshit
                 emit variableAdded(variable);
             }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable2> 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<Variable2>> VisualizationGraphWidget::variables() const
             {
                 auto variables = std::vector<std::shared_ptr<Variable2>> {};
                 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<Variable2> 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(Variable2& variable) const
             {
                 auto isSpectrogram
                     = [](auto& variable) { return variable.type() == DataSeriesType::SPECTROGRAM; };
                 // - 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(Variable2& 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)
                     {
                         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, posInPlot, event->button(), event->buttons(),
                                     event->modifiers() };
                                 sqpApp->sendEvent(this->impl->m_plot, &e);
                                 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<Variable2> 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<Variable2>& variable)
             {
                 this->removeVariable(variable);
             }

gui/tests/GUITestUtils/GUITestUtils.h 0 -1

             #ifndef GUITESTUTILS_H
             #define GUITESTUTILS_H
             #include <Common/cpp_utils.h>
             #include <QCoreApplication>
             #include <QCursor>
             #include <QDesktopWidget>
             #include <QMouseEvent>
             #include <QPoint>
             #include <QtTest>
             #include <SqpApplication.h>
-            #include <Variable/Variable.h>
             #include <Variable/VariableController2.h>
             #include <qcustomplot.h>
             template <typename T>
             QPoint center(T* widget)
             {
                 return QPoint { widget->width() / 2, widget->height() / 2 };
             }
             HAS_METHOD(viewport)
             template <typename T>
             static inline constexpr bool is_QWidgetOrDerived = std::is_base_of<QWidget, T>::value;
             template <typename T>
             using viewport_type = decltype(std::declval<T>().viewport());
             HAS_METHOD(topLevelItem)
             template <typename T>
             void mouseMove(T* widget, QPoint pos, Qt::MouseButton mouseModifier)
             {
                 QCursor::setPos(widget->mapToGlobal(pos));
                 QMouseEvent event(QEvent::MouseMove, pos, Qt::NoButton, mouseModifier, Qt::NoModifier);
                 if constexpr (has_viewport<T>)
                 {
                     if constexpr (is_QWidgetOrDerived<viewport_type<T>>)
                     {
                         qApp->sendEvent(widget->viewport(), &event);
                     }
                     else
                     {
                         qApp->sendEvent(widget, &event);
                     }
                 }
                 else
                 {
                     qApp->sendEvent(widget, &event);
                 }
                 qApp->processEvents();
             }
             template <typename T>
             void setMouseTracking(T* widget)
             {
                 if constexpr (has_viewport<T>)
                 {
                     if constexpr (is_QWidgetOrDerived<viewport_type<T>>)
                     {
                         widget->viewport()->setMouseTracking(true);
                     }
                     else
                     {
                         widget->setMouseTracking(true);
                     }
                 }
                 else
                 {
                     widget->setMouseTracking(true);
                 }
             }
             template <typename T, typename T2>
             auto getItem(T* widget, T2 itemIndex)
             {
                 if constexpr (has_topLevelItem<T>)
                 {
                     return widget->topLevelItem(itemIndex);
                 }
                 else
                 {
                     return widget->item(itemIndex);
                 }
             }
             #define SELECT_ITEM(widget, itemIndex, item)                                                       \
                 auto item = getItem(widget, itemIndex);                                                        \
                 {                                                                                              \
                     auto itemCenterPos = widget->visualItemRect(item).center();                                \
                     QTest::mouseClick(widget->viewport(), Qt::LeftButton, Qt::NoModifier, itemCenterPos);      \
                     QVERIFY(widget->selectedItems().size() > 0);                                               \
                     QVERIFY(widget->selectedItems().contains(item));                                           \
                 }
             #define GET_CHILD_WIDGET_FOR_GUI_TESTS(parent, child, childType, childName)                        \
                 childType* child = parent.findChild<childType*>(childName);                                    \
                 QVERIFY(child != Q_NULLPTR);                                                                   \
                 setMouseTracking(child);
             template <typename T1, typename T2, typename T3, typename T4 = void>
             void dragnDropItem(T1* sourceWidget, T2* destWidget, T3* item, T4* destItem = Q_NULLPTR)
             {
                 auto itemCenterPos = sourceWidget->visualItemRect(item).center();
                 if constexpr (has_viewport<T1>)
                 {
                     QTest::mousePress(sourceWidget->viewport(), Qt::LeftButton, Qt::NoModifier, itemCenterPos);
                 }
                 else
                 {
                     QTest::mousePress(sourceWidget, Qt::LeftButton, Qt::NoModifier, itemCenterPos);
                 }
                 mouseMove(sourceWidget, itemCenterPos, Qt::LeftButton);
                 itemCenterPos += QPoint(0, -10);
                 QTimer::singleShot(100, [destWidget, destItem]() {
                     mouseMove(destWidget, destWidget->rect().center(), Qt::LeftButton);
                     mouseMove(destWidget, destWidget->rect().center() + QPoint(0, -10), Qt::LeftButton);
                     if constexpr (!std::is_same_v<void, T4>)
                     {
                         auto destItemCenterPos = destWidget->visualItemRect(destItem).center();
                         QTest::mouseRelease(destWidget, Qt::LeftButton, Qt::NoModifier, destItemCenterPos);
                     }
                     else if constexpr (has_viewport<T2>)
                     {
                         QTest::mouseRelease(destWidget->viewport(), Qt::LeftButton);
                     }
                     else
                     {
                         QTest::mouseRelease(destWidget, Qt::LeftButton);
                     }
                     QTest::mouseRelease(destWidget->viewport(), Qt::LeftButton);
                 });
                 mouseMove(sourceWidget, itemCenterPos, Qt::LeftButton);
             }
             template <typename T>
             void scroll_graph(T* w, int dx)
             {
                 auto cent = center(w);
                 QTest::mousePress(w, Qt::LeftButton, Qt::NoModifier, cent, 1);
                 mouseMove(w, { cent.x() + dx, cent.y() }, Qt::LeftButton);
                 QTest::mouseRelease(w, Qt::LeftButton);
             }
             ALIAS_TEMPLATE_FUNCTION(isReady, static_cast<SqpApplication*>(qApp)->variableController().isReady)
             void waitForVar(std::shared_ptr<Variable2> var)
             {
                 while (!isReady(var))
                     QCoreApplication::processEvents();
             }
             template <typename T>
             bool prepare_gui_test(T* w)
             {
                 w->setGeometry(QRect(
                     QPoint(QApplication::desktop()->geometry().center() - QPoint(250, 250)), QSize(500, 500)));
                 w->show();
                 qApp->setActiveWindow(w);
                 return QTest::qWaitForWindowActive(w);
             }
             #define GET_CHILD_WIDGET_FOR_GUI_TESTS(parent, child, childType, childName)                        \
                 childType* child = parent.findChild<childType*>(childName);                                    \
                 QVERIFY(child != Q_NULLPTR);                                                                   \
                 setMouseTracking(child);
             #endif

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