HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1420:3c3e24550401

Switched to new TS impl but quite broken!...

jeandet -

r1420:3c3e24550401

parent child

Context file:

r1420:3c3e24550401

app/CMakeLists.txt +6 0

             add_executable(sciqlopapp WIN32 ${app_SRCS} ${UiGenerated_SRCS})
             if(NOT BUILD_SHARED_LIBS)
                 add_definitions(-DQT_STATICPLUGIN)
+                if(BUILD_PLUGINS)
                     target_link_libraries(sciqlopapp mockplugin)
                     target_link_libraries(sciqlopapp amdaplugin)
                 endif()
+            endif()
+            if(NOT BUILD_PLUGINS)
+                add_definitions(-DSQP_NO_PLUGINS)
+            endif()
             target_link_libraries(sciqlopapp
               Qt5::Core

app/src/Main.cpp +2 0

             int main(int argc, char* argv[])
             {
             #ifdef QT_STATICPLUGIN
+            #ifndef SQP_NO_PLUGINS
                 Q_IMPORT_PLUGIN(MockPlugin)
                 Q_IMPORT_PLUGIN(AmdaPlugin)
                 Q_INIT_RESOURCE(amdaresources);
             #endif
+            #endif
                 Q_INIT_RESOURCE(sqpguiresources);
                 SqpApplication::setOrganizationName("LPP");

core +1 -1

	@@ -1,1 +1,1
	1	Subproject commit 00b9e6e4b7f57c09175c396576ac6e30f45a14ff		1	Subproject commit a8a4e48c21af5a28ad3f56582db7bbec0fe76978

gui/include/Variable/VariableInspectorWidget.h +7 -5

             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableInspectorWidget)
-            class Variable;
+            class Variable2;
             class QProgressBarItemDelegate;
-            namespace Ui {
+            namespace Ui
+            {
             class VariableInspectorWidget;
             } // Ui
              * which it is possible to view the loaded variables, handle them or trigger their display in
              * visualization
              */
-            class VariableInspectorWidget : public QWidget {
+            class VariableInspectorWidget : public QWidget
+            {
                 Q_OBJECT
             public:
                  * @remarks To make the dynamic addition of menus work, the connections to this signal must be
                  * in Qt :: DirectConnection
                  */
-                void tableMenuAboutToBeDisplayed(QMenu *tableMenu,
+                void tableMenuAboutToBeDisplayed(
-                                                 const QVector<std::shared_ptr<Variable> > &variables);
+                    QMenu* tableMenu, const QVector<std::shared_ptr<Variable2>>& variables);
             private:
                 Ui::VariableInspectorWidget* ui;

gui/include/Variable/VariableMenuHeaderWidget.h +7 -5

             #include <memory>
-            namespace Ui {
+            namespace Ui
+            {
             class VariableMenuHeaderWidget;
             } // Ui
-            class Variable;
+            class Variable2;
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableMenuHeaderWidget)
              * variable inspector
              * @sa VariableInspectorWidget
              */
-            class VariableMenuHeaderWidget : public QWidget {
+            class VariableMenuHeaderWidget : public QWidget
+            {
             public:
                 /**
                  * Ctor
                  * @param variables the list of variables used to generate the header
                  * @param parent the parent widget
                  */
-                explicit VariableMenuHeaderWidget(const QVector<std::shared_ptr<Variable> > &variables,
+                explicit VariableMenuHeaderWidget(
-                                                  QWidget *parent = 0);
+                    const QVector<std::shared_ptr<Variable2>>& variables, QWidget* parent = 0);
                 virtual ~VariableMenuHeaderWidget() noexcept;
             private:

gui/include/Visualization/AxisRenderingUtils.h +6 -4

             class QCPAxis;
             class QCustomPlot;
             class SqpColorScale;
-            class Variable;
+            class Variable2;
             /// Formats a data value according to the axis on which it is present
             QString formatValue(double value, const QCPAxis& axis);
             /**
              * Helper used to handle axes rendering
              */
-            struct IAxisHelper {
+            struct IAxisHelper
+            {
                 virtual ~IAxisHelper() noexcept = default;
                 /// Set properties of the plot's axes and the color scale associated to plot passed as
                 virtual void setUnits(QCustomPlot& plot, SqpColorScale& colorScale) = 0;
             };
-            struct IAxisHelperFactory {
+            struct IAxisHelperFactory
+            {
                 /// Creates IPlottablesHelper according to the type of data series a variable holds
-                static std::unique_ptr<IAxisHelper> create(const Variable &variable) noexcept;
+                static std::unique_ptr<IAxisHelper> create(Variable2& variable) noexcept;
             };
             #endif // SCIQLOP_AXISRENDERINGUTILS_H

gui/include/Visualization/IVariableContainer.h +5 -4

             #ifndef SCIQLOP_IVARIABLECONTAINER_H
             #define SCIQLOP_IVARIABLECONTAINER_H
-            class Variable;
+            class Variable2;
             /**
              * @brief The IVariableContainer interface represents an UI object that can accommodate a variable
              */
-            class IVariableContainer {
+            class IVariableContainer
+            {
             public:
                 virtual ~IVariableContainer() = default;
                 /// Checks if the container can handle the variable passed in parameter
-                virtual bool canDrop(const Variable &variable) const = 0;
+                virtual bool canDrop(Variable2& variable) const = 0;
                 /// Checks if the container contains the variable passed in parameter
-                virtual bool contains(const Variable &variable) const = 0;
+                virtual bool contains(Variable2& variable) const = 0;
             };

gui/include/Visualization/PlottablesRenderingUtils.h +6 -4

             class QCPColorScale;
             class QCustomPlot;
-            class Variable;
+            class Variable2;
             /**
              * Helper used to handle plottables rendering
              */
-            struct IPlottablesHelper {
+            struct IPlottablesHelper
+            {
                 virtual ~IPlottablesHelper() noexcept = default;
                 /// Set properties of the plottables passed as parameter
                 virtual void setProperties(PlottablesMap& plottables) = 0;
             };
-            struct IPlottablesHelperFactory {
+            struct IPlottablesHelperFactory
+            {
                 /// Creates IPlottablesHelper according to the type of data series a variable holds
-                static std::unique_ptr<IPlottablesHelper> create(const Variable &variable) noexcept;
+                static std::unique_ptr<IPlottablesHelper> create(Variable2& variable) noexcept;
             };
             #endif // SCIQLOP_PLOTTABLESRENDERINGUTILS_H

gui/include/Visualization/VisualizationGraphHelper.h +6 -5

             class IDataSeries;
             class QCPAbstractPlottable;
             class QCustomPlot;
-            class Variable;
+            class Variable2;
             /**
              * @brief The VisualizationGraphHelper class aims to create the QCustomPlot components relative to a
              * variable, depending on the data series of this variable
              */
-            struct VisualizationGraphHelper {
+            struct VisualizationGraphHelper
+            {
                 /**
                  * Creates (if possible) the QCustomPlot components relative to the variable passed in
                  * parameter, and adds these to the plot passed in parameter.
                  * components.
                  * @return the list of the components created
                  */
-                static PlottablesMap create(std::shared_ptr<Variable> variable, QCustomPlot &plot) noexcept;
+                static PlottablesMap create(std::shared_ptr<Variable2> variable, QCustomPlot& plot) noexcept;
-                static void updateData(PlottablesMap &plottables, std::shared_ptr<Variable> variable,
+                static void updateData(PlottablesMap& plottables, std::shared_ptr<Variable2> variable,
                     const DateTimeRange& dateTime);
-                static void setYAxisRange(std::shared_ptr<Variable> variable, QCustomPlot &plot) noexcept;
+                static void setYAxisRange(std::shared_ptr<Variable2> variable, QCustomPlot& plot) noexcept;
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHHELPER_H

gui/include/Visualization/VisualizationGraphRenderingDelegate.h +5 -4

             class QCustomPlot;
             class QMouseEvent;
             class Unit;
-            class Variable;
+            class Variable2;
             class VisualizationGraphWidget;
-            class VisualizationGraphRenderingDelegate {
+            class VisualizationGraphRenderingDelegate
+            {
             public:
                 /// Ctor
                 /// @param graphWidget the graph widget to which the delegate is associated
                 /// Sets units of the plot's axes according to the properties of the variable passed as
                 /// parameter
-                void setAxesUnits(const Variable &variable) noexcept;
+                void setAxesUnits(Variable2& variable) noexcept;
                 /// Sets graph properties of the plottables passed as parameter, from the variable that
                 /// generated these
-                void setGraphProperties(const Variable &variable, PlottablesMap &plottables) noexcept;
+                void setGraphProperties(Variable2& variable, PlottablesMap& plottables) noexcept;
                 /// Shows or hides graph overlay (name, close button, etc.)

gui/include/Visualization/VisualizationGraphWidget.h +21 -17

             #include "Visualization/VisualizationDragWidget.h"
             #include <QLoggingCategory>
-            #include <QWidget>
             #include <QUuid>
+            #include <QWidget>
             #include <memory>
             class QCPRange;
             class QCustomPlot;
-            class Variable;
+            class Variable2;
             class VisualizationWidget;
             class VisualizationZoneWidget;
             class VisualizationSelectionZoneItem;
-            namespace Ui {
+            namespace Ui
+            {
             class VisualizationGraphWidget;
             } // namespace Ui
             /// Defines options that can be associated with the graph
-            enum GraphFlag {
+            enum GraphFlag
+            {
                 DisableAll = 0x0, ///< Disables acquisition and synchronization
                 EnableAcquisition = 0x1, ///< When this flag is set, the change of the graph's range leads to
                                          /// the acquisition of data
             Q_DECLARE_FLAGS(GraphFlags, GraphFlag)
             Q_DECLARE_OPERATORS_FOR_FLAGS(GraphFlags)
-            class VisualizationGraphWidget : public VisualizationDragWidget, public IVisualizationWidget {
+            class VisualizationGraphWidget : public VisualizationDragWidget, public IVisualizationWidget
+            {
                 Q_OBJECT
                 friend class QCustomPlotSynchronizer;
                 /// Sets graph options
                 void setFlags(GraphFlags flags);
-                void addVariable(std::shared_ptr<Variable> variable, DateTimeRange range);
+                void addVariable(std::shared_ptr<Variable2> variable, DateTimeRange range);
                 /// Removes a variable from the graph
-                void removeVariable(std::shared_ptr<Variable> variable) noexcept;
+                void removeVariable(std::shared_ptr<Variable2> variable) noexcept;
                 /// Returns the list of all variables used in the graph
-                std::vector<std::shared_ptr<Variable> > variables() const;
+                std::vector<std::shared_ptr<Variable2>> variables() const;
                 /// Sets the y-axis range based on the data of a variable
-                void setYRange(std::shared_ptr<Variable> variable);
+                void setYRange(std::shared_ptr<Variable2> variable);
                 DateTimeRange graphRange() const noexcept;
                 void setGraphRange(const DateTimeRange& range, bool updateVar = false, bool forward = false);
                 void setAutoRangeOnVariableInitialization(bool value);
                 /// Adds new selection zones in the graph
                 void addSelectionZones(const QVector<DateTimeRange>& ranges);
                 /// Adds a new selection zone in the graph
-                VisualizationSelectionZoneItem *addSelectionZone(const QString &name, const DateTimeRange &range);
+                VisualizationSelectionZoneItem* addSelectionZone(
+                    const QString& name, const DateTimeRange& range);
                 /// Removes the specified selection zone
                 void removeSelectionZone(VisualizationSelectionZoneItem* selectionZone);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor* visitor) override;
-                bool canDrop(const Variable &variable) const override;
+                bool canDrop(Variable2& variable) const override;
-                bool contains(const Variable &variable) const override;
+                bool contains(Variable2& variable) const override;
                 QString name() const override;
                 // VisualisationDragWidget
             signals:
                 void synchronize(const DateTimeRange& range, const DateTimeRange& oldRange);
-                void changeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange &range);
+                void changeRange(const std::shared_ptr<Variable2>& variable, const DateTimeRange& range);
                 /// Signal emitted when the variable is about to be removed from the graph
-                void variableAboutToBeRemoved(std::shared_ptr<Variable> var);
+                void variableAboutToBeRemoved(std::shared_ptr<Variable2> var);
                 /// Signal emitted when the variable has been added to the graph
-                void variableAdded(std::shared_ptr<Variable> var);
+                void variableAdded(std::shared_ptr<Variable2> var);
                 void zoom_sig(double factor, int center, Qt::Orientation orientation, bool forward = true);
                 void onDataCacheVariableUpdated();
-                void onUpdateVarDisplaying(std::shared_ptr<Variable> variable, const DateTimeRange &range);
+                void onUpdateVarDisplaying(std::shared_ptr<Variable2> variable, const DateTimeRange& range);
                 void variableUpdated(QUuid id);
-                void variableDeleted(const std::shared_ptr<Variable>&);
+                void variableDeleted(const std::shared_ptr<Variable2>&);
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H

gui/include/Visualization/VisualizationTabWidget.h +9 -7

             class Variable;
             class VisualizationZoneWidget;
-            namespace Ui {
+            namespace Ui
+            {
             class VisualizationTabWidget;
             } // namespace Ui
-            class VisualizationTabWidget : public QWidget, public IVisualizationWidget {
+            class VisualizationTabWidget : public QWidget, public IVisualizationWidget
+            {
                 Q_OBJECT
             public:
                  * @param variable the variable for which to create the zone
                  * @return the pointer to the created zone
                  */
-                VisualizationZoneWidget *createZone(std::shared_ptr<Variable> variable);
+                VisualizationZoneWidget* createZone(std::shared_ptr<Variable2> variable);
                 /**
                  * Creates a zone using a list of variables. The variables will be displayed in a new graph of
                  * @param index The index where the zone should be inserted in the layout
                  * @return the pointer to the created zone
                  */
-                VisualizationZoneWidget *createZone(const std::vector<std::shared_ptr<Variable> > &variables,
+                VisualizationZoneWidget* createZone(
-                                                    int index);
+                    const std::vector<std::shared_ptr<Variable2>>& variables, int index);
                 /**
                  * Creates a zone which is empty (no variables). The zone is inserted at the specified index.
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor* visitor) override;
-                bool canDrop(const Variable &variable) const override;
+                bool canDrop(Variable2& variable) const override;
-                bool contains(const Variable &variable) const override;
+                bool contains(Variable2& variable) const override;
                 QString name() const override;
             protected:

gui/include/Visualization/VisualizationWidget.h +11 -9

             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationWidget)
             class QMenu;
-            class Variable;
+            class Variable2;
             class VisualizationTabWidget;
             class VisualizationSelectionZoneManager;
-            namespace Ui {
+            namespace Ui
+            {
             class VisualizationWidget;
             } // namespace Ui
-            class VisualizationWidget : public QWidget, public IVisualizationWidget {
+            class VisualizationWidget : public QWidget, public IVisualizationWidget
+            {
                 Q_OBJECT
             public:
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor* visitor) override;
-                bool canDrop(const Variable &variable) const override;
+                bool canDrop(Variable2& variable) const override;
-                bool contains(const Variable &variable) const override;
+                bool contains(Variable2& variable) const override;
                 QString name() const override;
             public slots:
                  * @param menu the parent menu of the generated menu
                  * @param variables the variables for which to generate the menu
                  */
-                void attachVariableMenu(QMenu *menu,
+                void attachVariableMenu(
-                                        const QVector<std::shared_ptr<Variable> > &variables) noexcept;
+                    QMenu* menu, const QVector<std::shared_ptr<Variable2>>& variables) noexcept;
                 /// Slot called when a variable is about to be deleted from SciQlop
-                void onVariableAboutToBeDeleted(std::shared_ptr<Variable> variable) noexcept;
+                void onVariableAboutToBeDeleted(std::shared_ptr<Variable2> variable) noexcept;
-                void onRangeChanged(std::shared_ptr<Variable> variable, const DateTimeRange &range) noexcept;
+                void onRangeChanged(std::shared_ptr<Variable2> variable, const DateTimeRange& range) noexcept;
             protected:
                 void closeEvent(QCloseEvent* event) override;

gui/include/Visualization/VisualizationZoneWidget.h +13 -11

             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationZoneWidget)
-            namespace Ui {
+            namespace Ui
+            {
             class VisualizationZoneWidget;
             } // namespace Ui
-            class Variable;
+            class Variable2;
             class VisualizationGraphWidget;
-            class VisualizationZoneWidget : public VisualizationDragWidget, public IVisualizationWidget {
+            class VisualizationZoneWidget : public VisualizationDragWidget, public IVisualizationWidget
+            {
                 Q_OBJECT
             public:
                  * @param variable the variable for which to create the graph
                  * @return the pointer to the created graph
                  */
-                VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable);
+                VisualizationGraphWidget* createGraph(std::shared_ptr<Variable2> variable);
                 /**
                  * Creates a graph using a variable. The variable will be displayed in the new graph.
                  * @param index The index where the graph should be inserted in the layout
                  * @return the pointer to the created graph
                  */
-                VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable, int index);
+                VisualizationGraphWidget* createGraph(std::shared_ptr<Variable2> variable, int index);
                 /**
                  * Creates a graph using a list of variables. The variables will be displayed in the new graph.
                  * @param index The index where the graph should be inserted in the layout
                  * @return the pointer to the created graph
                  */
-                VisualizationGraphWidget *createGraph( std::vector<std::shared_ptr<Variable> > variables,
+                VisualizationGraphWidget* createGraph(
-                                                      int index);
+                    std::vector<std::shared_ptr<Variable2>> variables, int index);
                 /// Returns the first graph in the zone or nullptr if there is no graph inside
                 VisualizationGraphWidget* firstGraph() const;
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor* visitor) override;
-                bool canDrop(const Variable &variable) const override;
+                bool canDrop(Variable2& variable) const override;
-                bool contains(const Variable &variable) const override;
+                bool contains(Variable2& variable) const override;
                 QString name() const override;
                 // VisualisationDragWidget
                 spimpl::unique_impl_ptr<VisualizationZoneWidgetPrivate> impl;
             private slots:
-                void onVariableAdded(std::shared_ptr<Variable> variable);
+                void onVariableAdded(std::shared_ptr<Variable2> variable);
                 /// Slot called when a variable is about to be removed from a graph contained in the zone
-                void onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable);
+                void onVariableAboutToBeRemoved(std::shared_ptr<Variable2> variable);
                 void dropMimeData(int index, const QMimeData* mimeData);
                 void dropMimeDataOnGraph(VisualizationDragWidget* dragWidget, const QMimeData* mimeData);

gui/include/Visualization/operations/FindVariableOperation.h +4 -3

             #include <set>
             class IVisualizationWidget;
-            class Variable;
+            class Variable2;
             /**
              * @brief The FindVariableOperation class defines an operation that traverses all of visualization
              * widgets to determine which ones contain the variable passed as parameter. The result of the
              * operation is the list of widgets that contain the variable.
              */
-            class FindVariableOperation : public IVisualizationWidgetVisitor {
+            class FindVariableOperation : public IVisualizationWidgetVisitor
+            {
             public:
                 /**
                  * Ctor
                  * @param variable the variable to find
                  */
-                explicit FindVariableOperation(std::shared_ptr<Variable> variable);
+                explicit FindVariableOperation(std::shared_ptr<Variable2> variable);
                 void visitEnter(VisualizationWidget* widget) override final;
                 void visitLeave(VisualizationWidget* widget) override final;

gui/include/Visualization/operations/GenerateVariableMenuOperation.h +4 -3

             class QMenu;
             class IVisualizationWidget;
-            class Variable;
+            class Variable2;
             Q_DECLARE_LOGGING_CATEGORY(LOG_GenerateVariableMenuOperation)
              * visualization widgets to determine which can accommodate a variable. The result of the operation
              * is a menu that contains actions to add the variable into the containers.
              */
-            class GenerateVariableMenuOperation : public IVisualizationWidgetVisitor {
+            class GenerateVariableMenuOperation : public IVisualizationWidgetVisitor
+            {
             public:
                 /**
                  * Ctor
                  * @param variableContainers the containers that already contain the variable for which to
                  * generate the menu
                  */
-                explicit GenerateVariableMenuOperation(QMenu *menu, std::shared_ptr<Variable> variable,
+                explicit GenerateVariableMenuOperation(QMenu* menu, std::shared_ptr<Variable2> variable,
                     std::set<IVisualizationWidget*> variableContainers);
                 void visitEnter(VisualizationWidget* widget) override final;

gui/include/Visualization/operations/RemoveVariableOperation.h +4 -3

             #include <memory>
-            class Variable;
+            class Variable2;
             Q_DECLARE_LOGGING_CATEGORY(LOG_RemoveVariableOperation)
              * @brief The RemoveVariableOperation class defines an operation that traverses all of visualization
              * widgets to remove a variable if they contain it
              */
-            class RemoveVariableOperation : public IVisualizationWidgetVisitor {
+            class RemoveVariableOperation : public IVisualizationWidgetVisitor
+            {
             public:
                 /**
                  * Ctor
                  * @param variable the variable to remove from widgets
                  */
-                explicit RemoveVariableOperation(std::shared_ptr<Variable> variable);
+                explicit RemoveVariableOperation(std::shared_ptr<Variable2> variable);
                 void visitEnter(VisualizationWidget* widget) override final;
                 void visitLeave(VisualizationWidget* widget) override final;

gui/include/Visualization/operations/RescaleAxeOperation.h +4 -3

             #include <memory>
-            class Variable;
+            class Variable2;
             Q_DECLARE_LOGGING_CATEGORY(LOG_RescaleAxeOperation)
              * @brief The RescaleAxeOperation class defines an operation that traverses all of visualization
              * widgets to remove a variable if they contain it
              */
-            class RescaleAxeOperation : public IVisualizationWidgetVisitor {
+            class RescaleAxeOperation : public IVisualizationWidgetVisitor
+            {
             public:
                 /**
                  * Ctor
                  * @param variable the variable to remove from widgets
                  */
-                explicit RescaleAxeOperation(std::shared_ptr<Variable> variable, const DateTimeRange &range);
+                explicit RescaleAxeOperation(std::shared_ptr<Variable2> variable, const DateTimeRange& range);
                 void visitEnter(VisualizationWidget* widget) override final;
                 void visitLeave(VisualizationWidget* widget) override final;

gui/src/DragAndDrop/DragDropGuiController.cpp +59 -35

             Q_LOGGING_CATEGORY(LOG_DragDropGuiController, "DragDropGuiController")
-            struct DragDropGuiController::DragDropGuiControllerPrivate {
+            struct DragDropGuiController::DragDropGuiControllerPrivate
+            {
                 VisualizationDragWidget* m_CurrentDragWidget = nullptr;
                 std::unique_ptr<QWidget> m_PlaceHolder = nullptr;
                 QList<QWidget*> m_WidgetToClose;
                 explicit DragDropGuiControllerPrivate()
-                        : m_PlaceHolder{std::make_unique<QWidget>()},
+                        : m_PlaceHolder { std::make_unique<QWidget>() }
-                          m_DragDropScroller{std::make_unique<DragDropScroller>()},
+                        , m_DragDropScroller { std::make_unique<DragDropScroller>() }
-                          m_DragDropTabSwitcher{std::make_unique<DragDropTabSwitcher>()}
+                        , m_DragDropTabSwitcher { std::make_unique<DragDropTabSwitcher>() }
                 {
                     auto layout = new QVBoxLayout { m_PlaceHolder.get() };
                     m_ImageTempUrl = QDir::temp().absoluteFilePath("Sciqlop_graph.png");
                 }
-                void preparePlaceHolder(DragDropGuiController::PlaceHolderType type,
+                void preparePlaceHolder(
-                                        const QString &topLabelText) const
+                    DragDropGuiController::PlaceHolderType type, const QString& topLabelText) const
+                {
+                    if (m_CurrentDragWidget)
                     {
-                    if (m_CurrentDragWidget) {
                         m_PlaceHolder->setMinimumSize(m_CurrentDragWidget->size());
                         m_PlaceHolder->setSizePolicy(m_CurrentDragWidget->sizePolicy());
                     }
-                    else {
+                    else
+                    {
                         // Configuration of the placeHolder when there is no dragWidget
                         // (for instance with a drag from a variable)
                         m_PlaceHolder->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                     }
-                    switch (type) {
+                    switch (type)
+                    {
                         case DragDropGuiController::PlaceHolderType::Graph:
                             m_PlaceBackground->setStyleSheet(
                                 "background-color: #BBD5EE; border: 1px solid #2A7FD4");
             void DragDropGuiController::setCurrentDragWidget(VisualizationDragWidget* dragWidget)
             {
-                if (impl->m_CurrentDragWidget) {
+                if (impl->m_CurrentDragWidget)
+                {
                     QObject::disconnect(impl->m_DragWidgetDestroyedConnection);
                 }
-                if (dragWidget) {
+                if (dragWidget)
+                {
                     // ensures the impl->m_CurrentDragWidget is reset when the widget is destroyed
-                    impl->m_DragWidgetDestroyedConnection
+                    impl->m_DragWidgetDestroyedConnection = QObject::connect(dragWidget,
-                        = QObject::connect(dragWidget, &VisualizationDragWidget::destroyed,
+                        &VisualizationDragWidget::destroyed, [this]() { impl->m_CurrentDragWidget = nullptr; });
-                                           [this]() { impl->m_CurrentDragWidget = nullptr; });
                 }
                 impl->m_CurrentDragWidget = dragWidget;
                 return *impl->m_PlaceHolder;
             }
-            void DragDropGuiController::insertPlaceHolder(QVBoxLayout *layout, int index, PlaceHolderType type,
+            void DragDropGuiController::insertPlaceHolder(
-                                                          const QString &topLabelText)
+                QVBoxLayout* layout, int index, PlaceHolderType type, const QString& topLabelText)
             {
                 removePlaceHolder();
                 impl->preparePlaceHolder(type, topLabelText);
             void DragDropGuiController::removePlaceHolder()
             {
                 auto parentWidget = impl->m_PlaceHolder->parentWidget();
-                if (parentWidget) {
+                if (parentWidget)
+                {
                     parentWidget->layout()->removeWidget(impl->m_PlaceHolder.get());
                     impl->m_PlaceHolder->setParent(nullptr);
                     impl->m_PlaceHolder->hide();
             void DragDropGuiController::setHightlightedDragWidget(VisualizationDragWidget* dragWidget)
             {
-                if (impl->m_HighlightedDragWidget) {
+                if (impl->m_HighlightedDragWidget)
+                {
                     impl->m_HighlightedDragWidget->highlightForMerge(false);
                     QObject::disconnect(impl->m_HighlightedWidgetDestroyedConnection);
                 }
-                if (dragWidget) {
+                if (dragWidget)
+                {
                     dragWidget->highlightForMerge(true);
                     // ensures the impl->m_HighlightedDragWidget is reset when the widget is destroyed
             void DragDropGuiController::doCloseWidgets()
             {
-                for (auto widget : impl->m_WidgetToClose) {
+                for (auto widget : impl->m_WidgetToClose)
+                {
                     widget->close();
                 }
             bool DragDropGuiController::checkMimeDataForVisualization(
                 const QMimeData* mimeData, VisualizationDragDropContainer* dropContainer)
             {
-                if (!mimeData || !dropContainer) {
+                if (!mimeData || !dropContainer)
+                {
                     qCWarning(LOG_DragDropGuiController()) << QObject::tr(
                         "DragDropGuiController::checkMimeDataForVisualization, invalid input parameters.");
                     Q_ASSERT(false);
                 auto result = false;
-                if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
+                if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST))
+                {
                     auto variables = sqpApp->variableController().variables(
                         Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
-                    if (variables.size() == 1) {
+                    if (variables.size() == 1)
+                    {
                         auto variable = variables[0];
-                        if (variable->dataSeries() != nullptr) {
+                        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) {
+                            while (parent && qobject_cast<VisualizationWidget*>(parent) == nullptr)
+                            {
                                 parent = parent->parentWidget(); // Search for the top level VisualizationWidget
                             }
-                            if (parent) {
+                            if (parent)
+                            {
                                 auto visualizationWidget = static_cast<VisualizationWidget*>(parent);
                                 FindVariableOperation findVariableOperation { variable };
                                 visualizationWidget->accept(&findVariableOperation);
                                 auto variableContainers = findVariableOperation.result();
-                                if (variableContainers.empty()) {
+                                if (variableContainers.empty())
+                                {
                                     result = true;
                                 }
-                                else {
+                                else
+                                {
                                     // result = false: the variable already exist in the visualisation
                                 }
                             }
-                            else {
+                            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 {
+                        else
+                        {
                             // result = false: the variable is not fully loaded
                         }
                     }
-                    else {
+                    else
+                    {
                         // result = false: cannot drop multiple variables in the visualisation
                     }
                 }
-                else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
+                else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST))
+                {
                     auto productDataList = sqpApp->dataSourceController().productsDataForMimeData(
                         mimeData->data(MIME_TYPE_PRODUCT_LIST));
-                    if (productDataList.count() == 1) {
+                    if (productDataList.count() == 1)
+                    {
                         result = true;
                     }
-                    else {
+                    else
+                    {
                         // result = false: cannot drop multiple products in the visualisation
                     }
                 }
-                else {
+                else
+                {
                     // Other MIME data
                     // no special rules, accepted by default
                     result = true;

gui/src/Variable/VariableInspectorWidget.cpp +54 -36

+            #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 <DataSource/DataSourceController.h>
             #include <ui_VariableInspectorWidget.h>
             Q_LOGGING_CATEGORY(LOG_VariableInspectorWidget, "VariableInspectorWidget")
-            class QProgressBarItemDelegate : public QStyledItemDelegate {
+            class QProgressBarItemDelegate : public QStyledItemDelegate
+            {
             public:
                 QProgressBarItemDelegate(QObject* parent) : QStyledItemDelegate { parent } {}
-                void paint(QPainter *painter, const QStyleOptionViewItem &option,
+                void paint(
-                           const QModelIndex &index) const
+                    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()) {
+                    if (data.isValid() && progressData.isValid())
+                    {
                         auto name = data.value<QString>();
                         auto progress = progressData.value<double>();
-                        if (progress > 0) {
+                        if (progress > 0)
+                        {
                             auto cancelButtonWidth = 20;
                             auto progressBarOption = QStyleOptionProgressBar {};
                             auto progressRect = option.rect;
                             progressBarOption.textAlignment = Qt::AlignCenter;
-                            QApplication::style()->drawControl(QStyle::CE_ProgressBar, &progressBarOption,
+                            QApplication::style()->drawControl(
-                                                               painter);
+                                QStyle::CE_ProgressBar, &progressBarOption, painter);
                             // Cancel button
                             auto buttonRect = QRect(progressRect.right(), option.rect.top(), cancelButtonWidth,
                             QApplication::style()->drawControl(QStyle::CE_PushButton, &buttonOption, painter);
                         }
-                        else {
+                        else
+                        {
                             QStyledItemDelegate::paint(painter, option, index);
                         }
                     }
-                    else {
+                    else
+                    {
                         QStyledItemDelegate::paint(painter, option, index);
                     }
                 }
                 bool editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option,
                     const QModelIndex& index)
                 {
-                    if (event->type() == QEvent::MouseButtonRelease) {
+                    if (event->type() == QEvent::MouseButtonRelease)
+                    {
                         auto data = index.data(Qt::DisplayRole);
                         auto progressData = index.data(VariableRoles::ProgressRole);
-                        if (data.isValid() && progressData.isValid()) {
+                        if (data.isValid() && progressData.isValid())
+                        {
                             auto cancelButtonWidth = 20;
                             auto progressRect = option.rect;
                             progressRect.setWidth(progressRect.width() - cancelButtonWidth);
                             auto w = buttonRect.width(); // button width
                             auto h = buttonRect.height(); // button height
-                            if (clickX > x && clickX < x + w) {
+                            if (clickX > x && clickX < x + w)
-                                if (clickY > y && clickY < y + h) {
+                                if (clickY > y && clickY < y + h)
+                                {
                                     // auto& variableModel = sqpApp->variableModel();
                                     // variableModel->abortProgress(index);
                                 }
                                 return true;
                             }
-                            else {
+                            else
+                            {
                                 return QStyledItemDelegate::editorEvent(event, model, option, index);
                             }
                         }
-                        else {
+                        else
+                        {
                             return QStyledItemDelegate::editorEvent(event, model, option, index);
                         }
                     }
-                    else {
+                    else
+                    {
                         return QStyledItemDelegate::editorEvent(event, model, option, index);
                     }
             };
             VariableInspectorWidget::VariableInspectorWidget(QWidget* parent)
-                    : QWidget{parent},
+                    : QWidget { parent }
-                      ui{new Ui::VariableInspectorWidget},
+                    , ui { new Ui::VariableInspectorWidget }
-                      m_ProgressBarItemDelegate{new QProgressBarItemDelegate{this}}
+                    , m_ProgressBarItemDelegate { new QProgressBarItemDelegate { this } }
             {
                 ui->setupUi(this);
                 m_model = new VariableModel2();
                 ui->tableView->setModel(m_model);
-                connect(m_model, &VariableModel2::createVariable,
+                connect(m_model, &VariableModel2::createVariable, [](const QVariantHash& productData) {
-                        [](const QVariantHash &productData)
                     sqpApp->dataSourceController().requestVariable(productData);
                 });
                 auto vc = &(sqpApp->variableController());
                 // Fixes column sizes
                 auto model = ui->tableView->model();
                 const auto count = model->columnCount();
-                for (auto i = 0; i < count; ++i) {
+                for (auto i = 0; i < count; ++i)
+                {
                     ui->tableView->setColumnWidth(
                         i, model->headerData(i, Qt::Horizontal, Qt::SizeHintRole).toSize().width());
                 }
             void VariableInspectorWidget::onTableMenuRequested(const QPoint& pos) noexcept
             {
                 auto selectedRows = ui->tableView->selectionModel()->selectedRows();
-                auto selectedVariables = QVector<std::shared_ptr<Variable> >{};
+                auto selectedVariables = QVector<std::shared_ptr<Variable2>> {};
-                for (const auto &selectedRow : qAsConst(selectedRows)) {
+                for (const auto& selectedRow : qAsConst(selectedRows))
-                    if (auto selectedVariable = this->m_model->variables()[selectedRow.row()]) {
+                    if (auto selectedVariable = this->m_model->variables()[selectedRow.row()])
+                    {
                         selectedVariables.push_back(selectedVariable);
                     }
                 }
                 emit tableMenuAboutToBeDisplayed(&tableMenu, selectedVariables);
                 // Adds menu-specific actions
-                if (!selectedVariables.isEmpty()) {
+                if (!selectedVariables.isEmpty())
+                {
                     tableMenu.addSeparator();
                     // 'Rename' and 'Duplicate' actions (only if one variable selected)
-                    if (selectedVariables.size() == 1) {
+                    if (selectedVariables.size() == 1)
+                    {
                         auto selectedVariable = selectedVariables.front();
-                        auto duplicateFun = [varW = std::weak_ptr<Variable>(selectedVariable)]()
+                        auto duplicateFun = [varW = std::weak_ptr<Variable2>(selectedVariable)]() {
+                            if (auto var = varW.lock())
                             {
-                            if (auto var = varW.lock()) {
                                 sqpApp->variableController().cloneVariable(var);
                             }
                         };
                         tableMenu.addAction(tr("Duplicate"), duplicateFun);
-                        auto renameFun = [ varW = std::weak_ptr<Variable>(selectedVariable), this ]()
+                        auto renameFun = [varW = std::weak_ptr<Variable2>(selectedVariable), this]() {
+                            if (auto var = varW.lock())
                             {
-                            if (auto var = varW.lock()) {
                                 // Generates forbidden names (names associated to existing variables)
                                 auto allVariables = sqpApp->variableController().variables();
                                 auto forbiddenNames = QVector<QString>(allVariables.size());
                                     [](const auto& variable) { return variable->name(); });
                                 RenameVariableDialog dialog { var->name(), forbiddenNames, this };
-                                if (dialog.exec() == QDialog::Accepted) {
+                                if (dialog.exec() == QDialog::Accepted)
+                                {
                                     var->setName(dialog.name());
                                 }
                             }
                     tableMenu.addAction(QIcon { ":/icones/delete.png" }, tr("Delete"), deleteFun);
                 }
-                if (!tableMenu.isEmpty()) {
+                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});
+                    headerAction->setDefaultWidget(
+                        new VariableMenuHeaderWidget { selectedVariables, &tableMenu });
                     tableMenu.insertAction(firstAction, headerAction);
                     // Displays menu

gui/src/Variable/VariableMenuHeaderWidget.cpp +12 -7

             #include "Variable/VariableMenuHeaderWidget.h"
-            #include "Variable/Variable.h"
+            #include "Variable/Variable2.h"
             #include <ui_VariableMenuHeaderWidget.h>
             Q_LOGGING_CATEGORY(LOG_VariableMenuHeaderWidget, "VariableMenuHeaderWidget")
             VariableMenuHeaderWidget::VariableMenuHeaderWidget(
-                const QVector<std::shared_ptr<Variable> > &variables, QWidget *parent)
+                const QVector<std::shared_ptr<Variable2>>& variables, QWidget* parent)
                     : QWidget { parent }, ui { new Ui::VariableMenuHeaderWidget }
             {
                 ui->setupUi(this);
                 // - the variable name if there is only one variable in the list
                 // - 'x variables' where x is the number of variables otherwise
                 const auto nbVariables = variables.size();
-                if (nbVariables == 1) {
+                if (nbVariables == 1)
-                    if (auto variable = variables.first()) {
+                    if (auto variable = variables.first())
+                    {
                         ui->label->setText(variable->name());
                     }
-                    else {
+                    else
+                    {
                         qCCritical(LOG_VariableMenuHeaderWidget())
                             << tr("Can't get the name of the variable : variable is null");
                     }
                 }
-                else if (nbVariables > 1) {
+                else if (nbVariables > 1)
+                {
                     ui->label->setText(tr("%1 variables").arg(nbVariables));
                 }
-                else {
+                else
+                {
                     ui->label->setText(tr("No variable"));
                 }
             }

gui/src/Visualization/AxisRenderingUtils.cpp +57 -53

             #include "Visualization/AxisRenderingUtils.h"
-            #include <Data/ScalarSeries.h>
+            #include <Data/ScalarTimeSerie.h>
-            #include <Data/SpectrogramSeries.h>
+            #include <Data/SpectrogramTimeSerie.h>
-            #include <Data/VectorSeries.h>
+            #include <Data/VectorTimeSerie.h>
-            #include <Variable/Variable.h>
+            #include <Variable/Variable2.h>
             #include <Visualization/SqpColorScale.h>
             #include <Visualization/qcustomplot.h>
             Q_LOGGING_CATEGORY(LOG_AxisRenderingUtils, "AxisRenderingUtils")
-            namespace {
+            namespace
+            {
             /// Format for datetimes on a axis
             const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
             /// non-time data
             QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis, QCPAxis::ScaleType scaleType)
             {
-                if (isTimeAxis) {
+                if (isTimeAxis)
+                {
                     auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
                     dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
                     dateTicker->setDateTimeSpec(Qt::UTC);
                     return dateTicker;
                 }
-                else if (scaleType == QCPAxis::stLogarithmic) {
+                else if (scaleType == QCPAxis::stLogarithmic)
+                {
                     return QSharedPointer<QCPAxisTickerLog>::create();
                 }
-                else {
+                else
+                {
                     // default ticker
                     return QSharedPointer<QCPAxisTicker>::create();
                 }
              * @param unit the unit to set for the axis
              * @param scaleType the scale type to set for the axis
              */
-            void setAxisProperties(QCPAxis &axis, const Unit &unit,
+            void setAxisProperties(QCPAxis& axis, const std::string& unit, bool isTime,
                 QCPAxis::ScaleType scaleType = QCPAxis::stLinear)
             {
                 // label (unit name)
-                axis.setLabel(unit.m_Name);
+                axis.setLabel(QString::fromStdString(unit));
                 // scale type
                 axis.setScaleType(scaleType);
-                if (scaleType == QCPAxis::stLogarithmic) {
+                if (scaleType == QCPAxis::stLogarithmic)
+                {
                     // Scientific notation
                     axis.setNumberPrecision(0);
                     axis.setNumberFormat("eb");
                 }
                 // ticker (depending on the type of unit)
-                axis.setTicker(axisTicker(unit.m_TimeUnit, scaleType));
+                axis.setTicker(axisTicker(isTime, scaleType));
             }
             /**
              * Delegate used to set axes properties
              */
             template <typename T, typename Enabled = void>
-            struct AxisSetter {
+            struct AxisSetter
+            {
                 static void setProperties(QCustomPlot&, SqpColorScale&)
                 {
                     // Default implementation does nothing
              * @sa VectorSeries
              */
             template <typename T>
-            struct AxisSetter<T, typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
+            struct AxisSetter<T,
-                                                           or std::is_base_of<VectorSeries, T>::value> > {
+                typename std::enable_if_t<std::is_base_of<ScalarTimeSerie, T>::value
+                    or std::is_base_of<VectorTimeSerie, T>::value>>
+            {
                 static void setProperties(QCustomPlot&, SqpColorScale&)
                 {
                     // Nothing to do
                 static void setUnits(T& dataSeries, QCustomPlot& plot, SqpColorScale&)
                 {
-                    dataSeries.lockRead();
+                    auto serie = dynamic_cast<TimeSeries::ITimeSerie*>(&dataSeries);
-                    auto xAxisUnit = dataSeries.xAxisUnit();
+                    setAxisProperties(*plot.xAxis, "s", true);
-                    auto valuesUnit = dataSeries.valuesUnit();
+                    setAxisProperties(*plot.yAxis, serie->unit(1), false);
-                    dataSeries.unlock();
-            //        setAxisProperties(*plot.xAxis, xAxisUnit);
-                    // This is cheating but it's ok ;)
-                    setAxisProperties(*plot.xAxis, Unit{"s", true});
-                    setAxisProperties(*plot.yAxis, valuesUnit);
                 }
             };
              * @sa SpectrogramSeries
              */
             template <typename T>
-            struct AxisSetter<T, typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
+            struct AxisSetter<T, typename std::enable_if_t<std::is_base_of<SpectrogramTimeSerie, T>::value>>
+            {
                 static void setProperties(QCustomPlot& plot, SqpColorScale& colorScale)
                 {
                     // Displays color scale in plot
                     // Aligns color scale with axes
                     auto marginGroups = plot.axisRect()->marginGroups();
-                    for (auto it = marginGroups.begin(), end = marginGroups.end(); it != end; ++it) {
+                    for (auto it = marginGroups.begin(), end = marginGroups.end(); it != end; ++it)
+                    {
                         colorScale.m_Scale->setMarginGroup(it.key(), it.value());
                     }
                 static void setUnits(T& dataSeries, QCustomPlot& plot, SqpColorScale& colorScale)
                 {
-                    dataSeries.lockRead();
+                    auto serie = dynamic_cast<TimeSeries::ITimeSerie*>(&dataSeries);
-                    auto xAxisUnit = dataSeries.xAxisUnit();
+                    setAxisProperties(*plot.xAxis, "s", true);
-                    auto yAxisUnit = dataSeries.yAxisUnit();
+                    setAxisProperties(*plot.yAxis, serie->unit(1), false, QCPAxis::stLogarithmic);
-                    auto valuesUnit = dataSeries.valuesUnit();
+                    setAxisProperties(
-                    dataSeries.unlock();
+                        *colorScale.m_Scale->axis(), serie->unit(2), false, QCPAxis::stLogarithmic);
-                    //setAxisProperties(*plot.xAxis, xAxisUnit);
-                    // This is cheating but it's ok ;)
-                    setAxisProperties(*plot.xAxis, Unit{"s", true});
-                    setAxisProperties(*plot.yAxis, yAxisUnit, QCPAxis::stLogarithmic);
-                    setAxisProperties(*colorScale.m_Scale->axis(), valuesUnit, QCPAxis::stLogarithmic);
                 }
             };
              * @tparam T the data series' type
              */
             template <typename T>
-            struct AxisHelper : public IAxisHelper {
+            struct AxisHelper : public IAxisHelper
-                explicit AxisHelper(std::shared_ptr<T> dataSeries) : m_DataSeries{dataSeries} {}
+                explicit AxisHelper(T* dataSeries) : m_DataSeries { dataSeries } {}
                 void setProperties(QCustomPlot& plot, SqpColorScale& colorScale) override
                 {
                 void setUnits(QCustomPlot& plot, SqpColorScale& colorScale) override
                 {
-                    if (m_DataSeries) {
+                    if (m_DataSeries)
+                    {
                         AxisSetter<T>::setUnits(*m_DataSeries, plot, colorScale);
                     }
-                    else {
+                    else
+                    {
                         qCCritical(LOG_AxisRenderingUtils()) << "Can't set units: inconsistency between the "
                                                                 "type of data series and the type supposed";
                     }
                 }
-                std::shared_ptr<T> m_DataSeries;
+                T* m_DataSeries;
             };
             } // namespace
             QString formatValue(double value, const QCPAxis& axis)
             {
                 // If the axis is a time axis, formats the value as a date
-                if (auto axisTicker = qSharedPointerDynamicCast<QCPAxisTickerDateTime>(axis.ticker())) {
+                if (auto axisTicker = qSharedPointerDynamicCast<QCPAxisTickerDateTime>(axis.ticker()))
+                {
                     return DateUtils::dateTime(value, axisTicker->dateTimeSpec()).toString(DATETIME_FORMAT);
                 }
-                else {
+                else
+                {
                     return QString::number(value, NUMBER_FORMAT, NUMBER_PRECISION);
                 }
             }
-            std::unique_ptr<IAxisHelper> IAxisHelperFactory::create(const Variable &variable) noexcept
+            std::unique_ptr<IAxisHelper> IAxisHelperFactory::create(Variable2& variable) noexcept
+            {
+                switch (variable.type())
                 {
-                switch (variable.type()) {
                     case DataSeriesType::SCALAR:
-                        return std::make_unique<AxisHelper<ScalarSeries> >(
+                        return std::make_unique<AxisHelper<ScalarTimeSerie>>(
-                            std::dynamic_pointer_cast<ScalarSeries>(variable.dataSeries()));
+                            dynamic_cast<ScalarTimeSerie*>(variable.data()->base()));
                     case DataSeriesType::SPECTROGRAM:
-                        return std::make_unique<AxisHelper<SpectrogramSeries> >(
+                        return std::make_unique<AxisHelper<SpectrogramTimeSerie>>(
-                            std::dynamic_pointer_cast<SpectrogramSeries>(variable.dataSeries()));
+                            dynamic_cast<SpectrogramTimeSerie*>(variable.data()->base()));
                     case DataSeriesType::VECTOR:
-                        return std::make_unique<AxisHelper<VectorSeries> >(
+                        return std::make_unique<AxisHelper<VectorTimeSerie>>(
-                            std::dynamic_pointer_cast<VectorSeries>(variable.dataSeries()));
+                            dynamic_cast<VectorTimeSerie*>(variable.data()->base()));
                     default:
                         // Creates default helper
                         break;
                 }
-                return std::make_unique<AxisHelper<IDataSeries> >(nullptr);
+                return std::make_unique<AxisHelper<TimeSeries::ITimeSerie>>(nullptr);
             }

gui/src/Visualization/PlottablesRenderingUtils.cpp +35 -24

             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
-            #include <Variable/Variable.h>
+            #include <Variable/Variable2.h>
             #include <Visualization/qcustomplot.h>
             Q_LOGGING_CATEGORY(LOG_PlottablesRenderingUtils, "PlottablesRenderingUtils")
-            namespace {
+            namespace
+            {
             /**
              * Delegate used to set plottables properties
              */
             template <typename T, typename Enabled = void>
-            struct PlottablesSetter {
+            struct PlottablesSetter
+            {
                 static void setProperties(PlottablesMap&)
                 {
                     // Default implementation does nothing
              * @sa VectorSeries
              */
             template <typename T>
-            struct PlottablesSetter<T, typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
+            struct PlottablesSetter<T,
-                                                                 or std::is_base_of<VectorSeries, T>::value> > {
+                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
+                    auto maxPlottableIndexIt = std::max_element(plottables.cbegin(), end,
-                        = std::max_element(plottables.cbegin(), end, [](const auto &it1, const auto &it2) {
+                        [](const auto& it1, const auto& it2) { return it1.first < it2.first; });
-                              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) {
+                    for (auto i = 0; i < componentCount; ++i)
+                    {
                         auto graphIt = plottables.find(i);
-                        if (graphIt != end) {
+                        if (graphIt != end)
+                        {
                             graphIt->second->setPen(QPen { colors.at(i) });
                         }
                     }
              */
             template <typename T>
             struct PlottablesSetter<T,
-                                    typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
+                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) {
+                    if (plottables.size() != 1)
+                    {
                         return;
                     }
-                    if (auto colormap = dynamic_cast<QCPColorMap *>(plottables.begin()->second)) {
+                    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) {
+                        for (auto plotElement : plotElements)
-                            if (auto colorScale = dynamic_cast<QCPColorScale *>(plotElement)) {
+                            if (auto colorScale = dynamic_cast<QCPColorScale*>(plotElement))
+                            {
                                 colormap->setColorScale(colorScale);
                             }
                         }
                         colormap->rescaleDataRange();
                     }
-                    else {
+                    else
+                    {
                         qCCritical(LOG_PlottablesRenderingUtils()) << "Can't get colormap of the spectrogram";
                     }
                 }
              * @tparam T the data series' type
              */
             template <typename T>
-            struct PlottablesHelper : public IPlottablesHelper {
+            struct PlottablesHelper : public IPlottablesHelper
+            {
                 void setProperties(PlottablesMap& plottables) override
                 {
                     PlottablesSetter<T>::setProperties(plottables);
             } // namespace
-            std::unique_ptr<IPlottablesHelper>
+            std::unique_ptr<IPlottablesHelper> IPlottablesHelperFactory::create(Variable2& variable) noexcept
-            IPlottablesHelperFactory::create(const Variable &variable) noexcept
+                switch (variable.type())
                 {
-                switch (variable.type()) {
                     case DataSeriesType::SCALAR:
-                        return std::make_unique<PlottablesHelper<ScalarSeries> >();
+                        return std::make_unique<PlottablesHelper<ScalarTimeSerie>>();
                     case DataSeriesType::SPECTROGRAM:
-                        return std::make_unique<PlottablesHelper<SpectrogramSeries> >();
+                        return std::make_unique<PlottablesHelper<SpectrogramTimeSerie>>();
                     case DataSeriesType::VECTOR:
-                        return std::make_unique<PlottablesHelper<VectorSeries> >();
+                        return std::make_unique<PlottablesHelper<VectorTimeSerie>>();
                     default:
                         // Returns default helper
                         break;

gui/src/Visualization/VisualizationGraphHelper.cpp +226 -144

@@ -2,17 +2,19
2	#include "Visualization/qcustomplot.h"	2	#include "Visualization/qcustomplot.h"
3		3
4	#include <Data/DataSeriesUtils.h>	4	#include <Data/DataSeriesUtils.h>
5	#include <Data/ScalarSeries.h>	5	#include <Data/ScalarTimeSerie.h>
6	#include <Data/SpectrogramSeries.h>	6	#include <Data/SpectrogramTimeSerie.h>
7	#include <Data/VectorSeries.h>	7	#include <Data/VectorTimeSerie.h>
8		8
9	#include <Variable/Variable.h>	9	#include <Variable/Variable2.h>
10		10
11	Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")	11	Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
12		12
13	namespace {	13	namespace
		14	{
14		15
15	class SqpDataContainer : public QCPGraphDataContainer {	16	class SqpDataContainer : public QCPGraphDataContainer
		17	{
16	public:	18	public:
17	void appendGraphData(const QCPGraphData &data) { mData.append(data); }	19	void appendGraphData(const QCPGraphData& data) { mData.append(data); }
18	};	20	};
@@ -24,13 +26,9 public:
24	* @remarks Default implementation can't create plottables	26	* @remarks Default implementation can't create plottables
25	*/	27	*/
26	template <typename T, typename Enabled = void>	28	template <typename T, typename Enabled = void>
27	struct PlottablesCreator {	29	struct PlottablesCreator
28	static PlottablesMap createPlottables(QCustomPlot &)
29	{	30	{
30	qCCritical(LOG_DataSeries())	31	static PlottablesMap createPlottables(QCustomPlot&) { return {}; }
31	<< QObject::tr("Can't create plottables: unmanaged data series type");
32	return {};
33	}
34	};	32	};
35		33
36	PlottablesMap createGraphs(QCustomPlot &plot, int nbGraphs)	34	PlottablesMap createGraphs(QCustomPlot& plot, int nbGraphs)
@@ -38,7 +36,8 PlottablesMap createGraphs(QCustomPlot &plot, int nbGraphs)
38	PlottablesMap result{};	36	PlottablesMap result {};
39		37
40	// Creates {nbGraphs} QCPGraph to add to the plot	38	// Creates {nbGraphs} QCPGraph to add to the plot
41	for (auto i = 0; i < nbGraphs; ++i) {	39	for (auto i = 0; i < nbGraphs; ++i)
		40	{
42	auto graph = plot.addGraph();	41	auto graph = plot.addGraph();
43	result.insert({i, graph});	42	result.insert({ i, graph });
44	}	43	}
@@ -53,7 +52,8 PlottablesMap createGraphs(QCustomPlot &plot, int nbGraphs)
53	* @sa ScalarSeries	52	* @sa ScalarSeries
54	*/	53	*/
55	template <typename T>	54	template <typename T>
56	struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value> > {	55	struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<ScalarTimeSerie, T>::value>>
		56	{
57	static PlottablesMap createPlottables(QCustomPlot &plot) { return createGraphs(plot, 1); }	57	static PlottablesMap createPlottables(QCustomPlot& plot) { return createGraphs(plot, 1); }
58	};	58	};
59		59
@@ -62,7 +62,8 struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<ScalarSeri
62	* @sa VectorSeries	62	* @sa VectorSeries
63	*/	63	*/
64	template <typename T>	64	template <typename T>
65	struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<VectorSeries, T>::value> > {	65	struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<VectorTimeSerie, T>::value>>
		66	{
66	static PlottablesMap createPlottables(QCustomPlot &plot) { return createGraphs(plot, 3); }	67	static PlottablesMap createPlottables(QCustomPlot& plot) { return createGraphs(plot, 3); }
67	};	68	};
68		69
@@ -72,7 +73,8 struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<VectorSeri
72	*/	73	*/
73	template <typename T>	74	template <typename T>
74	struct PlottablesCreator<T,	75	struct PlottablesCreator<T,
75	typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {	76	typename std::enable_if_t<std::is_base_of<SpectrogramTimeSerie, T>::value>>
		77	{
76	static PlottablesMap createPlottables(QCustomPlot &plot)	78	static PlottablesMap createPlottables(QCustomPlot& plot)
77	{	79	{
78	PlottablesMap result{};	80	PlottablesMap result {};
@@ -91,7 +93,8 struct PlottablesCreator<T,
91	* @remarks Default implementation can't update plottables	93	* @remarks Default implementation can't update plottables
92	*/	94	*/
93	template <typename T, typename Enabled = void>	95	template <typename T, typename Enabled = void>
94	struct PlottablesUpdater {	96	struct PlottablesUpdater
		97	{
95	static void setPlotYAxisRange(T &, const DateTimeRange &, QCustomPlot &)	98	static void setPlotYAxisRange(T&, const DateTimeRange&, QCustomPlot&)
96	{	99	{
97	qCCritical(LOG_VisualizationGraphHelper())	100	qCCritical(LOG_VisualizationGraphHelper())
@@ -111,61 +114,120 struct PlottablesUpdater {
111	* @sa VectorSeries	114	* @sa VectorSeries
112	*/	115	*/
113	template <typename T>	116	template <typename T>
114	struct PlottablesUpdater<T,	117	struct PlottablesUpdater<T, typename std::enable_if_t<std::is_base_of<ScalarTimeSerie, T>::value>>
115	typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value	118	{
116	or std::is_base_of<VectorSeries, T>::value> > {
117	static void setPlotYAxisRange(T &dataSeries, const DateTimeRange &xAxisRange, QCustomPlot &plot)	119	static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
118	{	120	{
119	auto minValue = 0., maxValue = 0.;	121	auto minValue = 0., maxValue = 0.;
120		122	if (auto serie = dynamic_cast<ScalarTimeSerie*>(&dataSeries))
121	dataSeries.lockRead();	123	{
122	auto valuesBounds = dataSeries.valuesBounds(xAxisRange.m_TStart, xAxisRange.m_TEnd);	124	maxValue = (std::max_element(std::begin(serie), std::end(*serie))).v();
123	auto end = dataSeries.cend();	125	minValue = (std::min_element(std::begin(serie), std::end(*serie))).v();
124	if (valuesBounds.first != end && valuesBounds.second != end) {
125	auto rangeValue = [](const auto &value) { return std::isnan(value) ? 0. : value; };
126
127	minValue = rangeValue(valuesBounds.first->minValue());
128	maxValue = rangeValue(valuesBounds.second->maxValue());
129	}	126	}
130	dataSeries.unlock();
131
132	plot.yAxis->setRange(QCPRange{minValue, maxValue});	127	plot.yAxis->setRange(QCPRange { minValue, maxValue });
133	}	128	}
134		129
135	static void updatePlottables(T &dataSeries, PlottablesMap &plottables, const DateTimeRange &range,	130	static void updatePlottables(
136	bool rescaleAxes)	131	T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
137	{	132	{
138		133
139	// For each plottable to update, resets its data	134	// For each plottable to update, resets its data
140	std::map<int, QSharedPointer<SqpDataContainer> > dataContainers{};	135	for (const auto& plottable : plottables)
141	for (const auto &plottable : plottables) {	136	{
142	if (auto graph = dynamic_cast<QCPGraph *>(plottable.second)) {	137	if (auto graph = dynamic_cast<QCPGraph*>(plottable.second))
		138	{
143	auto dataContainer = QSharedPointer<SqpDataContainer>::create();	139	auto dataContainer = QSharedPointer<SqpDataContainer>::create();
		140	if (auto serie = dynamic_cast<ScalarTimeSerie*>(&dataSeries))
		141	{
		142	std::for_each(
		143	std::begin(serie), std::end(serie), [&dataContainer](const auto& value) {
		144	dataContainer->appendGraphData(QCPGraphData(value.t(), value.v()));
		145	});
		146	}
144	graph->setData(dataContainer);	147	graph->setData(dataContainer);
		148	}
		149	}
		150
		151	if (!plottables.empty())
		152	{
		153	auto plot = plottables.begin()->second->parentPlot();
145		154
146	dataContainers.insert({plottable.first, dataContainer});	155	if (rescaleAxes)
		156	{
		157	plot->rescaleAxes();
147	}	158	}
148	}	159	}
149	dataSeries.lockRead();	160	}
		161	};
		162
150		163
151	// - Gets the data of the series included in the current range	164	template <typename T>
152	// - Updates each plottable by adding, for each data item, a point that takes x-axis data	165	struct PlottablesUpdater<T, typename std::enable_if_t<std::is_base_of<VectorTimeSerie, T>::value>>
153	// and value data. The correct value is retrieved according to the index of the component	166	{
154	auto subDataIts = dataSeries.xAxisRange(range.m_TStart, range.m_TEnd);	167	static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
155	for (auto it = subDataIts.first; it != subDataIts.second; ++it) {	168	{
156	for (const auto &dataContainer : dataContainers) {	169	double minValue = 0., maxValue = 0.;
157	auto componentIndex = dataContainer.first;	170	if (auto serie = dynamic_cast<VectorTimeSerie*>(&dataSeries))
158	dataContainer.second->appendGraphData(	171	{
159	QCPGraphData(it->x(), it->value(componentIndex)));	172	std::for_each(
		173	std::begin(serie), std::end(serie), [&minValue, &maxValue](const auto& v) {
		174	minValue = std::min({ minValue, v.v().x, v.v().y, v.v().z });
		175	maxValue = std::max({ maxValue, v.v().x, v.v().y, v.v().z });
		176	});
160	}	177	}
		178
		179	plot.yAxis->setRange(QCPRange { minValue, maxValue });
161	}	180	}
162		181
163	dataSeries.unlock();	182	static void updatePlottables(
		183	T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
		184	{
164		185
165	if (!plottables.empty()) {	186	// For each plottable to update, resets its data
		187	for (const auto& plottable : plottables)
		188	{
		189	if (auto graph = dynamic_cast<QCPGraph*>(plottable.second))
		190	{
		191	auto dataContainer = QSharedPointer<SqpDataContainer>::create();
		192	if (auto serie = dynamic_cast<VectorTimeSerie*>(&dataSeries))
		193	{
		194	switch (plottable.first)
		195	{
		196	case 0:
		197	std::for_each(std::begin(serie), std::end(serie),
		198	[&dataContainer](const auto& value) {
		199	dataContainer->appendGraphData(
		200	QCPGraphData(value.t(), value.v().x));
		201	});
		202	break;
		203	case 1:
		204	std::for_each(std::begin(serie), std::end(serie),
		205	[&dataContainer](const auto& value) {
		206	dataContainer->appendGraphData(
		207	QCPGraphData(value.t(), value.v().y));
		208	});
		209	break;
		210	case 2:
		211	std::for_each(std::begin(serie), std::end(serie),
		212	[&dataContainer](const auto& value) {
		213	dataContainer->appendGraphData(
		214	QCPGraphData(value.t(), value.v().z));
		215	});
		216	break;
		217	default:
		218	break;
		219	}
		220	}
		221	graph->setData(dataContainer);
		222	}
		223	}
		224
		225	if (!plottables.empty())
		226	{
166	auto plot = plottables.begin()->second->parentPlot();	227	auto plot = plottables.begin()->second->parentPlot();
167		228
168	if (rescaleAxes) {	229	if (rescaleAxes)
		230	{
169	plot->rescaleAxes();	231	plot->rescaleAxes();
170	}	232	}
171	}	233	}
@@ -178,87 +240,97 struct PlottablesUpdater<T,
178	*/	240	*/
179	template <typename T>	241	template <typename T>
180	struct PlottablesUpdater<T,	242	struct PlottablesUpdater<T,
181	typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {	243	typename std::enable_if_t<std::is_base_of<SpectrogramTimeSerie, T>::value>>
		244	{
182	static void setPlotYAxisRange(T &dataSeries, const DateTimeRange &xAxisRange, QCustomPlot &plot)	245	static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
183	{	246	{
184	double min, max;	247	// TODO
185	std::tie(min, max) = dataSeries.yBounds();	248	// double min, max;
		249	// std::tie(min, max) = dataSeries.yBounds();
186		250
187	if (!std::isnan(min) && !std::isnan(max)) {	251	// if (!std::isnan(min) && !std::isnan(max))
188	plot.yAxis->setRange(QCPRange{min, max});	252	// {
189	}	253	// plot.yAxis->setRange(QCPRange { min, max });
		254	// }
190	}	255	}
191		256
192	static void updatePlottables(T &dataSeries, PlottablesMap &plottables, const DateTimeRange &range,	257	static void updatePlottables(
193	bool rescaleAxes)	258	T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
194	{	259	{
195	if (plottables.empty()) {	260	// TODO
196	qCDebug(LOG_VisualizationGraphHelper())	261	// if (plottables.empty())
197	<< QObject::tr("Can't update spectrogram: no colormap has been associated");	262	// {
198	return;	263	// qCDebug(LOG_VisualizationGraphHelper())
199	}	264	// << QObject::tr("Can't update spectrogram: no colormap has been
200		265	// associated");
201	// Gets the colormap to update (normally there is only one colormap)	266	// return;
202	Q_ASSERT(plottables.size() == 1);	267	// }
203	auto colormap = dynamic_cast<QCPColorMap *>(plottables.at(0));	268
204	Q_ASSERT(colormap != nullptr);	269	// // Gets the colormap to update (normally there is only one colormap)
205		270	// Q_ASSERT(plottables.size() == 1);
206	dataSeries.lockRead();	271	// auto colormap = dynamic_cast<QCPColorMap*>(plottables.at(0));
207		272	// Q_ASSERT(colormap != nullptr);
208	// Processing spectrogram data for display in QCustomPlot	273
209	auto its = dataSeries.xAxisRange(range.m_TStart, range.m_TEnd);	274	// dataSeries.lockRead();
210		275
211	// Computes logarithmic y-axis resolution for the spectrogram	276	// // Processing spectrogram data for display in QCustomPlot
212	auto yData = its.first->y();	277	// auto its = dataSeries.xAxisRange(range.m_TStart, range.m_TEnd);
213	auto yResolution = DataSeriesUtils::resolution(yData.begin(), yData.end(), true);	278
214		279	// // Computes logarithmic y-axis resolution for the spectrogram
215	// Generates mesh for colormap	280	// auto yData = its.first->y();
216	auto mesh = DataSeriesUtils::regularMesh(	281	// auto yResolution = DataSeriesUtils::resolution(yData.begin(), yData.end(), true);
217	its.first, its.second, DataSeriesUtils::Resolution{dataSeries.xResolution()},	282
218	yResolution);	283	// // Generates mesh for colormap
219		284	// auto mesh = DataSeriesUtils::regularMesh(its.first, its.second,
220	dataSeries.unlock();	285	// DataSeriesUtils::Resolution { dataSeries.xResolution() }, yResolution);
221		286
222	colormap->data()->setSize(mesh.m_NbX, mesh.m_NbY);	287	// dataSeries.unlock();
223	if (!mesh.isEmpty()) {	288
224	colormap->data()->set~~Range~~(	289	// colormap->data()->setSize(mesh.m_NbX, mesh.m_NbY);
225	QCPRange{mesh.m_XMin, mesh.xMax()},	290	// if (!mesh.isEmpty())
226	// y-axis range is converted to linear values	291	// {
227	QCPRange{std::pow(10, mesh.m_YMin), std::pow(10, mesh.yMax())});	292	// colormap->data()->setRange(QCPRange { mesh.m_XMin, mesh.xMax() },
228		293	// // y-axis range is converted to linear values
229	// Sets values	294	// QCPRange { std::pow(10, mesh.m_YMin), std::pow(10, mesh.yMax()) });
230	auto index = 0;	295
231	for (auto it = mesh.m_Data.begin(), end = mesh.m_Data.end(); it != end; ++it, ++index) {	296	// // Sets values
232	auto ~~xIndex~~ = index % ~~mesh~~.~~m_NbX~~;	297	// auto index = 0;
233	auto yIndex = index / mesh.m_NbX;	298	// for (auto it = mesh.m_Data.begin(), end = mesh.m_Data.end(); it != end; ++it,
234		299	// ++index)
235	colormap->data()->setCell(xIndex, yIndex, *it);	300	// {
236		301	// auto xIndex = index % mesh.m_NbX;
237	// Makes the NaN values to be transparent in the colormap	302	// auto yIndex = index / mesh.m_NbX;
238	if (std::isnan(*it)) {	303
239	colormap->data()->set~~Alpha~~(xIndex, yIndex, 0);	304	// colormap->data()->setCell(xIndex, yIndex, *it);
240	}	305
241	}	306	// // Makes the NaN values to be transparent in the colormap
242	}	307	// if (std::isnan(*it))
243		308	// {
244	// Rescales axes	309	// colormap->data()->setAlpha(xIndex, yIndex, 0);
245	auto plot = colormap->parentPlot();	310	// }
246		311	// }
247	if (rescaleAxes) {	312	// }
248	plot->rescaleAxes();	313
249	}	314	// // Rescales axes
		315	// auto plot = colormap->parentPlot();
		316
		317	// if (rescaleAxes)
		318	// {
		319	// plot->rescaleAxes();
		320	// }
250	}	321	}
251	};	322	};
252		323
253	/**	324	/**
254	* Helper used to create/update plottables	325	* Helper used to create/update plottables
255	*/	326	*/
256	struct IPlottablesHelper {	327	struct IPlottablesHelper
		328	{
257	virtual ~IPlottablesHelper() noexcept = default;	329	virtual ~IPlottablesHelper() noexcept = default;
258	virtual PlottablesMap create(QCustomPlot &plot) const = 0;	330	virtual PlottablesMap create(QCustomPlot& plot) const = 0;
259	virtual void setYAxisRange(const DateTimeRange &xAxisRange, QCustomPlot &plot) const = 0;	331	virtual void setYAxisRange(const DateTimeRange& xAxisRange, QCustomPlot& plot) const = 0;
260	virtual void update(PlottablesMap &plottables, const DateTimeRange &range,	332	virtual void update(
261	bool rescaleAxes = false) const = 0;	333	PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes = false) const = 0;
262	};	334	};
263		335
264	/**	336	/**
@@ -266,20 +338,24 struct IPlottablesHelper {
266	* @tparam T the data series' type	338	* @tparam T the data series' type
267	*/	339	*/
268	template <typename T>	340	template <typename T>
269	struct PlottablesHelper : public IPlottablesHelper {	341	struct PlottablesHelper : public IPlottablesHelper
270	explicit PlottablesHelper(std::shared_ptr<T> dataSeries) : m_DataSeries{dataSeries} {}	342	{
		343	explicit PlottablesHelper(T* dataSeries) : m_DataSeries { dataSeries } {}
271		344
272	PlottablesMap create(QCustomPlot &plot) const override	345	PlottablesMap create(QCustomPlot& plot) const override
273	{	346	{
274	return PlottablesCreator<T>::createPlottables(plot);	347	return PlottablesCreator<T>::createPlottables(plot);
275	}	348	}
276		349
277	void update(PlottablesMap &plottables, const DateTimeRange &range, bool rescaleAxes) const override	350	void update(
		351	PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes) const override
		352	{
		353	if (m_DataSeries)
278	{	354	{
279	if (m_DataSeries) {
280	PlottablesUpdater<T>::updatePlottables(*m_DataSeries, plottables, range, rescaleAxes);	355	PlottablesUpdater<T>::updatePlottables(*m_DataSeries, plottables, range, rescaleAxes);
281	}	356	}
282	else {	357	else
		358	{
283	qCCritical(LOG_VisualizationGraphHelper()) << "Can't update plottables: inconsistency "	359	qCCritical(LOG_VisualizationGraphHelper()) << "Can't update plottables: inconsistency "
284	"between the type of data series and the "	360	"between the type of data series and the "
285	"type supposed";	361	"type supposed";
@@ -288,73 +364,79 struct PlottablesHelper : public IPlottablesHelper {
288		364
289	void setYAxisRange(const DateTimeRange &xAxisRange, QCustomPlot &plot) const override	365	void setYAxisRange(const DateTimeRange& xAxisRange, QCustomPlot& plot) const override
290	{	366	{
291	if (m_DataSeries) {	367	if (m_DataSeries)
		368	{
292	PlottablesUpdater<T>::setPlotYAxisRange(*m_DataSeries, xAxisRange, plot);	369	PlottablesUpdater<T>::setPlotYAxisRange(*m_DataSeries, xAxisRange, plot);
293	}	370	}
294	else {	371	else
		372	{
295	qCCritical(LOG_VisualizationGraphHelper()) << "Can't update plottables: inconsistency "	373	qCCritical(LOG_VisualizationGraphHelper()) << "Can't update plottables: inconsistency "
296	"between the type of data series and the "	374	"between the type of data series and the "
297	"type supposed";	375	"type supposed";
298	}	376	}
299	}	377	}
300		378
301	~~std~~::~~shared_ptr~~<T> m_DataSeries;	379	T* m_DataSeries;
302	};	380	};
303		381
304	/// Creates IPlottablesHelper according to the type of data series a variable holds	382	/// Creates IPlottablesHelper according to the type of data series a variable holds
305	std::unique_ptr<IPlottablesHelper> createHelper(std::shared_ptr<Variable> variable) noexcept	383	std::unique_ptr<IPlottablesHelper> createHelper(std::shared_ptr<Variable2> variable) noexcept
		384	{
		385	switch (variable->type())
306	{	386	{
307	switch (variable->type()) {
308	case DataSeriesType::SCALAR:	387	case DataSeriesType::SCALAR:
309	return std::make_unique<PlottablesHelper<ScalarSeries> >(	388	return std::make_unique<PlottablesHelper<ScalarTimeSerie>>(
310	~~std~~::dynamic~~_pointer~~_cast<Scalar~~Series~~>(variable->data~~Series~~()));	389	dynamic_cast<ScalarTimeSerie*>(variable->data()->base()));
311	case DataSeriesType::SPECTROGRAM:	390	case DataSeriesType::SPECTROGRAM:
312	return std::make_unique<PlottablesHelper<SpectrogramSeries> >(	391	return std::make_unique<PlottablesHelper<SpectrogramTimeSerie>>(
313	~~std~~::dynamic~~_pointer~~_cast<Spectrogram~~Series~~>(variable->data~~Series~~()));	392	dynamic_cast<SpectrogramTimeSerie*>(variable->data()->base()));
314	case DataSeriesType::VECTOR:	393	case DataSeriesType::VECTOR:
315	return std::make_unique<PlottablesHelper<VectorSeries> >(	394	return std::make_unique<PlottablesHelper<VectorTimeSerie>>(
316	~~std~~::dynamic~~_pointer~~_cast<Vector~~Series~~>(variable->data~~Series~~()));	395	dynamic_cast<VectorTimeSerie*>(variable->data()->base()));
317	default:	396	default:
318	// Creates default helper	397	// Creates default helper
319	break;	398	break;
320	}	399	}
321		400
322	return std::make_unique<PlottablesHelper<~~IDataSeries~~> >(nullptr);	401	return std::make_unique<PlottablesHelper<TimeSeries::ITimeSerie>>(nullptr);
323	}	402	}
324		403
325	} // namespace	404	} // namespace
326		405
327	PlottablesMap VisualizationGraphHelper::create(~~std~~::~~shared_ptr~~<~~Variable~~> ~~variable~~,	406	PlottablesMap VisualizationGraphHelper::create(
328	QCustomPlot &plot) noexcept	407	std::shared_ptr<Variable2> variable, QCustomPlot& plot) noexcept
		408	{
		409	if (variable)
329	{	410	{
330	if (variable) {
331	auto helper = createHelper(variable);	411	auto helper = createHelper(variable);
332	auto plottables = helper->create(plot);	412	auto plottables = helper->create(plot);
333	return plottables;	413	return plottables;
334	}	414	}
335	else {	415	else
		416	{
336	qCDebug(LOG_VisualizationGraphHelper())	417	qCDebug(LOG_VisualizationGraphHelper())
337	<< QObject::tr("Can't create graph plottables : the variable is null");	418	<< QObject::tr("Can't create graph plottables : the variable is null");
338	return PlottablesMap{};	419	return PlottablesMap {};
339	}	420	}
340	}	421	}
341		422
342	void VisualizationGraphHelper::setYAxisRange(~~std~~::~~shared_ptr~~<~~Variable~~> ~~variable~~,	423	void VisualizationGraphHelper::setYAxisRange(
343	QCustomPlot &plot) noexcept	424	std::shared_ptr<Variable2> variable, QCustomPlot& plot) noexcept
		425	{
		426	if (variable)
344	{	427	{
345	if (variable) {
346	auto helper = createHelper(variable);	428	auto helper = createHelper(variable);
347	helper->setYAxisRange(variable->range(), plot);	429	helper->setYAxisRange(variable->range(), plot);
348	}	430	}
349	else {	431	else
		432	{
350	qCDebug(LOG_VisualizationGraphHelper())	433	qCDebug(LOG_VisualizationGraphHelper())
351	<< QObject::tr("Can't set y-axis range of plot: the variable is null");	434	<< QObject::tr("Can't set y-axis range of plot: the variable is null");
352	}	435	}
353	}	436	}
354		437
355	void VisualizationGraphHelper::updateData(~~PlottablesMap~~ &~~plottables~~,	438	void VisualizationGraphHelper::updateData(
356	std::shared_ptr<Variable> variable,	439	PlottablesMap& plottables, std::shared_ptr<Variable2> variable, const DateTimeRange& dateTime)
357	const DateTimeRange &dateTime)
358	{	440	{
359	auto helper = createHelper(variable);	441	auto helper = createHelper(variable);
360	helper->update(plottables, dateTime);	442	helper->update(plottables, dateTime);

gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp +42 -28

             #include <SqpApplication.h>
-            namespace {
+            namespace
+            {
             /// Name of the axes layer in QCustomPlot
             const auto AXES_LAYER = QStringLiteral("axes");
                 auto isLogarithmic = (xCoord ? colormap.keyAxis() : colormap.valueAxis())->scaleType()
                     == QCPAxis::stLogarithmic;
-                if (isLogarithmic) {
+                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
                     // According to the coord position, calculates the closest index in the range
                     return std::round((std::log10(coord) - std::log10(range.lower)) / valueStep);
                 }
-                else {
+                else
+                {
                     // For a linear axis, we use the conversion method of colormap
                     int index;
-                    if (xCoord) {
+                    if (xCoord)
+                    {
                         colormap.data()->coordToCell(coord, 0., &index, nullptr);
                     }
-                    else {
+                    else
+                    {
                         colormap.data()->coordToCell(0., coord, nullptr, &index);
                     }
             } // namespace
-            struct VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegatePrivate {
+            struct VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegatePrivate
+            {
                 explicit VisualizationGraphRenderingDelegatePrivate(VisualizationGraphWidget& graphWidget)
-                        : m_Plot{graphWidget.plot()},
+                        : m_Plot { graphWidget.plot() }
-                          m_PointTracer{new QCPItemTracer{&m_Plot}},
+                        , m_PointTracer { new QCPItemTracer { &m_Plot } }
-                          m_TracerTimer{},
+                        , m_TracerTimer {}
-                          m_ClosePixmap{new QCPItemPixmap{&m_Plot}},
+                        , m_ClosePixmap { new QCPItemPixmap { &m_Plot } }
-                          m_TitleText{new QCPItemText{&m_Plot}},
+                        , m_TitleText { new QCPItemText { &m_Plot } }
-                          m_XAxisPixmap{new QCPItemPixmap{&m_Plot}},
+                        , m_XAxisPixmap { new QCPItemPixmap { &m_Plot } }
-                          m_ShowXAxis{true},
+                        , m_ShowXAxis { true }
-                          m_XAxisLabel{},
+                        , m_XAxisLabel {}
-                          m_ColorScale{SqpColorScale{m_Plot}}
+                        , m_ColorScale { SqpColorScale { m_Plot } }
                 {
                     initPointTracerStyle(*m_PointTracer);
                     initClosePixmapStyle(*m_ClosePixmap);
                     // Connects pixmap selection to graph widget closing
-                    QObject::connect(&m_Plot, &QCustomPlot::itemClick,
+                    QObject::connect(
-                                     [&graphWidget, this](auto item, auto mouseEvent) {
+                        &m_Plot, &QCustomPlot::itemClick, [&graphWidget, this](auto item, auto mouseEvent) {
-                                         if (item == m_ClosePixmap) {
+                            if (item == m_ClosePixmap)
+                            {
                                 graphWidget.close();
                             }
                         });
                     // Connects pixmap selection to graph x-axis showing/hiding
                     QObject::connect(&m_Plot, &QCustomPlot::itemClick, [this](auto item, auto mouseEvent) {
-                        if (m_XAxisPixmap == item) {
+                        if (m_XAxisPixmap == item)
+                        {
                             // Changes the selection state and refreshes the x-axis
                             m_ShowXAxis = !m_ShowXAxis;
                             this->updateXAxisState();
             {
                 // 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 (impl->m_ColorScale.m_Scale == colorScale)
-                    if (ColorScaleEditor{impl->m_ColorScale}.exec() == QDialog::Accepted) {
+                    if (ColorScaleEditor { impl->m_ColorScale }.exec() == QDialog::Accepted)
+                    {
                         impl->m_Plot.replot();
                     }
                 }
                 // Gets the graph under the mouse position
                 auto eventPos = event->pos();
-                if (auto graph = qobject_cast<QCPGraph *>(impl->m_Plot.plottableAt(eventPos))) {
+                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()) {
+                    if (graphDataIt != graphData->constEnd())
+                    {
                         // Sets tooltip
                         auto key = formatValue(graphDataIt->key, *graph->keyAxis());
                         auto value = formatValue(graphDataIt->value, *graph->valueAxis());
                         impl->m_Plot.replot();
                     }
                 }
-                else if (auto colorMap = qobject_cast<QCPColorMap *>(impl->m_Plot.plottableAt(eventPos))) {
+                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());
                         formatValue(value, *colorMap->colorScale()->axis()));
                 }
-                if (!tooltip.isEmpty()) {
+                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.replot();
             }
-            void VisualizationGraphRenderingDelegate::setAxesUnits(const Variable &variable) noexcept
+            void VisualizationGraphRenderingDelegate::setAxesUnits(Variable2& variable) noexcept
             {
                 auto axisHelper = IAxisHelperFactory::create(variable);
                 impl->m_Plot.layer(AXES_LAYER)->replot();
             }
-            void VisualizationGraphRenderingDelegate::setGraphProperties(const Variable &variable,
+            void VisualizationGraphRenderingDelegate::setGraphProperties(
-                                                                         PlottablesMap &plottables) noexcept
+                Variable2& variable, PlottablesMap& plottables) noexcept
             {
                 // Axes' properties
                 auto axisHelper = IAxisHelperFactory::create(variable);

gui/src/Visualization/VisualizationGraphWidget.cpp +290 -177

             #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/Variable.h>
+            #include <Variable/Variable2.h>
             #include <Variable/VariableController2.h>
-            #include <Data/DateTimeRangeHelper.h>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
-            namespace {
+            namespace
+            {
             /// Key pressed to enable drag&drop in all modes
             const auto DRAG_DROP_MODIFIER = Qt::AltModifier;
             } // namespace
-            struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
+            struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate
+            {
                 explicit VisualizationGraphWidgetPrivate(const QString& name)
-                        : m_Name{name},
+                        : m_Name { name }
-                          m_Flags{GraphFlag::EnableAll},
+                        , m_Flags { GraphFlag::EnableAll }
-                          m_IsCalibration{false},
+                        , m_IsCalibration { false }
-                          m_RenderingDelegate{nullptr}
+                        , m_RenderingDelegate { nullptr }
                 {
                     m_plot = new QCustomPlot();
                     // Necessary for all platform since Qt::AA_EnableHighDpiScaling is enable.
                     m_plot->setPlottingHint(QCP::phFastPolylines, true);
                 }
-                void updateData(PlottablesMap &plottables, std::shared_ptr<Variable> variable,
+                void updateData(
-                                const DateTimeRange &range)
+                    PlottablesMap& plottables, std::shared_ptr<Variable2> variable, const DateTimeRange& range)
                 {
                     VisualizationGraphHelper::updateData(plottables, variable, range);
                 QString m_Name;
                 // 1 variable -> n qcpplot
-                std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
+                std::map<std::shared_ptr<Variable2>, PlottablesMap> m_VariableToPlotMultiMap;
                 GraphFlags m_Flags;
                 bool m_IsCalibration;
                 QCustomPlot* m_plot;
                     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())};
+                    QPointF pos { m_plot->xAxis->pixelToCoord(newPos.x()),
+                        m_plot->yAxis->pixelToCoord(newPos.y()) };
                     m_DrawingZoomRect->bottomRight->setCoords(pos);
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                     removeDrawingRect();
                     if (newAxisXRange.size() > axisX->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0)
-                        && newAxisYRange.size() > axisY->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);
                 void removeDrawingRect()
                 {
-                    if (m_DrawingZoomRect) {
+                    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);
+                    setSelectionZonesEditionEnabled(
+                        sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones);
                 }
                 void startDrawingZone(const QPoint& pos)
                 void endDrawingZone()
                 {
-                    if (m_DrawingZone) {
+                    if (m_DrawingZone)
+                    {
                         auto drawingZoneRange = m_DrawingZone->range();
-                        if (qAbs(drawingZoneRange.m_TEnd - drawingZoneRange.m_TStart) > 0) {
+                        if (qAbs(drawingZoneRange.m_TEnd - drawingZoneRange.m_TStart) > 0)
+                        {
                             m_DrawingZone->setEditionEnabled(true);
                             addSelectionZone(m_DrawingZone);
                         }
-                        else {
+                        else
+                        {
                             m_plot->removeItem(m_DrawingZone);
                         }
                 void setSelectionZonesEditionEnabled(bool value)
                 {
-                    for (auto s : m_SelectionZones) {
+                    for (auto s : m_SelectionZones)
+                    {
                         s->setEditionEnabled(value);
                     }
                 }
                 {
                     VisualizationSelectionZoneItem* selectionZoneItemUnderCursor = nullptr;
                     auto minDistanceToZone = -1;
-                    for (auto zone : m_SelectionZones) {
+                    for (auto zone : m_SelectionZones)
+                    {
                         auto distanceToZone = zone->selectTest(pos, false);
                         if ((minDistanceToZone < 0 || distanceToZone <= minDistanceToZone)
-                            && distanceToZone >= 0 && distanceToZone < m_plot->selectionTolerance()) {
+                            && distanceToZone >= 0 && distanceToZone < m_plot->selectionTolerance())
+                        {
                             selectionZoneItemUnderCursor = zone;
                         }
                     }
                     return selectionZoneItemUnderCursor;
                 }
-                QVector<VisualizationSelectionZoneItem *> selectionZonesAt(const QPoint &pos,
+                QVector<VisualizationSelectionZoneItem*> selectionZonesAt(
-                                                                           const QCustomPlot &plot) const
+                    const QPoint& pos, const QCustomPlot& plot) const
                 {
                     QVector<VisualizationSelectionZoneItem*> zones;
-                    for (auto zone : m_SelectionZones) {
+                    for (auto zone : m_SelectionZones)
+                    {
                         auto distanceToZone = zone->selectTest(pos, false);
-                        if (distanceToZone >= 0 && distanceToZone < plot.selectionTolerance()) {
+                        if (distanceToZone >= 0 && distanceToZone < plot.selectionTolerance())
+                        {
                             zones << zone;
                         }
                     }
                 void moveSelectionZoneOnTop(VisualizationSelectionZoneItem* zone, QCustomPlot& plot)
                 {
-                    if (!m_SelectionZones.isEmpty() && m_SelectionZones.last() != zone) {
+                    if (!m_SelectionZones.isEmpty() && m_SelectionZones.last() != zone)
+                    {
                         zone->moveToTop();
                         m_SelectionZones.removeAll(zone);
                         m_SelectionZones.append(zone);
                     this->m_plot->xAxis->setRange(newRange.m_TStart, newRange.m_TEnd);
                     if (updateVar)
                     {
-                        for (auto it = m_VariableToPlotMultiMap.begin(),
+                        for (auto it = m_VariableToPlotMultiMap.begin(), end = m_VariableToPlotMultiMap.end();
-                             end = m_VariableToPlotMultiMap.end();
                              it != end; it = m_VariableToPlotMultiMap.upper_bound(it->first))
                         {
                             sqpApp->variableController().asyncChangeRange(it->first, newRange);
                     setRange(graphRange);
                 }
-                void rescaleY()
+                void rescaleY() { m_plot->yAxis->rescale(true); }
-                    m_plot->yAxis->rescale(true);
                 std::tuple<double, double> moveGraph(const QPoint& destination)
                 {
                     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());
+                        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());
+                        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 oldRange = m_plot->xAxis->range();
                     QCPAxis* axis = m_plot->axisRect()->rangeDragAxis(orientation);
-                    if (m_plot->xAxis->scaleType() == QCPAxis::stLinear) {
+                    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) {
+                    else if (m_plot->xAxis->scaleType() == QCPAxis::stLogarithmic)
+                    {
                         int start = 0, stop = 0;
                         double diff = 0.;
-                        if (factor > 0.0) {
+                        if (factor > 0.0)
+                        {
                             stop = m_plot->width() * factor / 10;
                             start = 2 * m_plot->width() * factor / 10;
                         }
-                        if (factor < 0.0) {
+                        if (factor < 0.0)
+                        {
                             factor *= -1.0;
                             start = m_plot->width() * factor / 10;
                             stop = 2 * m_plot->width() * factor / 10;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString& name, QWidget* parent)
-                    : VisualizationDragWidget{parent},
+                    : VisualizationDragWidget { parent }
-                      ui{new Ui::VisualizationGraphWidget},
+                    , ui { new Ui::VisualizationGraphWidget }
-                      impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name)}
+                    , impl { spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name) }
             {
                 ui->setupUi(this);
                 this->layout()->addWidget(impl->m_plot);
                 impl->m_plot->setContextMenuPolicy(Qt::CustomContextMenu);
                 impl->m_plot->setParent(this);
-                connect(&sqpApp->variableController(), &VariableController2::variableDeleted, this, &VisualizationGraphWidget::variableDeleted);
+                connect(&sqpApp->variableController(), &VariableController2::variableDeleted, this,
+                    &VisualizationGraphWidget::variableDeleted);
             }
             VisualizationZoneWidget* VisualizationGraphWidget::parentZoneWidget() const noexcept
             {
                 auto parent = parentWidget();
-                while (parent != nullptr && !qobject_cast<VisualizationZoneWidget *>(parent)) {
+                while (parent != nullptr && !qobject_cast<VisualizationZoneWidget*>(parent))
+                {
                     parent = parent->parentWidget();
                 }
             VisualizationWidget* VisualizationGraphWidget::parentVisualizationWidget() const
             {
                 auto parent = parentWidget();
-                while (parent != nullptr && !qobject_cast<VisualizationWidget *>(parent)) {
+                while (parent != nullptr && !qobject_cast<VisualizationWidget*>(parent))
+                {
                     parent = parent->parentWidget();
                 }
                 impl->m_Flags = std::move(flags);
             }
-            void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, DateTimeRange range)
+            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);
                 setGraphRange(range);
                 // If the variable already has its data loaded, load its units and its range in the graph
-                if (variable->dataSeries() != nullptr) {
+                if (variable->data() != nullptr)
+                {
                     impl->m_RenderingDelegate->setAxesUnits(*variable);
                 }
                 else
                 {
                     auto context = new QObject { this };
-                    connect(variable.get(), &Variable::updated, context,
+                    connect(
-                            [this, variable, context, range](QUuid)
+                        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(), &Variable::updated, this, &VisualizationGraphWidget::variableUpdated);
+                connect(variable.get(), &Variable2::updated, this, &VisualizationGraphWidget::variableUpdated);
                 this->onUpdateVarDisplaying(variable, range); // My bullshit
                 emit variableAdded(variable);
             }
-            void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
+            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()) {
+                if (variableIt != impl->m_VariableToPlotMultiMap.cend())
+                {
                     emit variableAboutToBeRemoved(variable);
                     auto& plottablesMap = variableIt->second;
                     for (auto plottableIt = plottablesMap.cbegin(), plottableEnd = plottablesMap.cend();
-                         plottableIt != plottableEnd;) {
+                         plottableIt != plottableEnd;)
+                    {
                         impl->m_plot->removePlottable(plottableIt->second);
                         plottableIt = plottablesMap.erase(plottableIt);
                     }
                 impl->m_plot->replot(QCustomPlot::rpQueuedReplot);
             }
-            std::vector<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
+            std::vector<std::shared_ptr<Variable2>> VisualizationGraphWidget::variables() const
             {
-                auto variables = std::vector<std::shared_ptr<Variable> >{};
+                auto variables = std::vector<std::shared_ptr<Variable2>> {};
                 for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap);
-                     it != std::cend(impl->m_VariableToPlotMultiMap); ++it) {
+                     it != std::cend(impl->m_VariableToPlotMultiMap); ++it)
+                {
                     variables.push_back(it->first);
                 }
                 return variables;
             }
-            void VisualizationGraphWidget::setYRange(std::shared_ptr<Variable> variable)
+            void VisualizationGraphWidget::setYRange(std::shared_ptr<Variable2> variable)
+            {
+                if (!variable)
                 {
-                if (!variable) {
                     qCCritical(LOG_VisualizationGraphWidget()) << "Can't set y-axis range: variable is null";
                     return;
                 }
                 return DateTimeRange { graphRange.lower, graphRange.upper };
             }
-            void VisualizationGraphWidget::setGraphRange(const DateTimeRange &range, bool updateVar, bool forward)
+            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)
             QVector<DateTimeRange> VisualizationGraphWidget::selectionZoneRanges() const
             {
                 QVector<DateTimeRange> ranges;
-                for (auto zone : impl->m_SelectionZones) {
+                for (auto zone : impl->m_SelectionZones)
+                {
                     ranges << zone->range();
                 }
             void VisualizationGraphWidget::addSelectionZones(const QVector<DateTimeRange>& ranges)
             {
-                for (const auto &range : 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);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
-            VisualizationSelectionZoneItem *
+            VisualizationSelectionZoneItem* VisualizationGraphWidget::addSelectionZone(
-            VisualizationGraphWidget::addSelectionZone(const QString &name, const DateTimeRange &range)
+                const QString& name, const DateTimeRange& range)
             {
                 // note: ownership is transfered to QCustomPlot
                 auto zone = new VisualizationSelectionZoneItem(&plot());
             {
                 parentVisualizationWidget()->selectionZoneManager().setSelected(selectionZone, false);
-                if (impl->m_HoveredZone == selectionZone) {
+                if (impl->m_HoveredZone == selectionZone)
+                {
                     impl->m_HoveredZone = nullptr;
                     setCursor(Qt::ArrowCursor);
                 }
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
-            void VisualizationGraphWidget::zoom(double factor, int center, Qt::Orientation orientation, bool forward)
+            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::transform(const DateTimeRangeTransformation &tranformation, bool forward)
+            void VisualizationGraphWidget::transform(
+                const DateTimeRangeTransformation& tranformation, bool forward)
             {
                 impl->transform(tranformation);
                 if (forward)
             void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor* visitor)
             {
-                if (visitor) {
+                if (visitor)
+                {
                     visitor->visit(this);
                 }
-                else {
+                else
+                {
                     qCCritical(LOG_VisualizationGraphWidget())
                         << tr("Can't visit widget : the visitor is null");
                 }
             }
-            bool VisualizationGraphWidget::canDrop(const Variable &variable) const
+            bool VisualizationGraphWidget::canDrop(Variable2& variable) const
             {
-                auto isSpectrogram = [](const auto &variable) {
+                auto isSpectrogram
-                    return std::dynamic_pointer_cast<SpectrogramSeries>(variable.dataSeries()) != nullptr;
+                    = [](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(
+                    : std::none_of(impl->m_VariableToPlotMultiMap.cbegin(),
-                                 impl->m_VariableToPlotMultiMap.cbegin(), impl->m_VariableToPlotMultiMap.cend(),
+                          impl->m_VariableToPlotMultiMap.cend(),
                           [isSpectrogram](const auto& entry) { return isSpectrogram(*entry.first); });
             }
-            bool VisualizationGraphWidget::contains(const Variable &variable) const
+            bool VisualizationGraphWidget::contains(Variable2& variable) const
             {
                 // Finds the variable among the keys of the map
                 auto variablePtr = &variable;
                 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(position);
                 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
-                    && selectionZoneItemUnderCursor) {
+                    && selectionZoneItemUnderCursor)
-                    mimeData->setData(MIME_TYPE_TIME_RANGE, TimeController::mimeDataForTimeRange(
-                                                                selectionZoneItemUnderCursor->range()));
+                    mimeData->setData(MIME_TYPE_TIME_RANGE,
-                    mimeData->setData(MIME_TYPE_SELECTION_ZONE, TimeController::mimeDataForTimeRange(
+                        TimeController::mimeDataForTimeRange(selectionZoneItemUnderCursor->range()));
-                                                                    selectionZoneItemUnderCursor->range()));
+                    mimeData->setData(MIME_TYPE_SELECTION_ZONE,
+                        TimeController::mimeDataForTimeRange(selectionZoneItemUnderCursor->range()));
                 }
-                else {
+                else
+                {
                     mimeData->setData(MIME_TYPE_GRAPH, QByteArray {});
                     auto timeRangeData = TimeController::mimeDataForTimeRange(graphRange());
             {
                 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(dragPosition);
                 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
-                    && selectionZoneItemUnderCursor) {
+                    && selectionZoneItemUnderCursor)
+                {
                     auto zoneTopLeft = selectionZoneItemUnderCursor->topLeft->pixelPosition();
                     auto zoneBottomRight = selectionZoneItemUnderCursor->bottomRight->pixelPosition();
             void VisualizationGraphWidget::highlightForMerge(bool highlighted)
             {
-                if (highlighted) {
+                if (highlighted)
+                {
                     plot().setBackground(QBrush(QColor("#BBD5EE")));
                 }
-                else {
+                else
+                {
                     plot().setBackground(QBrush(Qt::white));
                 }
             {
                 Q_UNUSED(event);
-                for (auto i : impl->m_SelectionZones) {
+                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) {
+                for (auto& variableEntry : impl->m_VariableToPlotMultiMap)
+                {
                     emit variableAboutToBeRemoved(variableEntry.first);
                 }
             }
                 Q_UNUSED(event);
                 impl->m_RenderingDelegate->showGraphOverlay(false);
-                if (auto parentZone = parentZoneWidget()) {
+                if (auto parentZone = parentZoneWidget())
+                {
                     parentZone->notifyMouseLeaveGraph(this);
                 }
-                else {
+                else
+                {
                     qCWarning(LOG_VisualizationGraphWidget()) << "leaveEvent: No parent zone widget";
                 }
-                if (impl->m_HoveredZone) {
+                if (impl->m_HoveredZone)
+                {
                     impl->m_HoveredZone->setHovered(false);
                     impl->m_HoveredZone = nullptr;
                 }
             {
                 double factor;
                 double wheelSteps = event->delta() / 120.0; // a single step delta is +/-120 usually
-                if (event->modifiers() == Qt::ControlModifier) {
+                if (event->modifiers() == Qt::ControlModifier)
+                {
                     if (event->orientation() == Qt::Vertical) // mRangeZoom.testFlag(Qt::Vertical))
                     {
                         setCursor(Qt::SizeVerCursor);
                         zoom(factor, event->pos().y(), Qt::Vertical);
                     }
                 }
-                else if (event->modifiers() == Qt::ShiftModifier) {
+                else if (event->modifiers() == Qt::ShiftModifier)
+                {
                     if (event->orientation() == Qt::Vertical) // mRangeZoom.testFlag(Qt::Vertical))
                     {
                         setCursor(Qt::SizeHorCursor);
                         zoom(factor, event->pos().x(), Qt::Horizontal);
                     }
                 }
-                else {
+                else
+                {
                     move(wheelSteps, Qt::Horizontal);
                 }
                 event->accept();
             }
             void VisualizationGraphWidget::mouseMoveEvent(QMouseEvent* event)
             {
                 if (impl->isDrawingZoomRect())
                         auto [dx, dy] = impl->moveGraph(event->pos());
                         emit this->setrange_sig(this->graphRange(), true, false);
                     }
-                    else if(sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones)
+                    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()};
+                                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
                 {
                     if (qobject_cast<VisualizationSelectionZoneItem*>(item))
                     {
-                        QMouseEvent e{QEvent::MouseButtonRelease, posInPlot, event->button(), event->buttons(), event->modifiers()};
+                        QMouseEvent e { QEvent::MouseButtonRelease, posInPlot, event->button(),
+                            event->buttons(), event->modifiers() };
                         sqpApp->sendEvent(this->impl->m_plot, &e);
                     }
                 }
                             impl->setSelectionZonesEditionEnabled(true);
                             if ((event->modifiers() == Qt::ControlModifier) && (selectedZone != nullptr))
                             {
-                                auto alreadySelectedZones = parentVisualizationWidget()->selectionZoneManager().selectedItems();
+                                auto alreadySelectedZones
+                                    = parentVisualizationWidget()->selectionZoneManager().selectedItems();
                                 selectedZone->setAssociatedEditedZones(alreadySelectedZones);
                                 if (SciQLop::containers::contains(alreadySelectedZones, selectedZone))
                                 {
                                 {
                                     alreadySelectedZones.append(selectedZone);
                                 }
-                                parentVisualizationWidget()->selectionZoneManager().select(alreadySelectedZones);
+                                parentVisualizationWidget()->selectionZoneManager().select(
+                                    alreadySelectedZones);
                             }
                             else
                             {
                                 }
                                 else
                                 {
-                                parentVisualizationWidget()->selectionZoneManager().select({ selectedZone });
+                                    parentVisualizationWidget()->selectionZoneManager().select(
+                                        { selectedZone });
                                 }
                             }
                             {
                                 {
                                     if (qobject_cast<VisualizationSelectionZoneItem*>(item))
                                     {
-                                    QMouseEvent e{QEvent::MouseButtonPress, posInPlot, event->button(), event->buttons(), event->modifiers()};
+                                        QMouseEvent e { QEvent::MouseButtonPress, posInPlot, event->button(),
+                                            event->buttons(), event->modifiers() };
                                         sqpApp->sendEvent(this->impl->m_plot, &e);
                                     }
                                 }
             void VisualizationGraphWidget::keyReleaseEvent(QKeyEvent* event)
             {
-                switch (event->key()) {
+                switch (event->key())
+                {
                     case Qt::Key_Control:
                         event->accept();
                         break;
             void VisualizationGraphWidget::keyPressEvent(QKeyEvent* event)
             {
-                switch (event->key()) {
+                switch (event->key())
+                {
                     case Qt::Key_Control:
                         setCursor(Qt::CrossCursor);
                         break;
                         impl->m_plot->replot(QCustomPlot::rpQueuedReplot);
                         break;
                     case Qt::Key_Left:
-                        if (event->modifiers() != Qt::ControlModifier) {
+                        if (event->modifiers() != Qt::ControlModifier)
+                        {
                             move(-0.1, Qt::Horizontal);
                         }
-                        else {
+                        else
+                        {
                             zoom(2, this->width() / 2, Qt::Horizontal);
                         }
                         break;
                     case Qt::Key_Right:
-                        if (event->modifiers() != Qt::ControlModifier) {
+                        if (event->modifiers() != Qt::ControlModifier)
+                        {
                             move(0.1, Qt::Horizontal);
                         }
-                        else {
+                        else
+                        {
                             zoom(0.5, this->width() / 2, Qt::Horizontal);
                         }
                         break;
                     case Qt::Key_Up:
-                        if (event->modifiers() != Qt::ControlModifier) {
+                        if (event->modifiers() != Qt::ControlModifier)
+                        {
                             move(0.1, Qt::Vertical);
                         }
-                        else {
+                        else
+                        {
                             zoom(0.5, this->height() / 2, Qt::Vertical);
                         }
                         break;
                     case Qt::Key_Down:
-                        if (event->modifiers() != Qt::ControlModifier) {
+                        if (event->modifiers() != Qt::ControlModifier)
+                        {
                             move(-0.1, Qt::Vertical);
                         }
-                        else {
+                        else
+                        {
                             zoom(2, this->height() / 2, Qt::Vertical);
                         }
                         break;
                 // 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)) {
+                     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 (!impl->m_ZoomStack.isEmpty())
-                    if (!graphMenu.isEmpty()) {
+                    if (!graphMenu.isEmpty())
+                    {
                         graphMenu.addSeparator();
                     }
                 // Selection Zone Actions
                 auto selectionZoneItem = impl->selectionZoneAt(pos);
-                if (selectionZoneItem) {
+                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()) {
+                    if (!zoneActions.isEmpty() && !graphMenu.isEmpty())
+                    {
                         graphMenu.addSeparator();
                     }
                     QHash<QString, bool> subMenusEnabled;
                     QHash<QString, FilteringAction*> filteredMenu;
-                    for (auto zoneAction : zoneActions) {
+                    for (auto zoneAction : zoneActions)
+                    {
                         auto isEnabled = zoneAction->isEnabled(selectedItems);
                         auto menu = &graphMenu;
                         QString menuPath;
-                        for (auto subMenuName : zoneAction->subMenuList()) {
+                        for (auto subMenuName : zoneAction->subMenuList())
+                        {
                             menuPath += '/';
                             menuPath += subMenuName;
-                            if (!subMenus.contains(menuPath)) {
+                            if (!subMenus.contains(menuPath))
+                            {
                                 menu = menu->addMenu(subMenuName);
                                 subMenus[menuPath] = menu;
                                 subMenusEnabled[menuPath] = isEnabled;
                             }
-                            else {
+                            else
+                            {
                                 menu = subMenus.value(menuPath);
-                                if (isEnabled) {
+                                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())) {
+                        if (sqpApp->actionsGuiController().isMenuFiltered(zoneAction->subMenuList()))
+                        {
                             filterAction = filteredMenu.value(menuPath);
-                            if (!filterAction) {
+                            if (!filterAction)
+                            {
                                 filterAction = new FilteringAction { this };
                                 filteredMenu[menuPath] = filterAction;
                                 menu->addAction(filterAction);
                         QObject::connect(action, &QAction::triggered,
                             [zoneAction, selectedItems]() { zoneAction->execute(selectedItems); });
-                        if (filterAction && zoneAction->isFilteringAllowed()) {
+                        if (filterAction && zoneAction->isFilteringAllowed())
+                        {
                             filterAction->addActionToFilter(action);
                         }
                     }
-                    for (auto it = subMenus.cbegin(); it != subMenus.cend(); ++it) {
+                    for (auto it = subMenus.cbegin(); it != subMenus.cend(); ++it)
+                    {
                         it.value()->setEnabled(subMenusEnabled[it.key()]);
                     }
                 }
-                if (!graphMenu.isEmpty()) {
+                if (!graphMenu.isEmpty())
+                {
                     graphMenu.exec(QCursor::pos());
                 }
             }
                 auto axisPos = impl->posToAxisPos(event->pos());
                 // Zoom box and zone drawing
-                if (impl->m_DrawingZoomRect) {
+                if (impl->m_DrawingZoomRect)
+                {
                     impl->m_DrawingZoomRect->bottomRight->setCoords(axisPos);
                 }
-                else if (impl->m_DrawingZone) {
+                else if (impl->m_DrawingZone)
+                {
                     impl->m_DrawingZone->setEnd(axisPos.x());
                 }
                 // Cursor
-                if (auto parentZone = parentZoneWidget()) {
+                if (auto parentZone = parentZoneWidget())
-                    if (impl->pointIsInAxisRect(axisPos, plot())) {
+                    if (impl->pointIsInAxisRect(axisPos, plot()))
+                    {
                         parentZone->notifyMouseMoveInGraph(event->pos(), axisPos, this);
                     }
-                    else {
+                    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) {
+                    && 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 (selectionZoneItemUnderCursor != impl->m_HoveredZone)
-                        if (impl->m_HoveredZone) {
+                        if (impl->m_HoveredZone)
+                        {
                             impl->m_HoveredZone->setHovered(false);
                         }
                         selectionZoneItemUnderCursor->setHovered(true);
                         plot().replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
-                else {
+                else
+                {
                     // There is no zone under the mouse or the interaction mode is not "selection zones"
-                    if (impl->m_HoveredZone) {
+                    if (impl->m_HoveredZone)
+                    {
                         impl->m_HoveredZone->setHovered(false);
                         impl->m_HoveredZone = nullptr;
                     }
             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()))) {
+                if (!dynamic_cast<QCPAxisRect*>(impl->m_plot->layoutElementAt(event->posF())))
+                {
                     return;
                 }
                 auto value = event->angleDelta().x() + event->angleDelta().y();
-                if (value != 0) {
+                if (value != 0)
+                {
                     auto direction = value > 0 ? 1.0 : -1.0;
                     auto isZoomX = event->modifiers().testFlag(HORIZONTAL_ZOOM_MODIFIER);
                     impl->m_plot->axisRect()->setRangeZoom(zoomOrientations);
-                    if (!isZoomX && !isZoomY) {
+                    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()) {
+                        if (plot().noAntialiasingOnDrag())
+                        {
                             plot().setNotAntialiasedElements(QCP::aeAll);
                         }
                     = sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones;
                 auto isLeftClick = event->buttons().testFlag(Qt::LeftButton);
-                if (!isDragDropClick && isLeftClick) {
+                if (!isDragDropClick && isLeftClick)
-                    if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::ZoomBox) {
+                    if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::ZoomBox)
+                    {
                         // Starts a zoom box
                         impl->startDrawingRect(event->pos());
                     }
-                    else if (isSelectionZoneMode && impl->m_DrawingZone == nullptr) {
+                    else if (isSelectionZoneMode && impl->m_DrawingZone == nullptr)
+                    {
                         // Starts a new selection zone
                         auto zoneAtPos = impl->selectionZoneAt(event->pos());
-                        if (!zoneAtPos) {
+                        if (!zoneAtPos)
+                        {
                             impl->startDrawingZone(event->pos());
                         }
                     }
                 impl->setSelectionZonesEditionEnabled(isSelectionZoneMode && !isDragDropClick);
                 // Selection / Deselection
-                if (isSelectionZoneMode) {
+                if (isSelectionZoneMode)
+                {
                     auto isMultiSelectionClick = event->modifiers().testFlag(MULTI_ZONE_SELECTION_MODIFIER);
                     auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos());
                     if (selectionZoneItemUnderCursor && !selectionZoneItemUnderCursor->selected()
-                        && !isMultiSelectionClick) {
+                        && !isMultiSelectionClick)
+                    {
                         parentVisualizationWidget()->selectionZoneManager().select(
                             { selectionZoneItemUnderCursor });
                     }
-                    else if (!selectionZoneItemUnderCursor && !isMultiSelectionClick && isLeftClick) {
+                    else if (!selectionZoneItemUnderCursor && !isMultiSelectionClick && isLeftClick)
+                    {
                         parentVisualizationWidget()->selectionZoneManager().clearSelection();
                     }
-                    else {
+                    else
+                    {
                         // No selection change
                     }
-                    if (selectionZoneItemUnderCursor && isLeftClick) {
+                    if (selectionZoneItemUnderCursor && isLeftClick)
+                    {
                         selectionZoneItemUnderCursor->setAssociatedEditedZones(
                             parentVisualizationWidget()->selectionZoneManager().selectedItems());
                     }
             void VisualizationGraphWidget::onMouseRelease(QMouseEvent* event) noexcept
             {
-                if (impl->m_DrawingZoomRect) {
+                if (impl->m_DrawingZoomRect)
+                {
                     auto axisX = plot().axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = plot().axisRect()->axis(QCPAxis::atLeft);
                     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)) {
+                        && 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);
                 // Selection / Deselection
                 auto isSelectionZoneMode
                     = sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones;
-                if (isSelectionZoneMode) {
+                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) {
+                        && !impl->m_HasMovedMouse)
+                    {
                         auto zonesUnderCursor = impl->selectionZonesAt(event->pos(), plot());
-                        if (zonesUnderCursor.count() > 1) {
+                        if (zonesUnderCursor.count() > 1)
+                        {
                             // There are multiple zones under the mouse.
                             // Performs the selection with a selection dialog.
                             VisualizationMultiZoneSelectionDialog dialog { this };
                             dialog.move(mapToGlobal(event->pos() - QPoint(dialog.width() / 2, 20)));
                             dialog.activateWindow();
                             dialog.raise();
-                            if (dialog.exec() == QDialog::Accepted) {
+                            if (dialog.exec() == QDialog::Accepted)
+                            {
                                 auto selection = dialog.selectedZones();
-                                if (!isMultiSelectionClick) {
+                                if (!isMultiSelectionClick)
+                                {
                                     parentVisualizationWidget()->selectionZoneManager().clearSelection();
                                 }
-                                for (auto it = selection.cbegin(); it != selection.cend(); ++it) {
+                                for (auto it = selection.cbegin(); it != selection.cend(); ++it)
+                                {
                                     auto zone = it.key();
                                     auto isSelected = it.value();
-                                    parentVisualizationWidget()->selectionZoneManager().setSelected(zone,
+                                    parentVisualizationWidget()->selectionZoneManager().setSelected(
-                                                                                                    isSelected);
+                                        zone, isSelected);
-                                    if (isSelected) {
+                                    if (isSelected)
+                                    {
                                         // Puts the zone on top of the stack so it can be moved or resized
                                         impl->moveSelectionZoneOnTop(zone, plot());
                                     }
                                 }
                             }
                         }
-                        else {
+                        else
-                            if (!isMultiSelectionClick) {
+                            if (!isMultiSelectionClick)
+                            {
                                 parentVisualizationWidget()->selectionZoneManager().select(
                                     { selectionZoneItemUnderCursor });
                                 impl->moveSelectionZoneOnTop(selectionZoneItemUnderCursor, plot());
                             }
-                            else {
+                            else
+                            {
                                 parentVisualizationWidget()->selectionZoneManager().setSelected(
-                                    selectionZoneItemUnderCursor, !selectionZoneItemUnderCursor->selected()
+                                    selectionZoneItemUnderCursor,
+                                    !selectionZoneItemUnderCursor->selected()
                                         || event->button() == Qt::RightButton);
                             }
                         }
                     }
-                    else {
+                    else
+                    {
                         // No selection change
                     }
                 }
                 auto graphRange = impl->m_plot->xAxis->range();
                 auto dateTime = DateTimeRange { graphRange.lower, graphRange.upper };
-                for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
+                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())) {
+                    if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range()))
+                    {
                         impl->updateData(variableEntry.second, variable, variable->range());
                     }
                 }
             }
-            void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,
+            void VisualizationGraphWidget::onUpdateVarDisplaying(
-                                                                 const DateTimeRange &range)
+                std::shared_ptr<Variable2> variable, const DateTimeRange& range)
             {
                 auto it = impl->m_VariableToPlotMultiMap.find(variable);
-                if (it != impl->m_VariableToPlotMultiMap.end()) {
+                if (it != impl->m_VariableToPlotMultiMap.end())
+                {
                     impl->updateData(it->second, variable, range);
                 }
             }
             void VisualizationGraphWidget::variableUpdated(QUuid id)
             {
-                for (auto &[var, plotables] : impl->m_VariableToPlotMultiMap) {
+                for (auto& [var, plotables] : impl->m_VariableToPlotMultiMap)
-                    if (var->ID() == id) {
+                    if (var->ID() == id)
+                    {
                         impl->updateData(plotables, var, this->graphRange());
                     }
                 }
             }
-            void VisualizationGraphWidget::variableDeleted(const std::shared_ptr<Variable> & variable)
+            void VisualizationGraphWidget::variableDeleted(const std::shared_ptr<Variable2>& variable)
             {
                 this->removeVariable(variable);
             }

gui/src/Visualization/VisualizationTabWidget.cpp +83 -57

             Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
-            namespace {
+            namespace
+            {
             /**
              * Applies a function to all zones of the tab represented by its layout
             template <typename Fun>
             void processZones(QLayout& layout, Fun fun)
             {
-                for (auto i = 0; i < layout.count(); ++i) {
+                for (auto i = 0; i < layout.count(); ++i)
-                    if (auto item = layout.itemAt(i)) {
+                    if (auto item = layout.itemAt(i))
+                    {
                         if (auto visualizationZoneWidget
-                            = qobject_cast<VisualizationZoneWidget *>(item->widget())) {
+                            = qobject_cast<VisualizationZoneWidget*>(item->widget()))
+                        {
                             fun(*visualizationZoneWidget);
                         }
                     }
             QString defaultZoneName(QLayout& layout)
             {
                 QSet<QString> existingNames;
-                processZones(layout,
+                processZones(
-                             [&existingNames](auto &zoneWidget) { existingNames.insert(zoneWidget.name()); });
+                    layout, [&existingNames](auto& zoneWidget) { existingNames.insert(zoneWidget.name()); });
                 int zoneNum = 1;
                 QString name;
-                do {
+                do
+                {
                     name = QObject::tr("Zone ").append(QString::number(zoneNum));
                     ++zoneNum;
                 } while (existingNames.contains(name));
             } // namespace
-            struct VisualizationTabWidget::VisualizationTabWidgetPrivate {
+            struct VisualizationTabWidget::VisualizationTabWidgetPrivate
+            {
                 explicit VisualizationTabWidgetPrivate(const QString& name) : m_Name { name } {}
                 QString m_Name;
                 void dropGraph(int index, VisualizationTabWidget* tabWidget);
                 void dropZone(int index, VisualizationTabWidget* tabWidget);
-                void dropVariables(const std::vector<std::shared_ptr<Variable> > &variables, int index,
+                void dropVariables(const std::vector<std::shared_ptr<Variable2>>& variables, int index,
-                                   VisualizationTabWidget *tabWidget);
-                void dropProducts(const QVariantList &productsMetaData, int index,
                     VisualizationTabWidget* tabWidget);
+                void dropProducts(
+                    const QVariantList& productsMetaData, int index, VisualizationTabWidget* tabWidget);
             };
             VisualizationTabWidget::VisualizationTabWidget(const QString& name, QWidget* parent)
-                    : QWidget{parent},
+                    : QWidget { parent }
-                      ui{new Ui::VisualizationTabWidget},
+                    , ui { new Ui::VisualizationTabWidget }
-                      impl{spimpl::make_unique_impl<VisualizationTabWidgetPrivate>(name)}
+                    , impl { spimpl::make_unique_impl<VisualizationTabWidgetPrivate>(name) }
             {
                 ui->setupUi(this);
                 ui->dragDropContainer->setPlaceHolderType(DragDropGuiController::PlaceHolderType::Zone, "Zone");
                 ui->dragDropContainer->layout()->setContentsMargins(0, 0, 0, 12);
                 ui->dragDropContainer->layout()->setSpacing(0);
-                ui->dragDropContainer->setMimeType(MIME_TYPE_GRAPH,
+                ui->dragDropContainer->setMimeType(
-                                                   VisualizationDragDropContainer::DropBehavior::Inserted);
+                    MIME_TYPE_GRAPH, VisualizationDragDropContainer::DropBehavior::Inserted);
-                ui->dragDropContainer->setMimeType(MIME_TYPE_ZONE,
+                ui->dragDropContainer->setMimeType(
-                                                   VisualizationDragDropContainer::DropBehavior::Inserted);
+                    MIME_TYPE_ZONE, VisualizationDragDropContainer::DropBehavior::Inserted);
-                ui->dragDropContainer->setMimeType(MIME_TYPE_VARIABLE_LIST,
+                ui->dragDropContainer->setMimeType(
-                                                   VisualizationDragDropContainer::DropBehavior::Inserted);
+                    MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::Inserted);
-                ui->dragDropContainer->setMimeType(MIME_TYPE_PRODUCT_LIST,
+                ui->dragDropContainer->setMimeType(
-                                                   VisualizationDragDropContainer::DropBehavior::Inserted);
+                    MIME_TYPE_PRODUCT_LIST, VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
-                    return sqpApp->dragDropGuiController().checkMimeDataForVisualization(mimeData,
+                    return sqpApp->dragDropGuiController().checkMimeDataForVisualization(
-                                                                                         ui->dragDropContainer);
+                        mimeData, ui->dragDropContainer);
                 });
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
             QStringList VisualizationTabWidget::availableZoneWidgets() const
             {
                 QStringList zones;
-                processZones(tabLayout(),
+                processZones(
-                             [&zones](VisualizationZoneWidget &zoneWidget) { zones << zoneWidget.name(); });
+                    tabLayout(), [&zones](VisualizationZoneWidget& zoneWidget) { zones << zoneWidget.name(); });
                 return zones;
             }
             {
                 VisualizationZoneWidget* result = nullptr;
                 processZones(tabLayout(), [&zoneName, &result](VisualizationZoneWidget& zoneWidget) {
-                    if (!result && zoneWidget.name() == zoneName) {
+                    if (!result && zoneWidget.name() == zoneName)
+                    {
                         result = &zoneWidget;
                     }
                 });
                 return result;
             }
-            VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
+            VisualizationZoneWidget* VisualizationTabWidget::createZone(std::shared_ptr<Variable2> variable)
             {
                 return createZone({ variable }, -1);
             }
-            VisualizationZoneWidget *
+            VisualizationZoneWidget* VisualizationTabWidget::createZone(
-            VisualizationTabWidget::createZone(const std::vector<std::shared_ptr<Variable> > &variables, int index)
+                const std::vector<std::shared_ptr<Variable2>>& variables, int index)
             {
                 auto zoneWidget = createEmptyZone(index);
             void VisualizationTabWidget::accept(IVisualizationWidgetVisitor* visitor)
             {
-                if (visitor) {
+                if (visitor)
+                {
                     visitor->visitEnter(this);
                     // Apply visitor to zone children: widgets different from zones are not visited (no action)
-                    processZones(tabLayout(), [visitor](VisualizationZoneWidget &zoneWidget) {
+                    processZones(tabLayout(),
-                        zoneWidget.accept(visitor);
+                        [visitor](VisualizationZoneWidget& zoneWidget) { zoneWidget.accept(visitor); });
-                    });
                     visitor->visitLeave(this);
                 }
-                else {
+                else
+                {
                     qCCritical(LOG_VisualizationTabWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
-            bool VisualizationTabWidget::canDrop(const Variable &variable) const
+            bool VisualizationTabWidget::canDrop(Variable2& variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
-            bool VisualizationTabWidget::contains(const Variable &variable) const
+            bool VisualizationTabWidget::contains(Variable2& variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             void VisualizationTabWidget::dropMimeData(int index, const QMimeData* mimeData)
             {
-                if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
+                if (mimeData->hasFormat(MIME_TYPE_GRAPH))
+                {
                     impl->dropGraph(index, this);
                 }
-                else if (mimeData->hasFormat(MIME_TYPE_ZONE)) {
+                else if (mimeData->hasFormat(MIME_TYPE_ZONE))
+                {
                     impl->dropZone(index, this);
                 }
-                else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
+                else 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)));
                     impl->dropVariables(variables, index, this);
                 }
-                else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
+                else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST))
+                {
                     auto productsData = sqpApp->dataSourceController().productsDataForMimeData(
                         mimeData->data(MIME_TYPE_PRODUCT_LIST));
                     impl->dropProducts(productsData, index, this);
                 }
-                else {
+                else
+                {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropMimeData, unknown MIME data received.");
                 }
                 auto& helper = sqpApp->dragDropGuiController();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget*>(helper.getCurrentDragWidget());
-                if (!graphWidget) {
+                if (!graphWidget)
+                {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropGraph, drop aborted, the dropped graph is not "
                               "found or invalid.");
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer*>(graphWidget->parentWidget());
-                if (!parentDragDropContainer) {
+                if (!parentDragDropContainer)
+                {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropGraph, drop aborted, the parent container of "
                               "the dropped graph is not found.");
                 const auto& variables = graphWidget->variables();
-                if (!variables.empty()) {
+                if (!variables.empty())
+                {
                     // Abort the requests for the variables (if any)
                     // Commented, because it's not sure if it's needed or not
                     // for (const auto& var : variables)
                     //    sqpApp->variableController().onAbortProgressRequested(var);
                     //}
-                    if (nbGraph == 1) {
+                    if (nbGraph == 1)
+                    {
                         // This is the only graph in the previous zone, close the zone
                         helper.delayedCloseWidget(graphWidget->parentZoneWidget());
                     }
-                    else {
+                    else
+                    {
                         // Close the graph
                         helper.delayedCloseWidget(graphWidget);
                     }
                     auto zoneWidget = tabWidget->createZone(variables, index);
                     auto firstGraph = zoneWidget->firstGraph();
-                    if (firstGraph) {
+                    if (firstGraph)
+                    {
                         firstGraph->addSelectionZones(graphWidget->selectionZoneRanges());
                     }
-                    else {
+                    else
+                    {
                         qCWarning(LOG_VisualizationZoneWidget())
                             << tr("VisualizationTabWidget::dropGraph, no graph added in the widget.");
                         Q_ASSERT(false);
                     }
                 }
-                else {
+                else
+                {
                     // The graph is empty, create an empty zone and move the graph inside
                     auto parentZoneWidget = graphWidget->parentZoneWidget();
                     zoneWidget->addGraph(graphWidget);
                     // Close the old zone if it was the only graph inside
-                    if (nbGraph == 1) {
+                    if (nbGraph == 1)
+                    {
                         helper.delayedCloseWidget(parentZoneWidget);
                     }
                 }
                 auto& helper = sqpApp->dragDropGuiController();
                 auto zoneWidget = qobject_cast<VisualizationZoneWidget*>(helper.getCurrentDragWidget());
-                if (!zoneWidget) {
+                if (!zoneWidget)
+                {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropZone, drop aborted, the dropped zone is not "
                               "found or invalid.");
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer*>(zoneWidget->parentWidget());
-                if (!parentDragDropContainer) {
+                if (!parentDragDropContainer)
+                {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropZone, drop aborted, the parent container of "
                               "the dropped zone is not found.");
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropVariables(
-                const std::vector<std::shared_ptr<Variable> > &variables, int index,
+                const std::vector<std::shared_ptr<Variable2>>& variables, int index,
                 VisualizationTabWidget* tabWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
-                if (variables.size() > 1) {
+                if (variables.size() > 1)
+                {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropVariables, dropping multiple variables, operation "
                               "aborted.");
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
-                if (productsMetaData.count() != 1) {
+                if (productsMetaData.count() != 1)
+                {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropProducts, dropping multiple products, operation "
                               "aborted.");

gui/src/Visualization/VisualizationWidget.cpp +47 -31

             Q_LOGGING_CATEGORY(LOG_VisualizationWidget, "VisualizationWidget")
-            struct VisualizationWidget::VisualizationWidgetPrivate {
+            struct VisualizationWidget::VisualizationWidgetPrivate
+            {
                 std::unique_ptr<VisualizationSelectionZoneManager> m_ZoneSelectionManager = nullptr;
                 VisualizationActionManager m_ActionManager;
             };
             VisualizationWidget::VisualizationWidget(QWidget* parent)
-                    : QWidget{parent},
+                    : QWidget { parent }
-                      ui{new Ui::VisualizationWidget},
+                    , ui { new Ui::VisualizationWidget }
-                      impl{spimpl::make_unique_impl<VisualizationWidgetPrivate>()}
+                    , impl { spimpl::make_unique_impl<VisualizationWidgetPrivate>() }
             {
                 ui->setupUi(this);
                 ui->tabWidget->setCornerWidget(addTabViewButton, Qt::TopRightCorner);
                 auto enableMinimumCornerWidgetSize = [this](bool enable) {
                     auto tabViewCornerWidget = ui->tabWidget->cornerWidget();
                     auto width = enable ? tabViewCornerWidget->width() : 0;
                     auto height = enable ? tabViewCornerWidget->height() : 0;
                 };
                 auto addTabView = [this, enableMinimumCornerWidgetSize]() {
-                    auto widget = new VisualizationTabWidget{QString{"View %1"}.arg(ui->tabWidget->count() + 1),
+                    auto widget
+                        = new VisualizationTabWidget { QString { "View %1" }.arg(ui->tabWidget->count() + 1),
                               ui->tabWidget };
                     auto index = ui->tabWidget->addTab(widget, widget->name());
-                    if (ui->tabWidget->count() > 0) {
+                    if (ui->tabWidget->count() > 0)
+                    {
                         enableMinimumCornerWidgetSize(false);
                     }
                     qCInfo(LOG_VisualizationWidget()) << tr("add the tab of index %1").arg(index);
                 };
                 auto removeTabView = [this, enableMinimumCornerWidgetSize](int index) {
-                    if (ui->tabWidget->count() == 1) {
+                    if (ui->tabWidget->count() == 1)
+                    {
                         enableMinimumCornerWidgetSize(true);
                     }
                     // Removes widget from tab and closes it
                     auto widget = ui->tabWidget->widget(index);
                     ui->tabWidget->removeTab(index);
-                    if (widget) {
+                    if (widget)
+                    {
                         widget->close();
                     }
                     qCInfo(LOG_VisualizationWidget()) << tr("remove the tab of index %1").arg(index);
                 };
                 ui->tabWidget->setTabsClosable(true);
                 removeZoneAction->setShortcut(QKeySequence::Delete);
                 connect(removeZoneAction, &QAction::triggered, [this]() {
                     auto selection = impl->m_ZoneSelectionManager->selectedItems();
-                    for (auto selectionZone : selection) {
+                    for (auto selectionZone : selection)
-                        if (auto graph = selectionZone->parentGraphWidget()) {
+                        if (auto graph = selectionZone->parentGraphWidget())
+                        {
                             graph->removeSelectionZone(selectionZone);
                         }
                     }
             VisualizationTabWidget* VisualizationWidget::currentTabWidget() const
             {
-                if (auto tab = qobject_cast<VisualizationTabWidget *>(ui->tabWidget->currentWidget())) {
+                if (auto tab = qobject_cast<VisualizationTabWidget*>(ui->tabWidget->currentWidget()))
+                {
                     return tab;
                 }
             void VisualizationWidget::accept(IVisualizationWidgetVisitor* visitor)
             {
-                if (visitor) {
+                if (visitor)
+                {
                     visitor->visitEnter(this);
                     // Apply visitor for tab children
-                    for (auto i = 0; i < ui->tabWidget->count(); ++i) {
+                    for (auto i = 0; i < ui->tabWidget->count(); ++i)
+                    {
                         // Widgets different from tabs are not visited (no action)
                         if (auto visualizationTabWidget
-                            = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->widget(i))) {
+                            = dynamic_cast<VisualizationTabWidget*>(ui->tabWidget->widget(i)))
+                        {
                             visualizationTabWidget->accept(visitor);
                         }
                     }
                     visitor->visitLeave(this);
                 }
-                else {
+                else
+                {
                     qCCritical(LOG_VisualizationWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
-            bool VisualizationWidget::canDrop(const Variable &variable) const
+            bool VisualizationWidget::canDrop(Variable2& variable) const
             {
                 // The main widget can never accomodate a variable
                 Q_UNUSED(variable);
                 return false;
             }
-            bool VisualizationWidget::contains(const Variable &variable) const
+            bool VisualizationWidget::contains(Variable2& variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             void VisualizationWidget::attachVariableMenu(
-                QMenu *menu, const QVector<std::shared_ptr<Variable> > &variables) noexcept
+                QMenu* menu, const QVector<std::shared_ptr<Variable2>>& variables) noexcept
             {
                 // Menu is generated only if there is a single variable
-                if (variables.size() == 1) {
+                if (variables.size() == 1)
-                    if (auto variable = variables.first()) {
+                    if (auto variable = variables.first())
+                    {
                         // Gets the containers of the variable
                         FindVariableOperation findVariableOperation { variable };
                         accept(&findVariableOperation);
                         auto variableContainers = findVariableOperation.result();
                         // Generates the actions that make it possible to visualize the variable
-                        GenerateVariableMenuOperation generateVariableMenuOperation{
+                        GenerateVariableMenuOperation generateVariableMenuOperation { menu, variable,
-                            menu, variable, std::move(variableContainers)};
+                            std::move(variableContainers) };
                         accept(&generateVariableMenuOperation);
                     }
-                    else {
+                    else
+                    {
                         qCCritical(LOG_VisualizationWidget()) << tr(
                             "Can't generate the menu relative to the visualization: the variable is null");
                     }
                 }
-                else {
+                else
+                {
                     qCDebug(LOG_VisualizationWidget())
                         << tr("No generation of the menu related to the visualization: several variables are "
                               "selected");
                 }
             }
-            void VisualizationWidget::onVariableAboutToBeDeleted(std::shared_ptr<Variable> variable) noexcept
+            void VisualizationWidget::onVariableAboutToBeDeleted(std::shared_ptr<Variable2> variable) noexcept
             {
                 // Calls the operation of removing all references to the variable in the visualization
                 auto removeVariableOperation = RemoveVariableOperation { variable };
                 accept(&removeVariableOperation);
             }
-            void VisualizationWidget::onRangeChanged(std::shared_ptr<Variable> variable,
+            void VisualizationWidget::onRangeChanged(
-                                                     const DateTimeRange &range) noexcept
+                std::shared_ptr<Variable2> variable, const DateTimeRange& range) noexcept
             {
                 // Calls the operation of rescaling all graph that contrains variable in the visualization
                 auto rescaleVariableOperation = RescaleAxeOperation { variable, range };
             void VisualizationWidget::closeEvent(QCloseEvent* event)
             {
                 // Closes tabs in the widget
-                for (auto i = 0; i < ui->tabWidget->count(); ++i) {
+                for (auto i = 0; i < ui->tabWidget->count(); ++i)
+                {
                     if (auto visualizationTabWidget
-                        = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->widget(i))) {
+                        = dynamic_cast<VisualizationTabWidget*>(ui->tabWidget->widget(i)))
+                    {
                         visualizationTabWidget->close();
                     }
                 }

gui/src/Visualization/VisualizationZoneWidget.cpp +146 -113

             #include <Data/DateTimeRangeHelper.h>
             #include <DataSource/DataSourceController.h>
             #include <Time/TimeController.h>
-            #include <Variable/Variable.h>
+            #include <Variable/Variable2.h>
             #include <Variable/VariableController2.h>
             #include <Visualization/operations/FindVariableOperation.h>
             Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
-            namespace {
+            namespace
+            {
             /**
              * Applies a function to all graphs of the zone represented by its layout
             template <typename Fun>
             void processGraphs(QLayout& layout, Fun fun)
             {
-                for (auto i = 0; i < layout.count(); ++i) {
+                for (auto i = 0; i < layout.count(); ++i)
-                    if (auto item = layout.itemAt(i)) {
+                    if (auto item = layout.itemAt(i))
+                    {
                         if (auto visualizationGraphWidget
-                            = qobject_cast<VisualizationGraphWidget *>(item->widget())) {
+                            = qobject_cast<VisualizationGraphWidget*>(item->widget()))
+                        {
                             fun(*visualizationGraphWidget);
                         }
                     }
                 int zoneNum = 1;
                 QString name;
-                do {
+                do
+                {
                     name = QObject::tr("Graph ").append(QString::number(zoneNum));
                     ++zoneNum;
                 } while (existingNames.contains(name));
             } // namespace
-            struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
+            struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate
+            {
                 explicit VisualizationZoneWidgetPrivate()
-                        : m_SynchronisationGroupId{QUuid::createUuid()},
+                        : m_SynchronisationGroupId { QUuid::createUuid() }
-                          m_Synchronizer{std::make_unique<QCustomPlotSynchronizer>()}
+                        , m_Synchronizer { std::make_unique<QCustomPlotSynchronizer>() }
                 {
                 }
                 QUuid m_SynchronisationGroupId;
                 std::unique_ptr<IGraphSynchronizer> m_Synchronizer;
                 void dropGraph(int index, VisualizationZoneWidget* zoneWidget);
-                void dropVariables(const std::vector<std::shared_ptr<Variable> > &variables, int index,
+                void dropVariables(const std::vector<std::shared_ptr<Variable2>>& variables, int index,
-                                   VisualizationZoneWidget *zoneWidget);
-                void dropProducts(const QVariantList &productsData, int index,
                     VisualizationZoneWidget* zoneWidget);
+                void dropProducts(
+                    const QVariantList& productsData, int index, VisualizationZoneWidget* zoneWidget);
             };
             VisualizationZoneWidget::VisualizationZoneWidget(const QString& name, QWidget* parent)
-                    : VisualizationDragWidget{parent},
+                    : VisualizationDragWidget { parent }
-                      ui{new Ui::VisualizationZoneWidget},
+                    , ui { new Ui::VisualizationZoneWidget }
-                      impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
+                    , impl { spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>() }
             {
                 ui->setupUi(this);
                 ui->zoneNameLabel->setText(name);
                 ui->dragDropContainer->setPlaceHolderType(DragDropGuiController::PlaceHolderType::Graph);
-                ui->dragDropContainer->setMimeType(MIME_TYPE_GRAPH,
+                ui->dragDropContainer->setMimeType(
-                                                   VisualizationDragDropContainer::DropBehavior::Inserted);
+                    MIME_TYPE_GRAPH, VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setMimeType(
                     MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
                 ui->dragDropContainer->setMimeType(
                     MIME_TYPE_PRODUCT_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
-                ui->dragDropContainer->setMimeType(MIME_TYPE_TIME_RANGE,
+                ui->dragDropContainer->setMimeType(
-                                                   VisualizationDragDropContainer::DropBehavior::Merged);
+                    MIME_TYPE_TIME_RANGE, VisualizationDragDropContainer::DropBehavior::Merged);
-                ui->dragDropContainer->setMimeType(MIME_TYPE_ZONE,
+                ui->dragDropContainer->setMimeType(
-                                                   VisualizationDragDropContainer::DropBehavior::Forbidden);
+                    MIME_TYPE_ZONE, VisualizationDragDropContainer::DropBehavior::Forbidden);
-                ui->dragDropContainer->setMimeType(MIME_TYPE_SELECTION_ZONE,
+                ui->dragDropContainer->setMimeType(
-                                                   VisualizationDragDropContainer::DropBehavior::Forbidden);
+                    MIME_TYPE_SELECTION_ZONE, VisualizationDragDropContainer::DropBehavior::Forbidden);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
-                    return sqpApp->dragDropGuiController().checkMimeDataForVisualization(mimeData,
+                    return sqpApp->dragDropGuiController().checkMimeDataForVisualization(
-                                                                                         ui->dragDropContainer);
+                        mimeData, ui->dragDropContainer);
                 });
                 auto acceptDragWidgetFun = [](auto dragWidget, auto mimeData) {
-                    if (!mimeData) {
+                    if (!mimeData)
+                    {
                         return false;
                     }
-                    if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
+                    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) {
+                        if (variables.size() != 1)
+                        {
                             return false;
                         }
                         auto variable = variables.front();
-                        if (auto graphWidget = dynamic_cast<const VisualizationGraphWidget *>(dragWidget)) {
+                        if (auto graphWidget = dynamic_cast<const VisualizationGraphWidget*>(dragWidget))
+                        {
                             return graphWidget->canDrop(*variable);
                         }
                     }
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                 // Synchronisation id
-                QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
+                //    QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
-                                          Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
+                //        Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             VisualizationZoneWidget::~VisualizationZoneWidget()
             void VisualizationZoneWidget::setZoneRange(const DateTimeRange& range)
             {
-                if (auto graph = firstGraph()) {
+                if (auto graph = firstGraph())
+                {
                     graph->setGraphRange(range);
                 }
-                else {
+                else
+                {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("setZoneRange:Cannot set the range of an empty zone.");
                 }
                 //    ui->dragDropContainer->addDragWidget(graphWidget);
                 insertGraph(0, graphWidget);
             }
             void VisualizationZoneWidget::insertGraph(int index, VisualizationGraphWidget* graphWidget)
             {
                 DEPRECATE(
-                    auto layout = ui->dragDropContainer->layout();
+                    auto layout = ui->dragDropContainer->layout(); for (int i = 0; i < layout->count(); i++) {
-                    for(int i=0;i<layout->count();i++)
                         auto graph = qobject_cast<VisualizationGraphWidget*>(layout->itemAt(i)->widget());
-                        connect(graphWidget, &VisualizationGraphWidget::setrange_sig, graph, &VisualizationGraphWidget::setGraphRange);
+                        connect(graphWidget, &VisualizationGraphWidget::setrange_sig, graph,
-                        connect(graph, &VisualizationGraphWidget::setrange_sig, graphWidget, &VisualizationGraphWidget::setGraphRange);
+                            &VisualizationGraphWidget::setGraphRange);
+                        connect(graph, &VisualizationGraphWidget::setrange_sig, graphWidget,
-                    if(auto graph = firstGraph())
+                            &VisualizationGraphWidget::setGraphRange);
+                    } if (auto graph = firstGraph()) { graphWidget->setGraphRange(graph->graphRange(), true); })
-                        graphWidget->setGraphRange(graph->graphRange(), true);
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->insertDragWidget(index, graphWidget);
             }
-            VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
+            VisualizationGraphWidget* VisualizationZoneWidget::createGraph(std::shared_ptr<Variable2> variable)
             {
                 return createGraph(variable, -1);
             }
-            VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable,
+            VisualizationGraphWidget* VisualizationZoneWidget::createGraph(
-                                                                           int index)
+                std::shared_ptr<Variable2> variable, int index)
             {
                 auto graphWidget
                     = new VisualizationGraphWidget { defaultGraphName(*ui->dragDropContainer->layout()), this };
                 //                    }
                 //                    default:
                 //                        qCCritical(LOG_VisualizationZoneWidget())
-            //                            << tr("Impossible to synchronize: zoom type not take into account");
+                //                            << tr("Impossible to synchronize: zoom type not take into
+                //                            account");
                 //                        // No action
                 //                        break;
                 //                }
                     &VisualizationZoneWidget::onVariableAboutToBeRemoved);
                 auto range = DateTimeRange {};
-                if (auto firstGraph = this->firstGraph()) {
+                if (auto firstGraph = this->firstGraph())
+                {
                     // Case of a new graph in a existant zone
                     range = firstGraph->graphRange();
                 }
-                else {
+                else
+                {
                     // Case of a new graph as the first of the zone
                     range = variable->range();
                 }
                 return graphWidget;
             }
-            VisualizationGraphWidget *
+            VisualizationGraphWidget* VisualizationZoneWidget::createGraph(
-            VisualizationZoneWidget::createGraph(const std::vector<std::shared_ptr<Variable> > variables, int index)
+                const std::vector<std::shared_ptr<Variable2>> variables, int index)
+            {
+                if (variables.empty())
                 {
-                if (variables.empty()) {
                     return nullptr;
                 }
                 auto graphWidget = createGraph(variables.front(), index);
-                for (auto variableIt = variables.cbegin() + 1; variableIt != variables.cend(); ++variableIt) {
+                for (auto variableIt = variables.cbegin() + 1; variableIt != variables.cend(); ++variableIt)
+                {
                     graphWidget->addVariable(*variableIt, graphWidget->graphRange());
                 }
             {
                 VisualizationGraphWidget* firstGraph = nullptr;
                 auto layout = ui->dragDropContainer->layout();
-                if (layout->count() > 0) {
+                if (layout->count() > 0)
+                {
                     if (auto visualizationGraphWidget
-                        = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
+                        = qobject_cast<VisualizationGraphWidget*>(layout->itemAt(0)->widget()))
+                    {
                         firstGraph = visualizationGraphWidget;
                     }
                 }
             void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor* visitor)
             {
-                if (visitor) {
+                if (visitor)
+                {
                     visitor->visitEnter(this);
                     // Apply visitor to graph children: widgets different from graphs are not visited (no
                     // action)
-                    processGraphs(
+                    processGraphs(*ui->dragDropContainer->layout(),
-                        *ui->dragDropContainer->layout(),
                         [visitor](VisualizationGraphWidget& graphWidget) { graphWidget.accept(visitor); });
                     visitor->visitLeave(this);
                 }
-                else {
+                else
+                {
                     qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
-            bool VisualizationZoneWidget::canDrop(const Variable &variable) const
+            bool VisualizationZoneWidget::canDrop(Variable2& variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
-            bool VisualizationZoneWidget::contains(const Variable &variable) const
+            bool VisualizationZoneWidget::contains(Variable2& variable) const
             {
                 Q_UNUSED(variable);
                 return false;
                 auto mimeData = new QMimeData;
                 mimeData->setData(MIME_TYPE_ZONE, QByteArray {});
-                if (auto firstGraph = this->firstGraph()) {
+                if (auto firstGraph = this->firstGraph())
+                {
                     auto timeRangeData = TimeController::mimeDataForTimeRange(firstGraph->graphRange());
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
                 }
             }
             void VisualizationZoneWidget::notifyMouseMoveInGraph(const QPointF& graphPosition,
-                                                                 const QPointF &plotPosition,
+                const QPointF& plotPosition, VisualizationGraphWidget* graphWidget)
-                                                                 VisualizationGraphWidget *graphWidget)
+                processGraphs(*ui->dragDropContainer->layout(),
+                    [&graphPosition, &plotPosition, &graphWidget](VisualizationGraphWidget& processedGraph) {
+                        switch (sqpApp->plotsCursorMode())
                         {
-                processGraphs(*ui->dragDropContainer->layout(), [&graphPosition, &plotPosition, &graphWidget](
-                                                                    VisualizationGraphWidget &processedGraph) {
-                    switch (sqpApp->plotsCursorMode()) {
                             case SqpApplication::PlotsCursorMode::Vertical:
                                 processedGraph.removeHorizontalCursor();
                                 processedGraph.addVerticalCursorAtViewportPosition(graphPosition.x());
                                 break;
                             case SqpApplication::PlotsCursorMode::Horizontal:
                                 processedGraph.removeVerticalCursor();
-                            if (&processedGraph == graphWidget) {
+                                if (&processedGraph == graphWidget)
+                                {
                                     processedGraph.addHorizontalCursorAtViewportPosition(graphPosition.y());
                                 }
-                            else {
+                                else
+                                {
                                     processedGraph.removeHorizontalCursor();
                                 }
                                 break;
                             case SqpApplication::PlotsCursorMode::Cross:
-                            if (&processedGraph == graphWidget) {
+                                if (&processedGraph == graphWidget)
+                                {
                                     processedGraph.addVerticalCursorAtViewportPosition(graphPosition.x());
                                     processedGraph.addHorizontalCursorAtViewportPosition(graphPosition.y());
                                 }
-                            else {
+                                else
+                                {
                                     processedGraph.removeHorizontalCursor();
                                     processedGraph.removeVerticalCursor();
                                 }
                                 processedGraph.removeVerticalCursor();
                                 break;
                         }
                     });
             }
                 QWidget::closeEvent(event);
             }
-            void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
+            void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable2> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
-                                          Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
+                    Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable2>, variable),
                     Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
-            void VisualizationZoneWidget::onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable)
+            void VisualizationZoneWidget::onVariableAboutToBeRemoved(std::shared_ptr<Variable2> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "desynchronize", Qt::QueuedConnection,
-                                          Q_ARG(std::shared_ptr<Variable>, variable),
+                    Q_ARG(std::shared_ptr<Variable2>, variable), Q_ARG(QUuid, impl->m_SynchronisationGroupId));
-                                          Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::dropMimeData(int index, const QMimeData* mimeData)
             {
-                if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
+                if (mimeData->hasFormat(MIME_TYPE_GRAPH))
+                {
                     impl->dropGraph(index, this);
                 }
-                else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
+                else 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)));
                     impl->dropVariables(variables, index, this);
                 }
-                else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
+                else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST))
+                {
                     auto products = sqpApp->dataSourceController().productsDataForMimeData(
                         mimeData->data(MIME_TYPE_PRODUCT_LIST));
                     impl->dropProducts(products, index, this);
                 }
-                else {
+                else
+                {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeData, unknown MIME data received.");
                 }
             }
-            void VisualizationZoneWidget::dropMimeDataOnGraph(VisualizationDragWidget *dragWidget,
+            void VisualizationZoneWidget::dropMimeDataOnGraph(
-                                                              const QMimeData *mimeData)
+                VisualizationDragWidget* dragWidget, const QMimeData* mimeData)
             {
                 auto graphWidget = qobject_cast<VisualizationGraphWidget*>(dragWidget);
-                if (!graphWidget) {
+                if (!graphWidget)
+                {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeDataOnGraph, dropping in an unknown widget, "
                               "drop aborted");
                     return;
                 }
-                if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
+                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)));
-                    for (const auto &var : variables) {
+                    for (const auto& var : variables)
+                    {
                         graphWidget->addVariable(var, graphWidget->graphRange());
                     }
                 }
-                else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
+                else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST))
+                {
                     auto products = sqpApp->dataSourceController().productsDataForMimeData(
                         mimeData->data(MIME_TYPE_PRODUCT_LIST));
                             else
                             {
                                 // -> this is pure insanity! this is a workaround to make a bad design work
-                                    QObject::connect(variable.get(), &Variable::updated,context,
+                                QObject::connect(variable.get(), &Variable2::updated, context,
-                                        [graphWidget, context, range, variable]()
+                                    [graphWidget, context, range, variable]() {
                                         graphWidget->addVariable(variable, range);
                                         delete context;
                                     });
                             }
                         },
                         Qt::QueuedConnection);
                     QMetaObject::invokeMethod(&sqpApp->dataSourceController(), "requestVariable",
                         Qt::QueuedConnection, Q_ARG(QVariantHash, productData));
                 }
-                else if (mimeData->hasFormat(MIME_TYPE_TIME_RANGE)) {
+                else if (mimeData->hasFormat(MIME_TYPE_TIME_RANGE))
+                {
                     auto range = TimeController::timeRangeForMimeData(mimeData->data(MIME_TYPE_TIME_RANGE));
                     graphWidget->setGraphRange(range, true, true);
                 }
-                else {
+                else
+                {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeDataOnGraph, unknown MIME data received.");
                 }
                 auto& helper = sqpApp->dragDropGuiController();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget*>(helper.getCurrentDragWidget());
-                if (!graphWidget) {
+                if (!graphWidget)
+                {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the dropped graph is not "
                               "found or invalid.");
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer*>(graphWidget->parentWidget());
-                if (!parentDragDropContainer) {
+                if (!parentDragDropContainer)
+                {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the parent container of "
                               "the dropped graph is not found.");
                 const auto& variables = graphWidget->variables();
-                if (parentDragDropContainer != zoneWidget->ui->dragDropContainer && !variables.empty()) {
+                if (parentDragDropContainer != zoneWidget->ui->dragDropContainer && !variables.empty())
+                {
                     // The drop didn't occur in the same zone
                     // Abort the requests for the variables (if any)
                     auto previousParentZoneWidget = graphWidget->parentZoneWidget();
                     auto nbGraph = parentDragDropContainer->countDragWidget();
-                    if (nbGraph == 1) {
+                    if (nbGraph == 1)
+                    {
                         // This is the only graph in the previous zone, close the zone
                         helper.delayedCloseWidget(previousParentZoneWidget);
                     }
-                    else {
+                    else
+                    {
                         // Close the graph
                         helper.delayedCloseWidget(graphWidget);
                     }
                     auto newGraphWidget = zoneWidget->createGraph(variables, index);
                     newGraphWidget->addSelectionZones(graphWidget->selectionZoneRanges());
                 }
-                else {
+                else
+                {
                     // The drop occurred in the same zone or the graph is empty
                     // Simple move of the graph, no variable operation associated
                     parentDragDropContainer->layout()->removeWidget(graphWidget);
-                    if (variables.empty() && parentDragDropContainer != zoneWidget->ui->dragDropContainer) {
+                    if (variables.empty() && parentDragDropContainer != zoneWidget->ui->dragDropContainer)
+                    {
                         // The graph is empty and dropped in a different zone.
                         // Take the range of the first graph in the zone (if existing).
                         auto layout = zoneWidget->ui->dragDropContainer->layout();
-                        if (layout->count() > 0) {
+                        if (layout->count() > 0)
+                        {
                             if (auto visualizationGraphWidget
-                                = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
+                                = qobject_cast<VisualizationGraphWidget*>(layout->itemAt(0)->widget()))
+                            {
                                 graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
                             }
                         }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropVariables(
-                const std::vector<std::shared_ptr<Variable> > &variables, int index,
+                const std::vector<std::shared_ptr<Variable2>>& variables, int index,
                 VisualizationZoneWidget* zoneWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
-                if (variables.size() > 1) {
+                if (variables.size() > 1)
+                {
                     return;
                 }
                 zoneWidget->createGraph(variables, index);
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
-                if (productsData.count() != 1) {
+                if (productsData.count() != 1)
+                {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropProducts, dropping multiple products, operation "
                               "aborted.");

gui/src/Visualization/operations/FindVariableOperation.cpp +9 -6

             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
-            #include <Variable/Variable.h>
+            #include <Variable/Variable2.h>
-            struct FindVariableOperation::FindVariableOperationPrivate {
+            struct FindVariableOperation::FindVariableOperationPrivate
-                explicit FindVariableOperationPrivate(std::shared_ptr<Variable> variable) : m_Variable{variable}
+                explicit FindVariableOperationPrivate(std::shared_ptr<Variable2> variable)
+                        : m_Variable { variable }
                 {
                 }
                 void visit(IVisualizationWidget* widget)
                 {
-                    if (m_Variable && widget && widget->contains(*m_Variable)) {
+                    if (m_Variable && widget && widget->contains(*m_Variable))
+                    {
                         m_Containers.insert(widget);
                     }
                 }
-                std::shared_ptr<Variable> m_Variable;          ///< Variable to find
+                std::shared_ptr<Variable2> m_Variable; ///< Variable to find
                 std::set<IVisualizationWidget*> m_Containers; ///< Containers found for the variable
             };
-            FindVariableOperation::FindVariableOperation(std::shared_ptr<Variable> variable)
+            FindVariableOperation::FindVariableOperation(std::shared_ptr<Variable2> variable)
                     : impl { spimpl::make_unique_impl<FindVariableOperationPrivate>(variable) }
             {
             }

gui/src/Visualization/operations/GenerateVariableMenuOperation.cpp +59 -43

             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
-            #include <Variable/Variable.h>
+            #include <Variable/Variable2.h>
             #include <QMenu>
             #include <QStack>
             Q_LOGGING_CATEGORY(LOG_GenerateVariableMenuOperation, "GenerateVariableMenuOperation")
-            struct GenerateVariableMenuOperation::GenerateVariableMenuOperationPrivate {
+            struct GenerateVariableMenuOperation::GenerateVariableMenuOperationPrivate
-                explicit GenerateVariableMenuOperationPrivate(
-                    QMenu *menu, std::shared_ptr<Variable> variable,
+                explicit GenerateVariableMenuOperationPrivate(QMenu* menu, std::shared_ptr<Variable2> variable,
                     std::set<IVisualizationWidget*> variableContainers)
-                        : m_Variable{variable},
+                        : m_Variable { variable }
-                          m_VariableContainers{std::move(variableContainers)},
+                        , m_VariableContainers { std::move(variableContainers) }
-                          m_PlotMenuBuilder{menu},
+                        , m_PlotMenuBuilder { menu }
-                          m_UnplotMenuBuilder{menu}
+                        , m_UnplotMenuBuilder { menu }
                 {
                 }
                 {
                     // Creates the root menu
                     if (auto plotMenu
-                        = m_PlotMenuBuilder.addMenu(QObject::tr("Plot"), QIcon{":/icones/plot.png"})) {
+                        = m_PlotMenuBuilder.addMenu(QObject::tr("Plot"), QIcon { ":/icones/plot.png" }))
-                        plotMenu->setEnabled(m_Variable && m_Variable->dataSeries() != nullptr);
+                        plotMenu->setEnabled(m_Variable && m_Variable->data() != nullptr);
                     }
                     m_UnplotMenuBuilder.addMenu(QObject::tr("Unplot"), QIcon { ":/icones/unplot.png" });
                 }
                 template <typename ActionFun>
-                void visitNodeLeavePlot(const IVisualizationWidget &container, const QString &actionName,
+                void visitNodeLeavePlot(
-                                        ActionFun actionFunction)
+                    const IVisualizationWidget& container, const QString& actionName, ActionFun actionFunction)
+                {
+                    if (isValidContainer(container))
                     {
-                    if (isValidContainer(container)) {
                         m_PlotMenuBuilder.addSeparator();
                         m_PlotMenuBuilder.addAction(actionName, actionFunction);
                     }
                 }
                 template <typename ActionFun>
-                void visitLeafPlot(const IVisualizationWidget &container, const QString &actionName,
+                void visitLeafPlot(
-                                   ActionFun actionFunction)
+                    const IVisualizationWidget& container, const QString& actionName, ActionFun actionFunction)
+                {
+                    if (isValidContainer(container))
                     {
-                    if (isValidContainer(container)) {
                         m_PlotMenuBuilder.addAction(actionName, actionFunction);
                     }
                 }
                 template <typename ActionFun>
-                void visitLeafUnplot(IVisualizationWidget *container, const QString &actionName,
+                void visitLeafUnplot(
-                                     ActionFun actionFunction)
+                    IVisualizationWidget* container, const QString& actionName, ActionFun actionFunction)
                 {
                     // If the container contains the variable, we generate 'unplot' action
-                    if (m_VariableContainers.count(container) == 1) {
+                    if (m_VariableContainers.count(container) == 1)
+                    {
                         m_UnplotMenuBuilder.addAction(actionName, actionFunction);
                     }
                 }
                     return m_Variable && m_VariableContainers.size() == 0 && container.canDrop(*m_Variable);
                 }
-                std::shared_ptr<Variable> m_Variable;
+                std::shared_ptr<Variable2> m_Variable;
                 std::set<IVisualizationWidget*> m_VariableContainers;
                 MenuBuilder m_PlotMenuBuilder; ///< Builder for the 'Plot' menu
                 MenuBuilder m_UnplotMenuBuilder; ///< Builder for the 'Unplot' menu
             };
-            GenerateVariableMenuOperation::GenerateVariableMenuOperation(
+            GenerateVariableMenuOperation::GenerateVariableMenuOperation(QMenu* menu,
-                QMenu *menu, std::shared_ptr<Variable> variable,
+                std::shared_ptr<Variable2> variable, std::set<IVisualizationWidget*> variableContainers)
-                std::set<IVisualizationWidget *> variableContainers)
                     : impl { spimpl::make_unique_impl<GenerateVariableMenuOperationPrivate>(
                           menu, variable, std::move(variableContainers)) }
             {
             void GenerateVariableMenuOperation::visitEnter(VisualizationTabWidget* tabWidget)
             {
-                if (tabWidget) {
+                if (tabWidget)
+                {
                     // 'Plot' and 'Unplot' menus
                     impl->visitNodeEnter(*tabWidget);
                 }
-                else {
+                else
+                {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                         "Can't visit enter VisualizationTabWidget : the widget is null");
                 }
             void GenerateVariableMenuOperation::visitLeave(VisualizationTabWidget* tabWidget)
             {
-                if (tabWidget) {
+                if (tabWidget)
+                {
                     // 'Plot' menu
                     impl->visitNodeLeavePlot(*tabWidget, QObject::tr("Open in a new zone"),
-                                             [ varW = std::weak_ptr<Variable>{impl->m_Variable}, tabWidget ]() {
+                        [varW = std::weak_ptr<Variable2> { impl->m_Variable }, tabWidget]() {
-                                                 if (auto var = varW.lock()) {
+                            if (auto var = varW.lock())
+                            {
                                 tabWidget->createZone(var);
                             }
                         });
                     // 'Unplot' menu
                     impl->visitNodeLeaveUnplot();
                 }
-                else {
+                else
+                {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                         "Can't visit leave VisualizationTabWidget : the widget is null");
                 }
             void GenerateVariableMenuOperation::visitEnter(VisualizationZoneWidget* zoneWidget)
             {
-                if (zoneWidget) {
+                if (zoneWidget)
+                {
                     // 'Plot' and 'Unplot' menus
                     impl->visitNodeEnter(*zoneWidget);
                 }
-                else {
+                else
+                {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                         "Can't visit enter VisualizationZoneWidget : the widget is null");
                 }
             void GenerateVariableMenuOperation::visitLeave(VisualizationZoneWidget* zoneWidget)
             {
-                if (zoneWidget) {
+                if (zoneWidget)
+                {
                     // 'Plot' menu
-                    impl->visitNodeLeavePlot(
+                    impl->visitNodeLeavePlot(*zoneWidget, QObject::tr("Open in a new graph"),
-                        *zoneWidget, QObject::tr("Open in a new graph"),
+                        [varW = std::weak_ptr<Variable2> { impl->m_Variable }, zoneWidget]() {
-                        [ varW = std::weak_ptr<Variable>{impl->m_Variable}, zoneWidget ]() {
+                            if (auto var = varW.lock())
-                            if (auto var = varW.lock()) {
                                 zoneWidget->createGraph(var);
                             }
                         });
                     // 'Unplot' menu
                     impl->visitNodeLeaveUnplot();
                 }
-                else {
+                else
+                {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                         "Can't visit leave VisualizationZoneWidget : the widget is null");
                 }
             void GenerateVariableMenuOperation::visit(VisualizationGraphWidget* graphWidget)
             {
-                if (graphWidget) {
+                if (graphWidget)
+                {
                     // 'Plot' menu
                     impl->visitLeafPlot(*graphWidget, QObject::tr("Open in %1").arg(graphWidget->name()),
-                                        [ varW = std::weak_ptr<Variable>{impl->m_Variable}, graphWidget ]() {
+                        [varW = std::weak_ptr<Variable2> { impl->m_Variable }, graphWidget]() {
-                                            if (auto var = varW.lock()) {
+                            if (auto var = varW.lock())
+                            {
                                 graphWidget->addVariable(var, graphWidget->graphRange());
                             }
                         });
                     // 'Unplot' menu
                     impl->visitLeafUnplot(graphWidget, QObject::tr("Remove from %1").arg(graphWidget->name()),
-                                          [ varW = std::weak_ptr<Variable>{impl->m_Variable}, graphWidget ]() {
+                        [varW = std::weak_ptr<Variable2> { impl->m_Variable }, graphWidget]() {
-                                              if (auto var = varW.lock()) {
+                            if (auto var = varW.lock())
+                            {
                                 graphWidget->removeVariable(var);
                             }
                         });
                 }
-                else {
+                else
+                {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                         "Can't visit VisualizationGraphWidget : the widget is null");
                 }

gui/src/Visualization/operations/RemoveVariableOperation.cpp +12 -8

             #include "Visualization/operations/RemoveVariableOperation.h"
             #include "Visualization/VisualizationGraphWidget.h"
-            #include <Variable/Variable.h>
+            #include <Variable/Variable2.h>
             Q_LOGGING_CATEGORY(LOG_RemoveVariableOperation, "RemoveVariableOperation")
-            struct RemoveVariableOperation::RemoveVariableOperationPrivate {
+            struct RemoveVariableOperation::RemoveVariableOperationPrivate
-                explicit RemoveVariableOperationPrivate(std::shared_ptr<Variable> variable)
+                explicit RemoveVariableOperationPrivate(std::shared_ptr<Variable2> variable)
                         : m_Variable(variable)
                 {
                 }
-                std::shared_ptr<Variable> m_Variable;
+                std::shared_ptr<Variable2> m_Variable;
             };
-            RemoveVariableOperation::RemoveVariableOperation(std::shared_ptr<Variable> variable)
+            RemoveVariableOperation::RemoveVariableOperation(std::shared_ptr<Variable2> variable)
                     : impl { spimpl::make_unique_impl<RemoveVariableOperationPrivate>(variable) }
             {
             }
             void RemoveVariableOperation::visit(VisualizationGraphWidget* graphWidget)
             {
-                if (graphWidget) {
+                if (graphWidget)
+                {
                     // If the widget contains the variable, removes it
-                    if (impl->m_Variable && graphWidget->contains(*impl->m_Variable)) {
+                    if (impl->m_Variable && graphWidget->contains(*impl->m_Variable))
+                    {
                         graphWidget->removeVariable(impl->m_Variable);
                     }
                 }
-                else {
+                else
+                {
                     qCCritical(LOG_RemoveVariableOperation(),
                         "Can't visit VisualizationGraphWidget : the widget is null");
                 }

gui/src/Visualization/operations/RescaleAxeOperation.cpp +15 -9

             Q_LOGGING_CATEGORY(LOG_RescaleAxeOperation, "RescaleAxeOperation")
-            struct RescaleAxeOperation::RescaleAxeOperationPrivate {
+            struct RescaleAxeOperation::RescaleAxeOperationPrivate
-                explicit RescaleAxeOperationPrivate(std::shared_ptr<Variable> variable, const DateTimeRange &range)
+                explicit RescaleAxeOperationPrivate(
+                    std::shared_ptr<Variable2> variable, const DateTimeRange& range)
                         : m_Variable { variable }, m_Range { range }
                 {
                 }
-                std::shared_ptr<Variable> m_Variable;
+                std::shared_ptr<Variable2> m_Variable;
                 DateTimeRange m_Range;
             };
-            RescaleAxeOperation::RescaleAxeOperation(std::shared_ptr<Variable> variable, const DateTimeRange &range)
+            RescaleAxeOperation::RescaleAxeOperation(
+                std::shared_ptr<Variable2> variable, const DateTimeRange& range)
                     : impl { spimpl::make_unique_impl<RescaleAxeOperationPrivate>(variable, range) }
             {
             }
             void RescaleAxeOperation::visit(VisualizationGraphWidget* graphWidget)
             {
-                if (graphWidget) {
+                if (graphWidget)
+                {
                     // If the widget contains the variable, rescale it
-                    if (impl->m_Variable && graphWidget->contains(*impl->m_Variable)) {
+                    if (impl->m_Variable && graphWidget->contains(*impl->m_Variable))
+                    {
                         // During rescale, acquisition for the graph is disabled but synchronization is still
                         // enabled
                         graphWidget->setFlags(GraphFlag::EnableSynchronization);
                         graphWidget->setFlags(GraphFlag::EnableAll);
                     }
                 }
-                else {
+                else
-                    qCCritical(LOG_RescaleAxeOperation(),
-                               "Can't visit VisualizationGraphWidget : the widget is null");
+                    qCCritical(
+                        LOG_RescaleAxeOperation(), "Can't visit VisualizationGraphWidget : the widget is null");
                 }
             }

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

             ALIAS_TEMPLATE_FUNCTION(isReady, static_cast<SqpApplication*>(qApp)->variableController().isReady)
-            void waitForVar(std::shared_ptr<Variable> var)
+            void waitForVar(std::shared_ptr<Variable2> var)
             {
                 while (!isReady(var))
                     QCoreApplication::processEvents();

gui/tests/multiple_sync_graph/main.cpp +18 -16

-            #include <QtTest>
+            #include <QMainWindow>
             #include <QObject>
-            #include <QString>
             #include <QScreen>
-            #include <QMainWindow>
+            #include <QString>
             #include <QWheelEvent>
+            #include <QtTest>
             #include <qcustomplot.h>
+            #include <Common/cpp_utils.h>
             #include <SqpApplication.h>
             #include <Variable/VariableController2.h>
-            #include <Common/cpp_utils.h>
-            #include <Visualization/VisualizationZoneWidget.h>
-            #include <Visualization/VisualizationGraphWidget.h>
-            #include <TestProviders.h>
             #include <GUITestUtils.h>
+            #include <TestProviders.h>
+            #include <Visualization/VisualizationGraphWidget.h>
+            #include <Visualization/VisualizationZoneWidget.h>
             template <int GraphCount = 2>
-            std::tuple< std::unique_ptr<VisualizationZoneWidget>,
+            std::tuple<std::unique_ptr<VisualizationZoneWidget>, std::vector<std::shared_ptr<Variable2>>,
-                        std::vector<std::shared_ptr<Variable>>,
+                std::vector<VisualizationGraphWidget*>, DateTimeRange>
-                        std::vector<VisualizationGraphWidget*>,
-                        DateTimeRange>
             build_multi_graph_test()
             {
                 auto w = std::make_unique<VisualizationZoneWidget>();
                 auto provider = std::make_shared<SimpleRange<10>>();
-                auto range = DateTimeRange::fromDateTime(QDate(2018, 8, 7), QTime(14, 00), QDate(2018, 8, 7),QTime(16, 00));
+                auto range = DateTimeRange::fromDateTime(
-                std::vector<std::shared_ptr<Variable>> variables;
+                    QDate(2018, 8, 7), QTime(14, 00), QDate(2018, 8, 7), QTime(16, 00));
+                std::vector<std::shared_ptr<Variable2>> variables;
                 std::vector<VisualizationGraphWidget*> graphs;
                 for (auto i = 0; i < GraphCount; i++)
                 {
             }
-            class A_MultipleSyncGraphs : public QObject {
+            class A_MultipleSyncGraphs : public QObject
+            {
                 Q_OBJECT
             public:
                 explicit A_MultipleSyncGraphs(QObject* parent = Q_NULLPTR) : QObject(parent) {}
                     auto var = variables.front();
                     auto graph = graphs.front();
                     QVERIFY(prepare_gui_test(w.get()));
-                    for (auto i = 0; i < 100; i++) {
+                    for (auto i = 0; i < 100; i++)
+                    {
                         scroll_graph(graph, -200);
                         waitForVar(var);
                     }
                     auto var = variables.front();
                     auto graph = graphs.front();
                     QVERIFY(prepare_gui_test(w.get()));
-                    for (auto i = 0; i < 100; i++) {
+                    for (auto i = 0; i < 100; i++)
+                    {
                         scroll_graph(graph, 200);
                         waitForVar(var);
                     }

gui/tests/simple_graph/main.cpp +22 -17

-            #include <QtTest>
+            #include <QMainWindow>
             #include <QObject>
-            #include <QString>
             #include <QScreen>
-            #include <QMainWindow>
+            #include <QString>
             #include <QWheelEvent>
+            #include <QtTest>
             #include <qcustomplot.h>
+            #include <Common/cpp_utils.h>
             #include <SqpApplication.h>
             #include <Variable/VariableController2.h>
-            #include <Common/cpp_utils.h>
-            #include <Visualization/VisualizationGraphWidget.h>
-            #include <TestProviders.h>
             #include <GUITestUtils.h>
-            #include <Variable/Variable.h>
+            #include <TestProviders.h>
+            #include <Variable/Variable2.h>
+            #include <Visualization/VisualizationGraphWidget.h>
-            std::tuple< std::unique_ptr<VisualizationGraphWidget>,
+            std::tuple<std::unique_ptr<VisualizationGraphWidget>, std::shared_ptr<Variable2>, DateTimeRange>
-                        std::shared_ptr<Variable>,
-                        DateTimeRange >
             build_simple_graph_test()
             {
                 auto w = std::make_unique<VisualizationGraphWidget>();
                 auto provider = std::make_shared<SimpleRange<10>>();
-                auto range = DateTimeRange::fromDateTime(QDate(2018, 8, 7), QTime(14, 00), QDate(2018, 8, 7),QTime(16, 00));
+                auto range = DateTimeRange::fromDateTime(
-                auto var = static_cast<SqpApplication *>(qApp)->variableController().createVariable("V1", {{"", "scalar"}}, provider, range);
+                    QDate(2018, 8, 7), QTime(14, 00), QDate(2018, 8, 7), QTime(16, 00));
-                while (!isReady(var)) QCoreApplication::processEvents();
+                auto var = static_cast<SqpApplication*>(qApp)->variableController().createVariable(
+                    "V1", { { "", "scalar" } }, provider, range);
+                while (!isReady(var))
+                    QCoreApplication::processEvents();
                 w->addVariable(var, range);
-                while (!isReady(var)) QCoreApplication::processEvents();
+                while (!isReady(var))
+                    QCoreApplication::processEvents();
                 return { std::move(w), var, range };
             }
-            class A_SimpleGraph : public QObject {
+            class A_SimpleGraph : public QObject
+            {
                 Q_OBJECT
             public:
                 explicit A_SimpleGraph(QObject* parent = Q_NULLPTR) : QObject(parent) {}
                 {
                     auto [w, var, range] = build_simple_graph_test();
                     QVERIFY(prepare_gui_test(w.get()));
-                    for (auto i = 0; i < 100; i++) {
+                    for (auto i = 0; i < 100; i++)
+                    {
                         scroll_graph(w.get(), 200);
                         waitForVar(var);
                     }
                 {
                     auto [w, var, range] = build_simple_graph_test();
                     QVERIFY(prepare_gui_test(w.get()));
-                    for (auto i = 0; i < 100; i++) {
+                    for (auto i = 0; i < 100; i++)
+                    {
                         scroll_graph(w.get(), -200);
                         waitForVar(var);
                     }

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