From f81e8612a847e0d9f8b09ccf69eae55daf4f18ec 2017-08-02 15:58:51
From: perrinel <mperrinel@itlink.fr>
Date: 2017-08-02 15:58:51
Subject: [PATCH] Merge pull request #196 from SCIQLOP-Initialisation develop

 Develop

---

diff --git a/app/src/MainWindow.cpp b/app/src/MainWindow.cpp
index b38845e..80c94f6 100644
--- a/app/src/MainWindow.cpp
+++ b/app/src/MainWindow.cpp
@@ -36,7 +36,6 @@
 
 #include <QAction>
 #include <QDate>
-#include <QDateTime>
 #include <QDir>
 #include <QFileDialog>
 #include <QToolBar>
diff --git a/core/include/Common/DateUtils.h b/core/include/Common/DateUtils.h
new file mode 100644
index 0000000..7d80539
--- /dev/null
+++ b/core/include/Common/DateUtils.h
@@ -0,0 +1,19 @@
+#ifndef SCIQLOP_DATEUTILS_H
+#define SCIQLOP_DATEUTILS_H
+
+#include "CoreGlobal.h"
+
+#include <QDateTime>
+
+/**
+ * Utility class with methods for dates
+ */
+struct SCIQLOP_CORE_EXPORT DateUtils {
+    /// Converts seconds (since epoch) to datetime. By default, the datetime is in UTC
+    static QDateTime dateTime(double secs, Qt::TimeSpec timeSpec = Qt::UTC) noexcept;
+
+    /// Converts datetime to seconds since epoch
+    static double secondsSinceEpoch(const QDateTime &dateTime) noexcept;
+};
+
+#endif // SCIQLOP_DATEUTILS_H
diff --git a/core/include/Data/IDataSeries.h b/core/include/Data/IDataSeries.h
index 5dfa75a..2710e1b 100644
--- a/core/include/Data/IDataSeries.h
+++ b/core/include/Data/IDataSeries.h
@@ -23,7 +23,7 @@ struct Unit {
     inline bool operator!=(const Unit &other) const { return !(*this == other); }
 
     QString m_Name;  ///< Unit name
-    bool m_TimeUnit; ///< The unit is a unit of time
+    bool m_TimeUnit; ///< The unit is a unit of time (UTC)
 };
 
 /**
diff --git a/core/include/Data/SqpDateTime.h b/core/include/Data/SqpDateTime.h
index 3ea0484..b4c51c5 100644
--- a/core/include/Data/SqpDateTime.h
+++ b/core/include/Data/SqpDateTime.h
@@ -3,18 +3,18 @@
 
 #include <QObject>
 
-#include <QDateTime>
 #include <QDebug>
 
+#include <Common/DateUtils.h>
 #include <Common/MetaTypes.h>
 
 /**
  * @brief The SqpDateTime struct holds the information of time parameters
  */
 struct SqpDateTime {
-    /// Start time
+    /// Start time (UTC)
     double m_TStart;
-    /// End time
+    /// End time (UTC)
     double m_TEnd;
 
     bool contains(const SqpDateTime &dateTime) const noexcept
@@ -30,10 +30,9 @@ 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);
+    auto tendDateTimeStart = DateUtils::dateTime(obj.m_TStart);
+    auto tendDateTimeEnd = DateUtils::dateTime(obj.m_TEnd);
 
-    //        QDebug << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
     d << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
     return d;
 }
diff --git a/core/src/Common/DateUtils.cpp b/core/src/Common/DateUtils.cpp
new file mode 100644
index 0000000..635bbf2
--- /dev/null
+++ b/core/src/Common/DateUtils.cpp
@@ -0,0 +1,13 @@
+#include "Common/DateUtils.h"
+
+QDateTime DateUtils::dateTime(double secs, Qt::TimeSpec timeSpec) noexcept
+{
+    // Uses msecs to be Qt 4 compatible
+    return QDateTime::fromMSecsSinceEpoch(secs * 1000., timeSpec);
+}
+
+double DateUtils::secondsSinceEpoch(const QDateTime &dateTime) noexcept
+{
+    // Uses msecs to be Qt 4 compatible
+    return dateTime.toMSecsSinceEpoch() / 1000.;
+}
diff --git a/core/src/Variable/VariableController.cpp b/core/src/Variable/VariableController.cpp
index c439435..e69b4de 100644
--- a/core/src/Variable/VariableController.cpp
+++ b/core/src/Variable/VariableController.cpp
@@ -8,7 +8,6 @@
 #include <Data/IDataSeries.h>
 #include <Time/TimeController.h>
 
