From 870a641b85282b6b387a3a04371d72505afafefa 2017-06-30 12:05:23
From: perrinel <mperrinel@itlink.fr>
Date: 2017-06-30 12:05:23
Subject: [PATCH] Merge pull request #169 from SCIQLOP-Initialisation develop

 Develop

---

diff --git a/app/src/MainWindow.cpp b/app/src/MainWindow.cpp
index 3e6f828..1c1c4ca 100644
--- a/app/src/MainWindow.cpp
+++ b/app/src/MainWindow.cpp
@@ -189,9 +189,11 @@ MainWindow::MainWindow(QWidget *parent)
     // potentially attach a menu to the variable's menu to do so before this menu is displayed.
     // The order of connections is also important, since it determines the order in which each
     // widget will attach its menu
-    connect(m_Ui->variableInspectorWidget,
-            SIGNAL(tableMenuAboutToBeDisplayed(QMenu *, std::shared_ptr<Variable>)), m_Ui->view,
-            SLOT(attachVariableMenu(QMenu *, std::shared_ptr<Variable>)), Qt::DirectConnection);
+    connect(
+        m_Ui->variableInspectorWidget,
+        SIGNAL(tableMenuAboutToBeDisplayed(QMenu *, const QVector<std::shared_ptr<Variable> > &)),
+        m_Ui->view, SLOT(attachVariableMenu(QMenu *, const QVector<std::shared_ptr<Variable> > &)),
+        Qt::DirectConnection);
 
     /*    QLopGUI::registerMenuBar(menuBar());
         this->setWindowIcon(QIcon(":/sciqlopLOGO.svg"));
diff --git a/core/include/Data/ArrayData.h b/core/include/Data/ArrayData.h
index 5be205f..c466119 100644
--- a/core/include/Data/ArrayData.h
+++ b/core/include/Data/ArrayData.h
@@ -44,9 +44,9 @@ public:
      * @remarks this method is only available for a unidimensional ArrayData
      */
     template <int D = Dim, typename = std::enable_if_t<D == 1> >
-    QVector<double> data() const noexcept
+    const QVector<double> &data() const noexcept
     {
-        return m_Data.at(0);
+        return m_Data[0];
     }
 
     /**
@@ -61,10 +61,10 @@ public:
 
     // TODO Comment
     template <int D = Dim, typename = std::enable_if_t<D == 1> >
-    void merge(ArrayData<1> *arrayData)
+    void merge(const ArrayData<1> &arrayData)
     {
         if (!m_Data.empty()) {
-            m_Data[0] += arrayData->data();
+            m_Data[0] += arrayData.data();
         }
     }
 
diff --git a/core/include/Data/DataSeries.h b/core/include/Data/DataSeries.h
index 31825bd..46ee991 100644
--- a/core/include/Data/DataSeries.h
+++ b/core/include/Data/DataSeries.h
@@ -40,8 +40,8 @@ public:
     void merge(IDataSeries *dataSeries) override
     {
         if (auto dimDataSeries = dynamic_cast<DataSeries<Dim> *>(dataSeries)) {
-            m_XAxisData->merge(dimDataSeries->xAxisData().get());
-            m_ValuesData->merge(dimDataSeries->valuesData().get());
+            m_XAxisData->merge(*dimDataSeries->xAxisData());
+            m_ValuesData->merge(*dimDataSeries->valuesData());
         }
         else {
             qCWarning(LOG_DataSeries())
diff --git a/core/include/Data/SqpDateTime.h b/core/include/Data/SqpDateTime.h
index dc43dc1..c0f73c1 100644
--- a/core/include/Data/SqpDateTime.h
+++ b/core/include/Data/SqpDateTime.h
@@ -2,6 +2,10 @@
 #define SCIQLOP_SQPDATETIME_H
 
 #include <QObject>
+
+#include <QDateTime>
+#include <QDebug>
+
 /**
  * @brief The SqpDateTime struct holds the information of time parameters
  */
@@ -22,6 +26,16 @@ struct SqpDateTime {
     }
 };
 