-#include <QDateTime>
 #include <QMutex>
 #include <QThread>
 #include <QUuid>
diff --git a/core/src/Variable/VariableModel.cpp b/core/src/Variable/VariableModel.cpp
index 75a3387..6b929c3 100644
--- a/core/src/Variable/VariableModel.cpp
+++ b/core/src/Variable/VariableModel.cpp
@@ -1,9 +1,10 @@
 #include <Variable/Variable.h>
 #include <Variable/VariableModel.h>
 
+#include <Common/DateUtils.h>
+
 #include <Data/IDataSeries.h>
 
-#include <QDateTime>
 #include <QSize>
 #include <unordered_map>
 
@@ -150,8 +151,8 @@ QVariant VariableModel::data(const QModelIndex &index, int role) const
     if (role == Qt::DisplayRole) {
         if (auto variable = impl->m_Variables.at(index.row()).get()) {
             /// Lambda function that builds the variant to return for a time value
-            auto dateTimeVariant = [](double time) {
-                auto dateTime = QDateTime::fromMSecsSinceEpoch(time * 1000.);
+            auto dateTimeVariant = [](double secs) {
+                auto dateTime = DateUtils::dateTime(secs);
                 return dateTime.toString(DATETIME_FORMAT);
             };
 
diff --git a/gui/include/Visualization/VisualizationGraphRenderingDelegate.h b/gui/include/Visualization/VisualizationGraphRenderingDelegate.h
new file mode 100644
index 0000000..7bdd366
--- /dev/null
+++ b/gui/include/Visualization/VisualizationGraphRenderingDelegate.h
@@ -0,0 +1,20 @@
+#ifndef SCIQLOP_VISUALIZATIONGRAPHRENDERINGDELEGATE_H
+#define SCIQLOP_VISUALIZATIONGRAPHRENDERINGDELEGATE_H
+
+#include <Common/spimpl.h>
+
+class QCustomPlot;
+class QMouseEvent;
+
+class VisualizationGraphRenderingDelegate {
+public:
+    explicit VisualizationGraphRenderingDelegate(QCustomPlot &plot);
+
+    void onMouseMove(QMouseEvent *event) noexcept;
+
+private:
+    class VisualizationGraphRenderingDelegatePrivate;
+    spimpl::unique_impl_ptr<VisualizationGraphRenderingDelegatePrivate> impl;
+};
+
+#endif // SCIQLOP_VISUALIZATIONGRAPHRENDERINGDELEGATE_H
diff --git a/gui/include/Visualization/VisualizationGraphWidget.h b/gui/include/Visualization/VisualizationGraphWidget.h
index 1f31ed2..a015f24 100644
--- a/gui/include/Visualization/VisualizationGraphWidget.h
+++ b/gui/include/Visualization/VisualizationGraphWidget.h
@@ -69,6 +69,8 @@ private slots:
     /// Rescale the X axe to range parameter
     void onRangeChanged(const QCPRange &t1, const QCPRange &t2);
 
+    /// Slot called when a mouse move was made
+    void onMouseMove(QMouseEvent *event) noexcept;
     /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
     void onMouseWheel(QWheelEvent *event) noexcept;
     /// Slot called when a mouse press was made, to activate the calibration of a graph
diff --git a/gui/src/TimeWidget/TimeWidget.cpp b/gui/src/TimeWidget/TimeWidget.cpp
index e2a754d..01cd71f 100644
--- a/gui/src/TimeWidget/TimeWidget.cpp
+++ b/gui/src/TimeWidget/TimeWidget.cpp
@@ -1,6 +1,7 @@
 #include "TimeWidget/TimeWidget.h"
 #include "ui_TimeWidget.h"
 
+#include <Common/DateUtils.h>
 #include <SqpApplication.h>
 #include <Time/TimeController.h>
 
@@ -22,13 +23,15 @@ TimeWidget::TimeWidget(QWidget *parent) : QWidget{parent}, ui{new Ui::TimeWidget
             &TimeController::onTimeNotify);
 
     // Initialisation
-    ui->startDateTimeEdit->setDateTime(
-        QDateTime::currentDateTime().addSecs(-3600)); // one hour berefore
-    ui->endDateTimeEdit->setDateTime(QDateTime::currentDateTime());
+    auto endDateTime = QDateTime::currentDateTimeUtc();
+    auto startDateTime = endDateTime.addSecs(-3600); // one hour before
+
+    ui->startDateTimeEdit->setDateTime(startDateTime);
+    ui->endDateTimeEdit->setDateTime(endDateTime);
+
+    auto dateTime = SqpDateTime{DateUtils::secondsSinceEpoch(startDateTime),
+                                DateUtils::secondsSinceEpoch(endDateTime)};
 
-    auto dateTime
-        = SqpDateTime{QDateTime::currentDateTime().addSecs(-3600).toMSecsSinceEpoch() / 1000.0,
-                      QDateTime::currentDateTime().toMSecsSinceEpoch() / 1000.0};
     sqpApp->timeController().onTimeToUpdate(dateTime);
 }
 
@@ -40,9 +43,8 @@ TimeWidget::~TimeWidget()
 
 void TimeWidget::onTimeUpdateRequested()
 {
-    auto dateTime = SqpDateTime{
-        static_cast<double>(ui->startDateTimeEdit->dateTime().toMSecsSinceEpoch() / 1000.),
-        static_cast<double>(ui->endDateTimeEdit->dateTime().toMSecsSinceEpoch()) / 1000.};
+    auto dateTime = SqpDateTime{DateUtils::secondsSinceEpoch(ui->startDateTimeEdit->dateTime()),
+                                DateUtils::secondsSinceEpoch(ui->endDateTimeEdit->dateTime())};
 
     emit timeUpdated(std::move(dateTime));
 }
diff --git a/gui/src/Visualization/VisualizationGraphHelper.cpp b/gui/src/Visualization/VisualizationGraphHelper.cpp
index 34bcae6..0ea7ff6 100644
--- a/gui/src/Visualization/VisualizationGraphHelper.cpp
+++ b/gui/src/Visualization/VisualizationGraphHelper.cpp
@@ -25,6 +25,7 @@ QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
     if (isTimeAxis) {
         auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
         dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
+        dateTicker->setDateTimeSpec(Qt::UTC);
 
         return dateTicker;
     }
diff --git a/gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp b/gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp
new file mode 100644
index 0000000..6e6e3ea
--- /dev/null
+++ b/gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp
@@ -0,0 +1,123 @@
+#include "Visualization/VisualizationGraphRenderingDelegate.h"
+#include "Visualization/qcustomplot.h"
+
+#include <Common/DateUtils.h>
+
+namespace {
+
+const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss:zzz");
+
+const auto TEXT_TRACER_FORMAT = QStringLiteral("key: %1\nvalue: %2");
+
+/// Timeout after which a tracer is displayed
+const auto TRACER_TIMEOUT = 500;
+
+/// Formats a data value according to the axis on which it is present
+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())) {
+        return DateUtils::dateTime(value, axisTicker->dateTimeSpec()).toString(DATETIME_FORMAT);
+    }
+    else {
+        return QString::number(value);
+    }
+}
+
+void initPointTracerStyle(QCPItemTracer &tracer) noexcept
+{
+    tracer.setInterpolating(false);
+    tracer.setStyle(QCPItemTracer::tsPlus);
+    tracer.setPen(QPen(Qt::black));
+    tracer.setBrush(Qt::black);
+    tracer.setSize(10);
+}
+
+void initTextTracerStyle(QCPItemText &tracer) noexcept
+{
+    tracer.setPen(QPen{Qt::gray});
+    tracer.setBrush(Qt::white);
+    tracer.setPadding(QMargins{6, 6, 6, 6});
+    tracer.setPositionAlignment(Qt::AlignTop | Qt::AlignLeft);
+    tracer.setTextAlignment(Qt::AlignLeft);
+}
+
+} // namespace
+
+struct VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegatePrivate {
+    explicit VisualizationGraphRenderingDelegatePrivate(QCustomPlot &plot)
+            : m_Plot{plot},
+              m_PointTracer{new QCPItemTracer{&plot}},
+              m_TextTracer{new QCPItemText{&plot}},
+              m_TracerTimer{}
+    {
+        initPointTracerStyle(*m_PointTracer);
+        initTextTracerStyle(*m_TextTracer);
+
+        m_TracerTimer.setInterval(TRACER_TIMEOUT);
+        m_TracerTimer.setSingleShot(true);
+    }
+
+    QCustomPlot &m_Plot;
+    QCPItemTracer *m_PointTracer;
+    QCPItemText *m_TextTracer;
+    QTimer m_TracerTimer;
+};
+
+VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegate(QCustomPlot &plot)
+        : impl{spimpl::make_unique_impl<VisualizationGraphRenderingDelegatePrivate>(plot)}
+{
+}
+
+void VisualizationGraphRenderingDelegate::onMouseMove(QMouseEvent *event) noexcept
+{
+    // Cancels pending refresh
+    impl->m_TracerTimer.disconnect();
+
+    auto showTracers = [ eventPos = event->pos(), this ]()
+    {
+        // Lambda function to display a tracer
+        auto displayTracer = [this](auto &tracer) {
+            // Tracer is set on top of the plot's main layer
+            tracer.setLayer(impl->m_Plot.layer("main"));
+            tracer.setVisible(true);
+            impl->m_Plot.replot();
+        };
+
+        // Reinits tracers
+        impl->m_PointTracer->setGraph(nullptr);
+        impl->m_PointTracer->setVisible(false);
+        impl->m_TextTracer->setVisible(false);
+        impl->m_Plot.replot();
+
+        // Gets the graph under the mouse position
+        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()) {
+                auto key = formatValue(graphDataIt->key, *graph->keyAxis());
+                auto value = formatValue(graphDataIt->value, *graph->valueAxis());
+                impl->m_TextTracer->setText(TEXT_TRACER_FORMAT.arg(key, value));
+
+                // Displays point tracer
+                impl->m_PointTracer->setGraph(graph);
+                impl->m_PointTracer->setGraphKey(graphDataIt->key);
+                displayTracer(*impl->m_PointTracer);
+
+                // Displays text tracer
+                auto tracerPosition = impl->m_TextTracer->position;
+                tracerPosition->setAxes(graph->keyAxis(), graph->valueAxis());
+                tracerPosition->setCoords(impl->m_PointTracer->position->key(),
+                                          impl->m_PointTracer->position->value());
+                displayTracer(*impl->m_TextTracer);
+            }
+        }
+    };
+
+    // Starts the timer to display tracers at timeout
+    QObject::connect(&impl->m_TracerTimer, &QTimer::timeout, showTracers);
+    impl->m_TracerTimer.start();
+}
diff --git a/gui/src/Visualization/VisualizationGraphWidget.cpp b/gui/src/Visualization/VisualizationGraphWidget.cpp
index 275a284..eb70fb8 100644
--- a/gui/src/Visualization/VisualizationGraphWidget.cpp
+++ b/gui/src/Visualization/VisualizationGraphWidget.cpp
@@ -1,6 +1,7 @@
 #include "Visualization/VisualizationGraphWidget.h"
 #include "Visualization/IVisualizationWidgetVisitor.h"
 #include "Visualization/VisualizationGraphHelper.h"