+inline QDebug operator<<(QDebug d, SqpDateTime obj)
+{
+    auto tendDateTimeStart = QDateTime::fromMSecsSinceEpoch(obj.m_TStart * 1000);
+    auto tendDateTimeEnd = QDateTime::fromMSecsSinceEpoch(obj.m_TEnd * 1000);
+
+    //        QDebug << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
+    d << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
+    return d;
+}
+
 // Required for using shared_ptr in signals/slots
 Q_DECLARE_METATYPE(SqpDateTime)
 
diff --git a/core/include/Variable/Variable.h b/core/include/Variable/Variable.h
index c6688c0..f654f78 100644
--- a/core/include/Variable/Variable.h
+++ b/core/include/Variable/Variable.h
@@ -42,7 +42,7 @@ public slots:
     void onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
 
 signals:
-    void dataCacheUpdated();
+    void updated();
 
 
 private:
diff --git a/core/include/Variable/VariableCacheController.h b/core/include/Variable/VariableCacheController.h
index 2fd48b2..dd7b988 100644
--- a/core/include/Variable/VariableCacheController.h
+++ b/core/include/Variable/VariableCacheController.h
@@ -5,10 +5,15 @@
 
 #include <Data/SqpDateTime.h>
 
+#include <QLoggingCategory>
+
 #include <Common/spimpl.h>
 
 class Variable;
 
+Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheController)
+
+
 /// This class aims to store in the cache all of the dateTime already requested to the variable.
 class VariableCacheController : public QObject {
     Q_OBJECT
@@ -25,6 +30,8 @@ public:
 
     QVector<SqpDateTime> dateCacheList(std::shared_ptr<Variable> variable) const noexcept;
 
+    void displayCache(std::shared_ptr<Variable> variable);
+
 private:
     class VariableCacheControllerPrivate;
     spimpl::unique_impl_ptr<VariableCacheControllerPrivate> impl;
diff --git a/core/include/Variable/VariableController.h b/core/include/Variable/VariableController.h
index 603c1e9..2da1749 100644
--- a/core/include/Variable/VariableController.h
+++ b/core/include/Variable/VariableController.h
@@ -30,14 +30,13 @@ public:
     void setTimeController(TimeController *timeController) noexcept;
 
 
-    /// Request the data loading of the variable whithin dateTime
-    void requestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
-
 signals:
     /// Signal emitted when a variable has been created
     void variableCreated(std::shared_ptr<Variable> variable);
 
 public slots:
+    /// Request the data loading of the variable whithin dateTime
+    void onRequestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
     /**
      * Creates a new variable and adds it to the model
      * @param name the name of the new variable
diff --git a/core/src/Variable/Variable.cpp b/core/src/Variable/Variable.cpp
index ff099c6..899ca31 100644
--- a/core/src/Variable/Variable.cpp
+++ b/core/src/Variable/Variable.cpp
@@ -67,7 +67,7 @@ void Variable::onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
     if (impl->m_DataSeries) {
         impl->m_DataSeries->merge(dataSeries.get());
 
-        emit dataCacheUpdated();
+        emit updated();
     }
 }
 
diff --git a/core/src/Variable/VariableCacheController.cpp b/core/src/Variable/VariableCacheController.cpp
index 34cb514..f151b4d 100644
--- a/core/src/Variable/VariableCacheController.cpp
+++ b/core/src/Variable/VariableCacheController.cpp
@@ -3,6 +3,8 @@
 #include "Variable/Variable.h"
 #include <unordered_map>
 
+Q_LOGGING_CATEGORY(LOG_VariableCacheController, "VariableCacheController")
+
 struct VariableCacheController::VariableCacheControllerPrivate {
 
     std::unordered_map<std::shared_ptr<Variable>, QVector<SqpDateTime> >
@@ -156,15 +158,26 @@ void VariableCacheController::VariableCacheControllerPrivate::addInCacheDataBySt
         // ts localised between to interval: let's localized te
         addInCacheDataByEnd(dateTime, dateTimeList, notInCache, cacheIndex, currentTStart);
     }
-    else if (dateTime.m_TStart < currentDateTimeI.m_TEnd) {
-        // ts not localised before the current interval: we need to look at the next interval
-        // We can assume now current tstart is the last interval tend, because data between them are
-        // in the cache
-        addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex,
-                              currentDateTimeI.m_TEnd);
+    else if (currentTStart < currentDateTimeI.m_TEnd) {
+        if (dateTime.m_TEnd > currentDateTimeI.m_TEnd) {
+            // ts not localised before the current interval: we need to look at the next interval
+            // We can assume now current tstart is the last interval tend, because data between them
+            // are
+            // in the cache
+            addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex,
+                                  currentDateTimeI.m_TEnd);
+        }
     }
     else {
         // ts not localised before the current interval: we need to look at the next interval
         addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex, currentTStart);
     }
 }
+
+
+void VariableCacheController::displayCache(std::shared_ptr<Variable> variable)
+{
+    auto variableDateTimeList = impl->m_VariableToSqpDateTimeListMap.at(variable);
+    qCInfo(LOG_VariableCacheController()) << tr("VariableCacheController::displayCache")
+                                          << variableDateTimeList;
+}
diff --git a/core/src/Variable/VariableController.cpp b/core/src/Variable/VariableController.cpp
index 90d1368..355cee0 100644
--- a/core/src/Variable/VariableController.cpp
+++ b/core/src/Variable/VariableController.cpp
@@ -9,7 +9,6 @@
 #include <Time/TimeController.h>
 
 #include <QDateTime>
-#include <QElapsedTimer>
 #include <QMutex>
 #include <QThread>
 
@@ -112,33 +111,27 @@ void VariableController::createVariable(const QString &name,
 }
 
 
-void VariableController::requestDataLoading(std::shared_ptr<Variable> variable,
-                                            const SqpDateTime &dateTime)
+void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
+                                              const SqpDateTime &dateTime)
 {
     // we want to load data of the variable for the dateTime.
     // First we check if the cache contains some of them.
     // For the other, we ask the provider to give them.
     if (variable) {
 
-        QElapsedTimer timer;
-        timer.start();
-        qCInfo(LOG_VariableController()) << "TORM: The slow s0 operation took" << timer.elapsed()
-                                         << "milliseconds";
         auto dateTimeListNotInCache
             = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
-        qCInfo(LOG_VariableController()) << "TORM: The slow s1 operation took" << timer.elapsed()
-                                         << "milliseconds";
 
-        // Ask the provider for each data on the dateTimeListNotInCache
-        impl->m_VariableToProviderMap.at(variable)->requestDataLoading(dateTimeListNotInCache);
-
-        qCInfo(LOG_VariableController()) << "TORM: The slow s2 operation took" << timer.elapsed()
-                                         << "milliseconds";
-
-        // store in cache
-        impl->m_VariableCacheController->addDateTime(variable, dateTime);
-        qCInfo(LOG_VariableController()) << "TORM: The slow s3 operation took" << timer.elapsed()
-                                         << "milliseconds";
+        if (!dateTimeListNotInCache.empty()) {
+            // Ask the provider for each data on the dateTimeListNotInCache
+            impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
+                std::move(dateTimeListNotInCache));
+            // store in cache
+            impl->m_VariableCacheController->addDateTime(variable, dateTime);
+        }
+        else {
+            emit variable->updated();
+        }
     }
     else {
         qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null");
diff --git a/core/tests/Variable/TestVariableCacheController.cpp b/core/tests/Variable/TestVariableCacheController.cpp
index 37e357d..6a6600d 100644
--- a/core/tests/Variable/TestVariableCacheController.cpp
+++ b/core/tests/Variable/TestVariableCacheController.cpp
@@ -241,6 +241,16 @@ void TestVariableCacheController::testProvideNotInCacheDateTimeList()
     notInCacheSqp = notInCach.at(1);
     QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
     QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+
+
+    // 12th case ts0 < ts < te0
+    ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 10, 0}};
+    te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 50, 0}};
+    sqp = SqpDateTime{static_cast<double>(ts.toMSecsSinceEpoch()),
+                      static_cast<double>(te.toMSecsSinceEpoch())};
+
+    notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
+    QCOMPARE(notInCach.size(), 0);
 }
 
 
diff --git a/gui/include/Variable/VariableInspectorWidget.h b/gui/include/Variable/VariableInspectorWidget.h
index cc6faee..56fa387 100644
--- a/gui/include/Variable/VariableInspectorWidget.h
+++ b/gui/include/Variable/VariableInspectorWidget.h
@@ -29,14 +29,15 @@ public:
 
 signals:
     /**
-     * Signal emitted before a menu concerning a variable is displayed. It is used for other widgets
+     * Signal emitted before a menu concerning variables is displayed. It is used for other widgets
      * to complete the menu.
      * @param tableMenu the menu to be completed
-     * @param variable the variable concerned by the menu
+     * @param variables the variables concerned by the menu
      * @remarks To make the dynamic addition of menus work, the connections to this signal must be
      * in Qt :: DirectConnection
      */
-    void tableMenuAboutToBeDisplayed(QMenu *tableMenu, std::shared_ptr<Variable> variable);
+    void tableMenuAboutToBeDisplayed(QMenu *tableMenu,
+                                     const QVector<std::shared_ptr<Variable> > &variables);
 
 private:
     Ui::VariableInspectorWidget *ui;
diff --git a/gui/include/Variable/VariableMenuHeaderWidget.h b/gui/include/Variable/VariableMenuHeaderWidget.h
new file mode 100644
index 0000000..009b0c5
--- /dev/null
+++ b/gui/include/Variable/VariableMenuHeaderWidget.h
@@ -0,0 +1,37 @@
+#ifndef SCIQLOP_VARIABLEMENUHEADERWIDGET_H
+#define SCIQLOP_VARIABLEMENUHEADERWIDGET_H
+
+#include <QLoggingCategory>
+#include <QWidget>
+
+#include <memory>
+
+namespace Ui {
+class VariableMenuHeaderWidget;
+} // Ui
+
+class Variable;
+
+Q_DECLARE_LOGGING_CATEGORY(LOG_VariableMenuHeaderWidget)
+
+/**
+ * @brief The VariableMenuHeaderWidget class represents the widget used as a header of a menu in the
+ * variable inspector
+ * @sa VariableInspectorWidget
+ */
+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,
+                                      QWidget *parent = 0);
+    virtual ~VariableMenuHeaderWidget() noexcept;
+
+private:
+    Ui::VariableMenuHeaderWidget *ui;
+};
+
+#endif // SCIQLOP_VARIABLEMENUHEADERWIDGET_H
diff --git a/gui/include/Visualization/VisualizationGraphWidget.h b/gui/include/Visualization/VisualizationGraphWidget.h
index 15b93e9..5e0d037 100644
--- a/gui/include/Visualization/VisualizationGraphWidget.h
+++ b/gui/include/Visualization/VisualizationGraphWidget.h
@@ -13,6 +13,7 @@
 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphWidget)
 
 class QCPRange;