+#include "Visualization/VisualizationGraphRenderingDelegate.h"
 #include "ui_VisualizationGraphWidget.h"
 
 #include <Data/ArrayData.h>
@@ -33,17 +34,21 @@ double toleranceValue(const QString &key, double defaultValue) noexcept
 
 struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
 
-    explicit VisualizationGraphWidgetPrivate() : m_DoSynchronize{true}, m_IsCalibration{false} {}
-
+    explicit VisualizationGraphWidgetPrivate()
+            : m_DoSynchronize{true}, m_IsCalibration{false}, m_RenderingDelegate{nullptr}
+    {
+    }
 
     // Return the operation when range changed
     VisualizationGraphWidgetZoomType getZoomType(const QCPRange &t1, const QCPRange &t2);
 
     // 1 variable -> n qcpplot
     std::multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMultiMap;
-
     bool m_DoSynchronize;
     bool m_IsCalibration;
+    QCPItemTracer *m_TextTracer;
+    /// Delegate used to attach rendering features to the plot
+    std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
 };
 
 VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
@@ -53,6 +58,9 @@ VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget 
 {
     ui->setupUi(this);
 
+    // The delegate must be initialized after the ui as it uses the plot
+    impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*ui->widget);
+
     ui->graphNameLabel->setText(name);
 
     // 'Close' options : widget is deleted when closed