+class SqpDateTime;
 class Variable;
 
 namespace Ui {
@@ -37,6 +38,9 @@ public:
 
     void updateDisplay(std::shared_ptr<Variable> variable);
 
+signals:
+    void requestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
+
 
 private:
     Ui::VisualizationGraphWidget *ui;
diff --git a/gui/include/Visualization/VisualizationWidget.h b/gui/include/Visualization/VisualizationWidget.h
index 2321bbd..874203d 100644
--- a/gui/include/Visualization/VisualizationWidget.h
+++ b/gui/include/Visualization/VisualizationWidget.h
@@ -30,11 +30,12 @@ public:
 
 public slots:
     /**
-     * Attaches to a menu the menu relating to the visualization of a variable
+     * Attaches to a menu the menu relative to the visualization of variables
      * @param menu the parent menu of the generated menu
-     * @param variable the variable for which to generate the menu
+     * @param variables the variables for which to generate the menu
      */
-    void attachVariableMenu(QMenu *menu, std::shared_ptr<Variable> variable) noexcept;
+    void attachVariableMenu(QMenu *menu,
+                            const QVector<std::shared_ptr<Variable> > &variables) noexcept;
 
 private:
     Ui::VisualizationWidget *ui;
diff --git a/gui/resources/icones/delete.png b/gui/resources/icones/delete.png
new file mode 100644
index 0000000000000000000000000000000000000000..a9e5409ad549c425690339c69d04bc5a7bcdf478
GIT binary patch
literal 834
zc%17D@N?(olHy`uVBq!ia0vp^4Is?H1|$#LC7uRSEX7WqAsj$Z!;#Vf<Z~8yL>4nJ
za0`PlBg3pY5)2GXPdr^5Ln`LHy%XyvZ79<AaQ$1pT@91wANn`F(M4sO!-IX%3&aap
zl1zHue(b63yYGG~HuTQVds-7bCorG@2bTS2|9-z$`8(}P{^Rw+Q*Xa6pY%oJ<=4N3
z6H9Wcl;Y3Lirepen)&Iknu_X}uVQTbzK37xUUvQc!lw(1?qpU~D0vv0@3W1G*&TiM
zKXXUIy-PpV7kx1)5EOjkA^Csb&6iv<s<z!6K}&l6tGrxx@n_du7Z&fJ<MvxD?^U@N
z=>PfA#<8qT^1i^q_J_yJH3e<7%UBNg<-7GI{P=jbL(t%#xU%bkAI5GS4Ijnlh?+AU
z^A|B>I(A+}lj)egh$7Rmcumu$;?>M`%^$TtN-#bSe+HDe-_gz?QJ-w<e&C0-W%f^}
z_p*$S->+HD5p?`{v%%D_0*sH%uNg5Nd+*ZCA+g_BQ*h4;KbD^RD{Yk${+!E|WPEJB
z(Uqm=z0X;Wpkw>HKJK1ubSDVNzcY(N!oFh?keD$CNUXR5BsNR|5<4ydi3xXr#DXgv
zZBqZ!Uo)4ya(~UdVBMtU4fE_9TX?efajGyq&-x?b!Q!`c-=T8fAI2^Ze9oQTtuE-O
zp}PL9u%keB-W!3&V$*l81RH}*^Ir-z8b{wbug;{tt;U#Luq3a){F8v=@^3Zw?F37f
z9c?%3SRkxxztNec_v?p3U8RgA?H_ps->g{<B9|Nok~wRhgUBO?fx)Zw*<_z$lb6kZ
zHb13^lb?YiT&@!L1ss=oJeF4S5Gky2X5m)q&+kY$#sL)gk+cM;bB}akjd2Z&a({kX
zZ^K7>9&yIU{=CABkI!?<Gd|YmmUcX~KEM9bjmNXEa8&L3yZ1$4&wORoruMYur%Tk2
z=}#1D>|Wj!ZCJN*DF@$KziBU(j_I3<AFMs?{M72jTg%s<ALd8NotU{8n2P)_3yWHH
l{{NaS^YqQ`deoG8;aI&4|N6Pji_E`*xSp<lF6*2UngCGTW4izV

literal 0
Hc$@<O00001

diff --git a/gui/resources/sqpguiresources.qrc b/gui/resources/sqpguiresources.qrc
index 93bbd78..ff211a8 100644
--- a/gui/resources/sqpguiresources.qrc
+++ b/gui/resources/sqpguiresources.qrc
@@ -1,5 +1,6 @@
 <RCC>
     <qresource prefix="/">
+		<file>icones/delete.png</file>
         <file>icones/openInspector.png</file>
         <file>icones/next.png</file>
         <file>icones/previous.png</file>
diff --git a/gui/src/Variable/VariableInspectorWidget.cpp b/gui/src/Variable/VariableInspectorWidget.cpp
index b83cd4d..14df440 100644
--- a/gui/src/Variable/VariableInspectorWidget.cpp
+++ b/gui/src/Variable/VariableInspectorWidget.cpp
@@ -1,10 +1,12 @@
 #include <Variable/VariableController.h>
 #include <Variable/VariableInspectorWidget.h>
+#include <Variable/VariableMenuHeaderWidget.h>
 #include <Variable/VariableModel.h>
 
 #include <ui_VariableInspectorWidget.h>
 
 #include <QSortFilterProxyModel>
+#include <QWidgetAction>
 
 #include <SqpApplication.h>
 
@@ -29,6 +31,10 @@ VariableInspectorWidget::VariableInspectorWidget(QWidget *parent)
             i, model->headerData(i, Qt::Horizontal, Qt::SizeHintRole).toSize().width());
     }
 
+    // Sets selection options
+    ui->tableView->setSelectionBehavior(QTableView::SelectRows);
+    ui->tableView->setSelectionMode(QTableView::ExtendedSelection);
+
     // Connection to show a menu when right clicking on the tree
     ui->tableView->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(ui->tableView, &QTableView::customContextMenuRequested, this,
@@ -42,24 +48,41 @@ VariableInspectorWidget::~VariableInspectorWidget()
 
 void VariableInspectorWidget::onTableMenuRequested(const QPoint &pos) noexcept
 {
-    auto selectedIndex = ui->tableView->indexAt(pos);
-    if (selectedIndex.isValid()) {
-        // Gets the model to retrieve the underlying selected variable
-        auto model = sqpApp->variableController().variableModel();
-        if (auto selectedVariable = model->variable(selectedIndex.row())) {
-            QMenu tableMenu{};
-
-            // Emit a signal so that potential receivers can populate the menu before displaying it
-            emit tableMenuAboutToBeDisplayed(&tableMenu, selectedVariable);
-
-            if (!tableMenu.isEmpty()) {
-                tableMenu.exec(mapToGlobal(pos));
-            }
+    auto selectedRows = ui->tableView->selectionModel()->selectedRows();
+
+    // Gets the model to retrieve the underlying selected variables
+    auto model = sqpApp->variableController().variableModel();
+    auto selectedVariables = QVector<std::shared_ptr<Variable> >{};
+    for (const auto &selectedRow : qAsConst(selectedRows)) {
+        if (auto selectedVariable = model->variable(selectedRow.row())) {
+            selectedVariables.push_back(selectedVariable);
         }
     }
-    else {
-        qCCritical(LOG_VariableInspectorWidget())
-            << tr("Can't display menu : invalid index (%1;%2)")
-                   .arg(selectedIndex.row(), selectedIndex.column());
+
+    QMenu tableMenu{};
+
+    // Emits a signal so that potential receivers can populate the menu before displaying it
+    emit tableMenuAboutToBeDisplayed(&tableMenu, selectedVariables);
+
+    // Adds menu-specific actions
+    if (!selectedVariables.isEmpty()) {
+        // 'Delete' action
+        auto deleteFun = []() {
+            /// @todo ALX : call variable deletion
+        };
+
+        tableMenu.addSeparator();
+        tableMenu.addAction(QIcon{":/icones/delete.png"}, tr("Delete"), deleteFun);
+    }
+
+    if (!tableMenu.isEmpty()) {
+        // Generates menu header (inserted before first action)
+        auto firstAction = tableMenu.actions().first();
+        auto headerAction = new QWidgetAction{&tableMenu};
+        headerAction->setDefaultWidget(new VariableMenuHeaderWidget{selectedVariables, &tableMenu});
+        tableMenu.insertAction(firstAction, headerAction);
+
+        // Displays menu
+        tableMenu.exec(mapToGlobal(pos));
     }
 }
diff --git a/gui/src/Variable/VariableMenuHeaderWidget.cpp b/gui/src/Variable/VariableMenuHeaderWidget.cpp
new file mode 100644
index 0000000..7baf824
--- /dev/null
+++ b/gui/src/Variable/VariableMenuHeaderWidget.cpp
@@ -0,0 +1,38 @@
+#include "Variable/VariableMenuHeaderWidget.h"
+#include "Variable/Variable.h"
+
+#include <ui_VariableMenuHeaderWidget.h>
+
+Q_LOGGING_CATEGORY(LOG_VariableMenuHeaderWidget, "VariableMenuHeaderWidget")
+
+VariableMenuHeaderWidget::VariableMenuHeaderWidget(
+    const QVector<std::shared_ptr<Variable> > &variables, QWidget *parent)
+        : QWidget{parent}, ui{new Ui::VariableMenuHeaderWidget}
+{
+    ui->setupUi(this);
+
+    // Generates label according to the state of the variables. The label contains :
+    // - 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 (auto variable = variables.first()) {
+            ui->label->setText(variable->name());
+        }
+        else {
+            qCCritical(LOG_VariableMenuHeaderWidget())
+                << tr("Can't get the name of the variable : variable is null");
+        }
+    }
+    else if (nbVariables > 1) {
+        ui->label->setText(tr("%1 variables").arg(nbVariables));
+    }
+    else {
+        ui->label->setText(tr("No variable"));
+    }
+}
+
+VariableMenuHeaderWidget::~VariableMenuHeaderWidget() noexcept
+{
+    delete ui;
+}
diff --git a/gui/src/Visualization/VisualizationGraphHelper.cpp b/gui/src/Visualization/VisualizationGraphHelper.cpp
index f4a0122..da5e732 100644
--- a/gui/src/Visualization/VisualizationGraphHelper.cpp
+++ b/gui/src/Visualization/VisualizationGraphHelper.cpp
@@ -37,30 +37,32 @@ void updateScalarData(QCPAbstractPlottable *component, ScalarSeries &scalarSerie
     timer.start();
     if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
         // Clean the graph
-        qCDebug(LOG_VisualizationGraphHelper()) << "The slow s1 operation took" << timer.elapsed()
-                                                << "milliseconds";
         // NAIVE approch
         const auto &xData = scalarSeries.xAxisData()->data();
         const auto &valuesData = scalarSeries.valuesData()->data();
+        const auto count = xData.count();
+        qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points in cache" << xData.count();
 
-        auto xValue = QVector<double>();
-        auto vValue = QVector<double>();
+        auto xValue = QVector<double>(count);
+        auto vValue = QVector<double>(count);
 
-        const auto count = xData.count();
-        auto ite = 0;
+        int n = 0;
         for (auto i = 0; i < count; ++i) {
-            const auto x = xData.at(i);
+            const auto x = xData[i];
             if (x >= dateTime.m_TStart && x <= dateTime.m_TEnd) {
-                xValue.push_back(x);
-                vValue.push_back(valuesData.at(i));
-                ++ite;
+                xValue[n] = x;
+                vValue[n] = valuesData[i];
+                ++n;
             }
         }
 
-        qcpGraph->setData(xValue, vValue);
+        xValue.resize(n);
+        vValue.resize(n);
 
-        qCDebug(LOG_VisualizationGraphHelper()) << "The slow s2 operation took" << timer.elapsed()
-                                                << "milliseconds";
+        qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points displayed"
+                                               << xValue.count();
+
+        qcpGraph->setData(xValue, vValue);
     }
     else {
         /// @todo DEBUG
diff --git a/gui/src/Visualization/VisualizationGraphWidget.cpp b/gui/src/Visualization/VisualizationGraphWidget.cpp
index 213979f..059beb8 100644
--- a/gui/src/Visualization/VisualizationGraphWidget.cpp
+++ b/gui/src/Visualization/VisualizationGraphWidget.cpp
@@ -57,6 +57,9 @@ VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget 
     ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
             &VisualizationGraphWidget::onGraphMenuRequested);
+
+    connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
+            &VariableController::onRequestDataLoading);
 }
 
 
@@ -74,7 +77,7 @@ void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
         impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
     }
 
-    connect(variable.get(), SIGNAL(dataCacheUpdated()), this, SLOT(onDataCacheVariableUpdated()));
+    connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
 }
 
 void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
@@ -142,9 +145,6 @@ void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange
          it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
 
         auto variable = it->first;
-        qCInfo(LOG_VisualizationGraphWidget())
-            << tr("TORM: VisualizationGraphWidget::onRangeChanged")
-            << variable->dataSeries()->xAxisData()->size();
         auto dateTime = SqpDateTime{t2.lower, t2.upper};
 
         if (!variable->contains(dateTime)) {
@@ -179,8 +179,7 @@ void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange
             variable->setDateTime(dateTime);
 
             // CHangement detected, we need to ask controller to request data loading
-            sqpApp->variableController().requestDataLoading(variable,
-                                                            variableDateTimeWithTolerance);
+            emit requestDataLoading(variable, variableDateTimeWithTolerance);
         }
     }
 }
diff --git a/gui/src/Visualization/VisualizationWidget.cpp b/gui/src/Visualization/VisualizationWidget.cpp
index 8f04c44..77eec9c 100644
--- a/gui/src/Visualization/VisualizationWidget.cpp
+++ b/gui/src/Visualization/VisualizationWidget.cpp
@@ -106,10 +106,24 @@ QString VisualizationWidget::name() const
     return QStringLiteral("MainView");
 }
 
-void VisualizationWidget::attachVariableMenu(QMenu *menu,
-                                             std::shared_ptr<Variable> variable) noexcept
+void VisualizationWidget::attachVariableMenu(
+    QMenu *menu, const QVector<std::shared_ptr<Variable> > &variables) noexcept
 {
-    // Generates the actions that make it possible to visualize the variable
-    auto generateVariableMenuOperation = GenerateVariableMenuOperation{menu, variable};
-    accept(&generateVariableMenuOperation);
+    // Menu is generated only if there is a single variable
+    if (variables.size() == 1) {
+        if (auto variable = variables.first()) {
+            // Generates the actions that make it possible to visualize the variable
+            auto generateVariableMenuOperation = GenerateVariableMenuOperation{menu, variable};
+            accept(&generateVariableMenuOperation);
+        }
+        else {
+            qCCritical(LOG_VisualizationWidget()) << tr(
+                "Can't generate the menu relative to the visualization: the variable is null");
+        }
+    }
+    else {
+        qCDebug(LOG_VisualizationWidget())
+            << tr("No generation of the menu related to the visualization: several variables are "
+                  "selected");
+    }
 }