@@ -65,9 +73,11 @@ VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget 
     // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
     ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
     ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
+
     connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
     connect(ui->widget, &QCustomPlot::mouseRelease, this,
             &VisualizationGraphWidget::onMouseRelease);
+    connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
     connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
     connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
                                    &QCPAxis::rangeChanged),
@@ -329,6 +339,12 @@ void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange
     }
 }
 
+void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
+{
+    // Handles plot rendering when mouse is moving
+    impl->m_RenderingDelegate->onMouseMove(event);
+}
+
 void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
 {
     auto zoomOrientations = QFlags<Qt::Orientation>{};
diff --git a/gui/ui/TimeWidget/TimeWidget.ui b/gui/ui/TimeWidget/TimeWidget.ui
index d1f5ccb..afc7200 100644
--- a/gui/ui/TimeWidget/TimeWidget.ui
+++ b/gui/ui/TimeWidget/TimeWidget.ui
@@ -47,6 +47,9 @@
      <property name="calendarPopup">
       <bool>true</bool>
      </property>
+     <property name="timeSpec">
+      <enum>Qt::UTC</enum>
+     </property>
     </widget>
    </item>
    <item>
@@ -76,6 +79,9 @@
      <property name="calendarPopup">
       <bool>true</bool>
      </property>
+     <property name="timeSpec">
+      <enum>Qt::UTC</enum>
+     </property>
     </widget>
    </item>
    <item>
diff --git a/plugins/amda/src/AmdaProvider.cpp b/plugins/amda/src/AmdaProvider.cpp
index bfc0f46..ccb5456 100644
--- a/plugins/amda/src/AmdaProvider.cpp
+++ b/plugins/amda/src/AmdaProvider.cpp
@@ -2,6 +2,7 @@
 #include "AmdaDefs.h"
 #include "AmdaResultParser.h"
 
+#include <Common/DateUtils.h>
 #include <Data/DataProviderParameters.h>
 #include <Network/NetworkController.h>
 #include <SqpApplication.h>
@@ -31,7 +32,7 @@ const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss");
 /// Formats a time to a date that can be passed in URL
 QString dateFormat(double sqpDateTime) noexcept
 {
-    auto dateTime = QDateTime::fromMSecsSinceEpoch(sqpDateTime * 1000.);
+    auto dateTime = DateUtils::dateTime(sqpDateTime);
     return dateTime.toString(AMDA_TIME_FORMAT);
 }
 
diff --git a/plugins/amda/src/AmdaResultParser.cpp b/plugins/amda/src/AmdaResultParser.cpp
index e435dce..abe18c1 100644
--- a/plugins/amda/src/AmdaResultParser.cpp
+++ b/plugins/amda/src/AmdaResultParser.cpp
@@ -1,5 +1,6 @@
 #include "AmdaResultParser.h"
 
+#include <Common/DateUtils.h>
 #include <Data/ScalarSeries.h>
 
 #include <QDateTime>
@@ -33,10 +34,17 @@ const auto UNIT_REGEX = QRegularExpression{QStringLiteral("-\\s*Units\\s*:\\s*(.
 double doubleDate(const QString &stringDate) noexcept
 {
     auto dateTime = QDateTime::fromString(stringDate, DATE_FORMAT);
-    return dateTime.isValid() ? (dateTime.toMSecsSinceEpoch() / 1000.)
+    dateTime.setTimeSpec(Qt::UTC);
+    return dateTime.isValid() ? DateUtils::secondsSinceEpoch(dateTime)
                               : std::numeric_limits<double>::quiet_NaN();
 }
 
+/// Checks if a line is a comment line
+bool isCommentLine(const QString &line)
+{
+    return line.startsWith("#");
+}
+
 /**
  * Reads stream to retrieve x-axis unit
  * @param stream the stream to read
@@ -47,20 +55,16 @@ Unit readXAxisUnit(QTextStream &stream)
 {
     QString line{};
 
-    if (stream.readLineInto(&line)) {
+    // Searches unit in the comment lines
+    while (stream.readLineInto(&line) && isCommentLine(line)) {
         auto match = UNIT_REGEX.match(line);
         if (match.hasMatch()) {
             return Unit{match.captured(1), true};
         }
-        else {
-            qCWarning(LOG_AmdaResultParser())
-                << QObject::tr("Can't read unit: invalid line %1").arg(line);
-        }
-    }
-    else {
-        qCWarning(LOG_AmdaResultParser()) << QObject::tr("Can't read unit: end of file");
     }
 
+    qCWarning(LOG_AmdaResultParser()) << QObject::tr("The unit could not be found in the file");
+
     // Error cases
     return Unit{{}, true};
 }
@@ -76,32 +80,36 @@ QPair<QVector<double>, QVector<double> > readResults(QTextStream &stream)
     auto valuesData = QVector<double>{};
 
     QString line{};
+
     while (stream.readLineInto(&line)) {
-        auto lineData = line.split(RESULT_LINE_SEPARATOR, QString::SkipEmptyParts);
-        if (lineData.size() == 2) {
-            // X : the data is converted from date to double (in secs)
-            auto x = doubleDate(lineData.at(0));
-
-            // Value
-            bool valueOk;
-            auto value = lineData.at(1).toDouble(&valueOk);
-
-            // Adds result only if x and value are valid
-            if (!std::isnan(x) && !std::isnan(value) && valueOk) {
-                xData.push_back(x);
-                valuesData.push_back(value);
+        // Ignore comment lines
+        if (!isCommentLine(line)) {
+            auto lineData = line.split(RESULT_LINE_SEPARATOR, QString::SkipEmptyParts);
+            if (lineData.size() == 2) {
+                // X : the data is converted from date to double (in secs)
+                auto x = doubleDate(lineData.at(0));
+
+                // Value
+                bool valueOk;
+                auto value = lineData.at(1).toDouble(&valueOk);
+
+                // Adds result only if x and value are valid
+                if (!std::isnan(x) && !std::isnan(value) && valueOk) {
+                    xData.push_back(x);
+                    valuesData.push_back(value);
+                }
+                else {
+                    qCWarning(LOG_AmdaResultParser())
+                        << QObject::tr(
+                               "Can't retrieve results from line %1: x and/or value are invalid")
+                               .arg(line);
+                }
             }
             else {
                 qCWarning(LOG_AmdaResultParser())
-                    << QObject::tr(
-                           "Can't retrieve results from line %1: x and/or value are invalid")
-                           .arg(line);
+                    << QObject::tr("Can't retrieve results from line %1: invalid line").arg(line);
             }
         }
-        else {
-            qCWarning(LOG_AmdaResultParser())
-                << QObject::tr("Can't retrieve results from line %1: invalid line").arg(line);
-        }
     }
 
     return qMakePair(std::move(xData), std::move(valuesData));
@@ -131,13 +139,12 @@ std::shared_ptr<IDataSeries> AmdaResultParser::readTxt(const QString &filePath) 
         return nullptr;
     }
 
-    // Ignore comments lines
-    stream.readLine();
-
     // Reads x-axis unit
+    stream.seek(0); // returns to the beginning of the file
     auto xAxisUnit = readXAxisUnit(stream);
 
     // Reads results
+    stream.seek(0); // returns to the beginning of the file
     auto results = readResults(stream);
 
     return std::make_shared<ScalarSeries>(std::move(results.first), std::move(results.second),
diff --git a/plugins/amda/tests/TestAmdaResultParser.cpp b/plugins/amda/tests/TestAmdaResultParser.cpp
index 0501e79..702b367 100644
--- a/plugins/amda/tests/TestAmdaResultParser.cpp
+++ b/plugins/amda/tests/TestAmdaResultParser.cpp
@@ -99,7 +99,7 @@ void TestAmdaResultParser::testReadTxt_data()
     // ////////// //
 
     auto dateTime = [](int year, int month, int day, int hours, int minutes, int seconds) {
-        return QDateTime{{year, month, day}, {hours, minutes, seconds}};
+        return QDateTime{{year, month, day}, {hours, minutes, seconds}, Qt::UTC};
     };
 
     // Valid file
diff --git a/plugins/mockplugin/src/CosinusProvider.cpp b/plugins/mockplugin/src/CosinusProvider.cpp
index d49bd10..bdc4345 100644
--- a/plugins/mockplugin/src/CosinusProvider.cpp
+++ b/plugins/mockplugin/src/CosinusProvider.cpp
@@ -5,7 +5,6 @@
 
 #include <cmath>
 
-#include <QDateTime>
 #include <QFuture>
 #include <QThread>
 #include <QtConcurrent/QtConcurrent>