diff --git a/gui/ui/Variable/VariableMenuHeaderWidget.ui b/gui/ui/Variable/VariableMenuHeaderWidget.ui
new file mode 100644
index 0000000..141d286
--- /dev/null
+++ b/gui/ui/Variable/VariableMenuHeaderWidget.ui
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>VariableMenuHeaderWidget</class>
+ <widget class="QWidget" name="VariableMenuHeaderWidget">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>110</width>
+    <height>34</height>
+   </rect>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="0" column="0">
+    <widget class="QLabel" name="label">
+     <property name="styleSheet">
+      <string notr="true">background-color: rgba(127, 127, 127, 127);</string>
+     </property>
+     <property name="text">
+      <string>TextLabel</string>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignCenter</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/plugins/mockplugin/src/CosinusProvider.cpp b/plugins/mockplugin/src/CosinusProvider.cpp
index cd9ef2b..ee66ccf 100644
--- a/plugins/mockplugin/src/CosinusProvider.cpp
+++ b/plugins/mockplugin/src/CosinusProvider.cpp
@@ -5,6 +5,8 @@
 
 #include <cmath>
 
+#include <QDateTime>
+
 Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
 
 std::unique_ptr<IDataSeries>
@@ -16,6 +18,7 @@ CosinusProvider::retrieveData(const DataProviderParameters &parameters) const
     auto start = dateTime.m_TStart;
     auto end = dateTime.m_TEnd;
 
+
     // We assure that timerange is valid
     if (end < start) {
         std::swap(start, end);
@@ -47,10 +50,12 @@ void CosinusProvider::requestDataLoading(const QVector<SqpDateTime> &dateTimeLis
 
 std::shared_ptr<IDataSeries> CosinusProvider::retrieveDataSeries(const SqpDateTime &dateTime)
 {
+    auto dataIndex = 0;
 
     // Gets the timerange from the parameters
-    auto start = dateTime.m_TStart;
-    auto end = dateTime.m_TEnd;
+    double freq = 100.0;
+    double start = dateTime.m_TStart * freq; // 100 htz
+    double end = dateTime.m_TEnd * freq;     // 100 htz
 
     // We assure that timerange is valid
     if (end < start) {
@@ -61,11 +66,9 @@ std::shared_ptr<IDataSeries> CosinusProvider::retrieveDataSeries(const SqpDateTi
     auto scalarSeries
         = std::make_shared<ScalarSeries>(end - start, Unit{QStringLiteral("t"), true}, Unit{});
 
-    auto dataIndex = 0;
     for (auto time = start; time < end; ++time, ++dataIndex) {
-        scalarSeries->setData(dataIndex, time, std::cos(time));
+        const auto timeOnFreq = time / freq;
+        scalarSeries->setData(dataIndex, timeOnFreq, std::cos(timeOnFreq));
     }
-
-
     return scalarSeries;
 }