GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r206:373baac343d6

Merge pull request from SCIQLOP-Initialisation develop...

leroux -

r206:373baac343d6

parent child

Context file:

r206:373baac343d6

Expand all files

core/include/Data/SqpDateTime.h created 644 +14 0

@@ -0,0 +1,14
	1	#ifndef SCIQLOP_SQPDATETIME_H
	2	#define SCIQLOP_SQPDATETIME_H
	3
	4	/**
	5	* @brief The SqpDateTime struct holds the information of time parameters
	6	*/
	7	struct SqpDateTime {
	8	/// Start time
	9	double m_TStart;
	10	/// End time
	11	double m_TEnd;
	12	};
	13
	14	#endif // SCIQLOP_SQPDATETIME_H

core/include/Time/TimeController.h created 644 +37 0

@@ -0,0 +1,37
	1	#ifndef SCIQLOP_TIMECONTROLLER_H
	2	#define SCIQLOP_TIMECONTROLLER_H
	3
	4	#include <Data/SqpDateTime.h>
	5
	6	#include <QLoggingCategory>
	7	#include <QObject>
	8
	9	#include <Common/spimpl.h>
	10
	11
	12	Q_DECLARE_LOGGING_CATEGORY(LOG_TimeController)
	13
	14	/**
	15	* @brief The TimeController class aims to handle the Time parameters notification in SciQlop.
	16	*/
	17	class TimeController : public QObject {
	18	Q_OBJECT
	19	public:
	20	explicit TimeController(QObject *parent = 0);
	21
	22	SqpDateTime dateTime() const noexcept;
	23
	24	signals:
	25	/// Signal emitted to notify that time parameters has beed updated
	26	void timeUpdated(SqpDateTime time);
	27
	28	public slots:
	29	/// Slot called when a new dateTime has been defined. Call timeUpdated signal
	30	void onTimeToUpdate(SqpDateTime dateTime);
	31
	32	private:
	33	class TimeControllerPrivate;
	34	spimpl::unique_impl_ptr<TimeControllerPrivate> impl;
	35	};
	36
	37	#endif // SCIQLOP_TIMECONTROLLER_H

core/src/Time/TimeController.cpp created 644 +26 0

@@ -0,0 +1,26
	1	#include "Time/TimeController.h"
	2
	3	Q_LOGGING_CATEGORY(LOG_TimeController, "TimeController")
	4
	5	struct TimeController::TimeControllerPrivate {
	6
	7	SqpDateTime m_DateTime;
	8	};
	9
	10	TimeController::TimeController(QObject *parent)
	11	: QObject{parent}, impl{spimpl::make_unique_impl<TimeControllerPrivate>()}
	12	{
	13	qCDebug(LOG_TimeController()) << tr("TimeController construction");
	14	}
	15
	16	SqpDateTime TimeController::dateTime() const noexcept
	17	{
	18	return impl->m_DateTime;
	19	}
	20
	21	void TimeController::onTimeToUpdate(SqpDateTime dateTime)
	22	{
	23	impl->m_DateTime = dateTime;
	24
	25	emit timeUpdated(dateTime);
	26	}

app/src/MainWindow.cpp +10 -1

             /*------------------------------------------------------------------------------
             -- This file is a part of the SciQLop Software
             -- Copyright (C) 2017, Plasma Physics Laboratory - CNRS
             --
             -- This program is free software; you can redistribute it and/or modify
             -- it under the terms of the GNU General Public License as published by
             -- the Free Software Foundation; either version 2 of the License, or
             -- (at your option) any later version.
             --
             -- This program is distributed in the hope that it will be useful,
             -- but WITHOUT ANY WARRANTY; without even the implied warranty of
             -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
             -- GNU General Public License for more details.
             --
             -- You should have received a copy of the GNU General Public License
             -- along with this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "MainWindow.h"
             #include "ui_MainWindow.h"
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceWidget.h>
             #include <SidePane/SqpSidePane.h>
             #include <SqpApplication.h>
+            #include <Time/TimeController.h>
             #include <TimeWidget/TimeWidget.h>
             #include <Variable/Variable.h>
             #include <Visualization/VisualizationController.h>
             #include <QAction>
             #include <QDate>
             #include <QDateTime>
             #include <QDir>
             #include <QFileDialog>
             #include <QToolBar>
             #include <QToolButton>
             #include <memory.h>
             //#include <omp.h>
             //#include <network/filedownloader.h>
             //#include <qlopdatabase.h>
             //#include <qlopsettings.h>
             //#include <qlopgui.h>
             //#include <spacedata.h>
             //#include "qlopcore.h"
             //#include "qlopcodecmanager.h"
             //#include "cdfcodec.h"
             //#include "amdatxtcodec.h"
             //#include <qlopplotmanager.h>
             #include "iostream"
             Q_LOGGING_CATEGORY(LOG_MainWindow, "MainWindow")
             namespace {
             const auto LEFTMAININSPECTORWIDGETSPLITTERINDEX = 0;
             const auto LEFTINSPECTORSIDEPANESPLITTERINDEX = 1;
             const auto VIEWPLITTERINDEX = 2;
             const auto RIGHTINSPECTORSIDEPANESPLITTERINDEX = 3;
             const auto RIGHTMAININSPECTORWIDGETSPLITTERINDEX = 4;
             }
             class MainWindow::MainWindowPrivate {
             public:
                 QSize m_LastOpenLeftInspectorSize;
                 QSize m_LastOpenRightInspectorSize;
             };
             MainWindow::MainWindow(QWidget *parent)
                     : QMainWindow{parent},
                       m_Ui{new Ui::MainWindow},
                       impl{spimpl::make_unique_impl<MainWindowPrivate>()}
             {
                 m_Ui->setupUi(this);
                 m_Ui->splitter->setCollapsible(LEFTINSPECTORSIDEPANESPLITTERINDEX, false);
                 m_Ui->splitter->setCollapsible(RIGHTINSPECTORSIDEPANESPLITTERINDEX, false);
                 auto leftSidePane = m_Ui->leftInspectorSidePane->sidePane();
                 auto openLeftInspectorAction = new QAction{QIcon{
                                                                ":/icones/previous.png",
                                                            },
                                                            tr("Show/hide the left inspector"), this};
                 auto spacerLeftTop = new QWidget{};
                 spacerLeftTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerLeftBottom = new QWidget{};
                 spacerLeftBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 leftSidePane->addWidget(spacerLeftTop);
                 leftSidePane->addAction(openLeftInspectorAction);
                 leftSidePane->addWidget(spacerLeftBottom);
                 auto rightSidePane = m_Ui->rightInspectorSidePane->sidePane();
                 auto openRightInspectorAction = new QAction{QIcon{
                                                                 ":/icones/next.png",
                                                             },
                                                             tr("Show/hide the right inspector"), this};
                 auto spacerRightTop = new QWidget{};
                 spacerRightTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerRightBottom = new QWidget{};
                 spacerRightBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 rightSidePane->addWidget(spacerRightTop);
                 rightSidePane->addAction(openRightInspectorAction);
                 rightSidePane->addWidget(spacerRightBottom);
                 openLeftInspectorAction->setCheckable(true);
                 openRightInspectorAction->setCheckable(true);
                 auto openInspector = [this](bool checked, bool right, auto action) {
                     action->setIcon(QIcon{(checked xor right) ? ":/icones/next.png" : ":/icones/previous.png"});
                     auto &lastInspectorSize
                         = right ? impl->m_LastOpenRightInspectorSize : impl->m_LastOpenLeftInspectorSize;
                     auto nextInspectorSize = right ? m_Ui->rightMainInspectorWidget->size()
                                                    : m_Ui->leftMainInspectorWidget->size();
                     // Update of the last opened geometry
                     if (checked) {
                         lastInspectorSize = nextInspectorSize;
                     }
                     auto startSize = lastInspectorSize;
                     auto endSize = startSize;
                     endSize.setWidth(0);
                     auto splitterInspectorIndex
                         = right ? RIGHTMAININSPECTORWIDGETSPLITTERINDEX : LEFTMAININSPECTORWIDGETSPLITTERINDEX;
                     auto currentSizes = m_Ui->splitter->sizes();
                     if (checked) {
                         // adjust sizes individually here, e.g.
                         currentSizes[splitterInspectorIndex] -= lastInspectorSize.width();
                         currentSizes[VIEWPLITTERINDEX] += lastInspectorSize.width();
                         m_Ui->splitter->setSizes(currentSizes);
                     }
                     else {
                         // adjust sizes individually here, e.g.
                         currentSizes[splitterInspectorIndex] += lastInspectorSize.width();
                         currentSizes[VIEWPLITTERINDEX] -= lastInspectorSize.width();
                         m_Ui->splitter->setSizes(currentSizes);
                     }
                 };
                 connect(openLeftInspectorAction, &QAction::triggered,
                         [openInspector, openLeftInspectorAction](bool checked) {
                             openInspector(checked, false, openLeftInspectorAction);
                         });
                 connect(openRightInspectorAction, &QAction::triggered,
                         [openInspector, openRightInspectorAction](bool checked) {
                             openInspector(checked, true, openRightInspectorAction);
                         });
                 this->menuBar()->addAction(tr("File"));
                 auto mainToolBar = this->addToolBar(QStringLiteral("MainToolBar"));
-                mainToolBar->addWidget(new TimeWidget{});
+                auto timeWidget = new TimeWidget{};
+                mainToolBar->addWidget(timeWidget);
                 // Widgets / controllers connections
+                // DataSource
                 connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem *)),
                         m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem *)));
+                // Time
+                connect(timeWidget, SIGNAL(timeUpdated(SqpDateTime)), &sqpApp->timeController(),
+                        SLOT(onTimeToUpdate(SqpDateTime)));
+                // Variable
                 qRegisterMetaType<std::shared_ptr<Variable> >();
                 connect(&sqpApp->visualizationController(), SIGNAL(variableCreated(std::shared_ptr<Variable>)),
                         m_Ui->view, SLOT(displayVariable(std::shared_ptr<Variable>)));
                 /*    QLopGUI::registerMenuBar(menuBar());
                     this->setWindowIcon(QIcon(":/sciqlopLOGO.svg"));
                     this->m_progressWidget = new QWidget();
                     this->m_progressLayout = new QVBoxLayout(this->m_progressWidget);
                     this->m_progressWidget->setLayout(this->m_progressLayout);
                     this->m_progressWidget->setWindowModality(Qt::WindowModal);
                     m_progressThreadIds = (int*) malloc(OMP_THREADS*sizeof(int));
                     for(int i=0;i<OMP_THREADS;i++)
                     {
                         this->m_progress.append(new QProgressBar(this->m_progressWidget));
                         this->m_progress.last()->setMinimum(0);
                         this->m_progress.last()->setMaximum(100);
                         this->m_progressLayout->addWidget(this->m_progress.last());
                         this->m_progressWidget->hide();
                         this->m_progressThreadIds[i] = -1;
                     }
                     this->m_progressWidget->setWindowTitle("Loading File");
                     const QList<QLopService*>ServicesToLoad=QList<QLopService*>()
                             << QLopCore::self()
                             << QLopPlotManager::self()
                             << QLopCodecManager::self()
                             << FileDownloader::self()
                             << QLopDataBase::self()
                             << SpaceData::self();
                     CDFCodec::registerToManager();
                     AMDATXTCodec::registerToManager();
                     for(int i=0;i<ServicesToLoad.count();i++)
                     {
                         qDebug()<<ServicesToLoad.at(i)->serviceName();
                         ServicesToLoad.at(i)->initialize(); //must be called before getGUI
                         QDockWidget* wdgt=ServicesToLoad.at(i)->getGUI();
                         if(wdgt)
                         {
                             wdgt->setAllowedAreas(Qt::AllDockWidgetAreas);
                             this->addDockWidget(Qt::TopDockWidgetArea,wdgt);
                         }
                         PythonQt::self()->getMainModule().addObject(ServicesToLoad.at(i)->serviceName(),(QObject*)ServicesToLoad.at(i));
                     }*/
             }
             MainWindow::~MainWindow()
             {
             }
             void MainWindow::changeEvent(QEvent *e)
             {
                 QMainWindow::changeEvent(e);
                 switch (e->type()) {
                     case QEvent::LanguageChange:
                         m_Ui->retranslateUi(this);
                         break;
                     default:
                         break;
                 }
             }

core/include/Data/DataProviderParameters.h +3 -4

             #ifndef SCIQLOP_DATAPROVIDERPARAMETERS_H
             #define SCIQLOP_DATAPROVIDERPARAMETERS_H
+            #include "SqpDateTime.h"
             /**
              * @brief The DataProviderParameters struct holds the information needed to retrieve data from a
              * data provider
              * @sa IDataProvider
              */
             struct DataProviderParameters {
-                /// Start time
+                SqpDateTime m_Time;
-                double m_TStart;
-                /// End time
-                double m_TEnd;
             };
             #endif // SCIQLOP_DATAPROVIDERPARAMETERS_H

core/include/Variable/VariableController.h +3 0

             #ifndef SCIQLOP_VARIABLECONTROLLER_H
             #define SCIQLOP_VARIABLECONTROLLER_H
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
             class IDataProvider;
+            class TimeController;
             class Variable;
             class VariableModel;
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
             /**
              * @brief The VariableController class aims to handle the variables in SciQlop.
              */
             class VariableController : public QObject {
                 Q_OBJECT
             public:
                 explicit VariableController(QObject *parent = 0);
                 virtual ~VariableController();
                 VariableModel *variableModel() noexcept;
+                void setTimeController(TimeController *timeController) noexcept;
             signals:
                 /// Signal emitted when a variable has been created
                 void variableCreated(std::shared_ptr<Variable> variable);
             public slots:
                 /**
                  * Creates a new variable and adds it to the model
                  * @param name the name of the new variable
                  * @param provider the data provider for the new variable
                  */
                 void createVariable(const QString &name, std::shared_ptr<IDataProvider> provider) noexcept;
                 void initialize();
                 void finalize();
             private:
                 void waitForFinish();
                 class VariableControllerPrivate;
                 spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLECONTROLLER_H

core/src/Variable/VariableController.cpp +28 -9

             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
+            #include <Time/TimeController.h>
             #include <QDateTime>
             #include <QMutex>
             #include <QThread>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             namespace {
             /// @todo Generates default dataseries, according to the provider passed in parameter. This method
             /// will be deleted when the timerange is recovered from SciQlop
-            std::unique_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider) noexcept
+            std::unique_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider,
+                                                                   const SqpDateTime &dateTime) noexcept
             {
-                auto parameters = DataProviderParameters{
+                auto parameters = DataProviderParameters{dateTime};
-                    // Remarks : we don't use toSecsSinceEpoch() here (method is for Qt 5.8 or above)
-                    static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 00}}.toMSecsSinceEpoch()
-                                        / 1000.),
-                    static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 01}}.toMSecsSinceEpoch())
-                        / 1000.};
                 return provider.retrieveData(parameters);
             }
             } // namespace
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate(VariableController *parent)
                         : m_WorkingMutex{}, m_VariableModel{new VariableModel{parent}}
                 {
                 }
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
+                TimeController *m_TimeController{nullptr};
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                   << QThread::currentThread();
             }
             VariableController::~VariableController()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
                                                   << QThread::currentThread();
                 this->waitForFinish();
             }
             VariableModel *VariableController::variableModel() noexcept
             {
                 return impl->m_VariableModel;
             }
+            void VariableController::setTimeController(TimeController *timeController) noexcept
+            {
+                impl->m_TimeController = timeController;
+            }
             void VariableController::createVariable(const QString &name,
                                                     std::shared_ptr<IDataProvider> provider) noexcept
             {
+                // TORM
+                //    auto dateTime = SqpDateTime{
+                //        // Remarks : we don't use toSecsSinceEpoch() here (method is for Qt 5.8 or above)
+                //        static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 00}}.toMSecsSinceEpoch()
+                //                            / 1000.),
+                //        static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 01}}.toMSecsSinceEpoch())
+                //            / 1000.};
+                if (!impl->m_TimeController) {
+                    qCCritical(LOG_VariableController())
+                        << tr("Impossible to create variable: The time controller is null");
+                    return;
+                }
                 /// @todo : for the moment :
                 /// - the provider is only used to retrieve data from the variable for its initialization, but
                 /// it will be retained later
                 /// - default data are generated for the variable, without taking into account the timerange set
                 /// in sciqlop
-                if (auto newVariable
+                if (auto newVariable = impl->m_VariableModel->createVariable(
-                    = impl->m_VariableModel->createVariable(name, generateDefaultDataSeries(*provider))) {
+                        name, generateDefaultDataSeries(*provider, impl->m_TimeController->dateTime()))) {
                     emit variableCreated(newVariable);
                 }
             }
             void VariableController::initialize()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableController()) << tr("VariableController init END");
             }
             void VariableController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

gui/include/SqpApplication.h +2 0

             #ifndef SCIQLOP_SQPAPPLICATION_H
             #define SCIQLOP_SQPAPPLICATION_H
             #include "SqpApplication.h"
             #include <QApplication>
             #include <QLoggingCategory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_SqpApplication)
             #if defined(sqpApp)
             #undef sqpApp
             #endif
             #define sqpApp (static_cast<SqpApplication *>(QCoreApplication::instance()))
             class DataSourceController;
+            class TimeController;
             class VariableController;
             class VisualizationController;
             /**
              * @brief The SqpApplication class aims to make the link between SciQlop
              * and its plugins. This is the intermediate class that SciQlop has to use
              * in the way to connect a data source. Please first use load method to initialize
              * a plugin specified by its metadata name (JSON plugin source) then others specifics
              * method will be able to access it.
              * You can load a data source driver plugin then create a data source.
              */
             class SqpApplication : public QApplication {
                 Q_OBJECT
             public:
                 explicit SqpApplication(int &argc, char **argv);
                 virtual ~SqpApplication();
                 void initialize();
                 /// Accessors for the differents sciqlop controllers
                 DataSourceController &dataSourceController() noexcept;
+                TimeController &timeController() noexcept;
                 VariableController &variableController() noexcept;
                 VisualizationController &visualizationController() noexcept;
             private:
                 class SqpApplicationPrivate;
                 spimpl::unique_impl_ptr<SqpApplicationPrivate> impl;
             };
             #endif // SCIQLOP_SQPAPPLICATION_H

gui/include/TimeWidget/TimeWidget.h +11 0

             #ifndef SCIQLOP_TIMEWIDGET_H
             #define SCIQLOP_TIMEWIDGET_H
             #include <QWidget>
+            #include <Data/SqpDateTime.h>
             namespace Ui {
             class TimeWidget;
             } // Ui
             class TimeWidget : public QWidget {
                 Q_OBJECT
             public:
                 explicit TimeWidget(QWidget *parent = 0);
                 virtual ~TimeWidget();
+            signals:
+                /// Signal emitted when the time parameters has beed updated
+                void timeUpdated(SqpDateTime time);
+            public slots:
+                /// slot called when time parameters update has ben requested
+                void onTimeUpdateRequested();
             private:
                 Ui::TimeWidget *ui;
             };
             #endif // SCIQLOP_ SQPSIDEPANE_H

gui/include/Visualization/VisualizationGraphWidget.h +1 -1

             #ifndef SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include <QWidget>
             #include <memory>
             #include <Common/spimpl.h>
             class Variable;
             namespace Ui {
             class VisualizationGraphWidget;
             } // namespace Ui
             class VisualizationGraphWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
-                explicit VisualizationGraphWidget(QWidget *parent = 0);
+                explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationGraphWidget();
                 void addVariable(std::shared_ptr<Variable> variable);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidget *visitor) override;
                 void close() override;
                 QString name() const;
             private:
                 Ui::VisualizationGraphWidget *ui;
                 class VisualizationGraphWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
             private slots:
                 /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
                 void onMouseWheel(QWheelEvent *event) noexcept;
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H

gui/include/Visualization/VisualizationTabWidget.h +14 -3

             #ifndef SCIQLOP_VISUALIZATIONTABWIDGET_H
             #define SCIQLOP_VISUALIZATIONTABWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
+            #include <Common/spimpl.h>
             #include <QWidget>
+            class Variable;
             class VisualizationZoneWidget;
             namespace Ui {
             class VisualizationTabWidget;
             } // namespace Ui
             class VisualizationTabWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
-                explicit VisualizationTabWidget(QWidget *parent = 0);
+                explicit VisualizationTabWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationTabWidget();
                 /// Add a zone widget
                 void addZone(VisualizationZoneWidget *zoneWidget);
-                /// Create a zone using a Variable
+                /**
-                VisualizationZoneWidget *createZone();
+                 * Creates a zone using a variable. The variable will be displayed in a new graph of the new
+                 * zone.
+                 * @param variable the variable for which to create the zone
+                 * @return the pointer to the created zone
+                 */
+                VisualizationZoneWidget *createZone(std::shared_ptr<Variable> variable);
                 /// Remove a zone
                 void removeZone(VisualizationZoneWidget *zone);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidget *visitor) override;
                 void close() override;
                 QString name() const override;
             private:
                 Ui::VisualizationTabWidget *ui;
+                class VisualizationTabWidgetPrivate;
+                spimpl::unique_impl_ptr<VisualizationTabWidgetPrivate> impl;
             };
             #endif // SCIQLOP_VISUALIZATIONTABWIDGET_H

gui/include/Visualization/VisualizationZoneWidget.h +10 -5

             #ifndef SCIQLOP_VISUALIZATIONZONEWIDGET_H
             #define SCIQLOP_VISUALIZATIONZONEWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
-            class VisualizationGraphWidget;
             #include <QWidget>
             namespace Ui {
             class VisualizationZoneWidget;
             } // Ui
+            class Variable;
+            class VisualizationGraphWidget;
             class VisualizationZoneWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
-                explicit VisualizationZoneWidget(QWidget *parent = 0);
+                explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationZoneWidget();
                 /// Add a graph widget
                 void addGraph(VisualizationGraphWidget *graphWidget);
-                /// Create a graph using a Variable
+                /**
-                VisualizationGraphWidget *createGraph();
+                 * Creates a graph using a variable. The variable will be displayed in the new graph.
+                 * @param variable the variable for which to create the graph
+                 * @return the pointer to the created graph
+                 */
+                VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable);
                 /// Remove a graph
                 void removeGraph(VisualizationGraphWidget *graph);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidget *visitor) override;
                 void close() override;
                 QString name() const override;
             private:
                 Ui::VisualizationZoneWidget *ui;
             };
             #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H

gui/src/SqpApplication.cpp +11 0

             #include "SqpApplication.h"
             #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
             #include <QThread>
+            #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/VisualizationController.h>
             Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
             class SqpApplication::SqpApplicationPrivate {
             public:
                 SqpApplicationPrivate()
                         : m_DataSourceController{std::make_unique<DataSourceController>()},
+                          m_TimeController{std::make_unique<TimeController>()},
                           m_VariableController{std::make_unique<VariableController>()},
                           m_VisualizationController{std::make_unique<VisualizationController>()}
                 {
                     // /////////////////////////////// //
                     // Connections between controllers //
                     // /////////////////////////////// //
                     // VariableController <-> DataSourceController
                     qRegisterMetaType<std::shared_ptr<IDataProvider> >();
                     connect(m_DataSourceController.get(),
                             SIGNAL(variableCreationRequested(const QString &, std::shared_ptr<IDataProvider>)),
                             m_VariableController.get(),
                             SLOT(createVariable(const QString &, std::shared_ptr<IDataProvider>)));
                     // VariableController <-> VisualizationController
                     qRegisterMetaType<std::shared_ptr<Variable> >();
                     connect(m_VariableController.get(), SIGNAL(variableCreated(std::shared_ptr<Variable>)),
                             m_VisualizationController.get(),
                             SIGNAL(variableCreated(std::shared_ptr<Variable>)));
                     m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
                     m_VariableController->moveToThread(&m_VariableControllerThread);
                     m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
+                    // Additionnal init
+                    m_VariableController->setTimeController(m_TimeController.get());
                 }
                 virtual ~SqpApplicationPrivate()
                 {
                     qCInfo(LOG_SqpApplication()) << tr("SqpApplicationPrivate destruction");
                     m_DataSourceControllerThread.quit();
                     m_DataSourceControllerThread.wait();
                     m_VariableControllerThread.quit();
                     m_VariableControllerThread.wait();
                     m_VisualizationControllerThread.quit();
                     m_VisualizationControllerThread.wait();
                 }
                 std::unique_ptr<DataSourceController> m_DataSourceController;
                 std::unique_ptr<VariableController> m_VariableController;
+                std::unique_ptr<TimeController> m_TimeController;
                 std::unique_ptr<VisualizationController> m_VisualizationController;
                 QThread m_DataSourceControllerThread;
                 QThread m_VariableControllerThread;
                 QThread m_VisualizationControllerThread;
             };
             SqpApplication::SqpApplication(int &argc, char **argv)
                     : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
             {
                 qCInfo(LOG_SqpApplication()) << tr("SqpApplication construction");
                 connect(&impl->m_DataSourceControllerThread, &QThread::started,
                         impl->m_DataSourceController.get(), &DataSourceController::initialize);
                 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
                         impl->m_DataSourceController.get(), &DataSourceController::finalize);
                 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
                         &VariableController::initialize);
                 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
                         &VariableController::finalize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::started,
                         impl->m_VisualizationController.get(), &VisualizationController::initialize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
                         impl->m_VisualizationController.get(), &VisualizationController::finalize);
                 impl->m_DataSourceControllerThread.start();
                 impl->m_VariableControllerThread.start();
                 impl->m_VisualizationControllerThread.start();
             }
             SqpApplication::~SqpApplication()
             {
             }
             void SqpApplication::initialize()
             {
             }
             DataSourceController &SqpApplication::dataSourceController() noexcept
             {
                 return *impl->m_DataSourceController;
             }
+            TimeController &SqpApplication::timeController() noexcept
+            {
+                return *impl->m_TimeController;
+            }
             VariableController &SqpApplication::variableController() noexcept
             {
                 return *impl->m_VariableController;
             }
             VisualizationController &SqpApplication::visualizationController() noexcept
             {
                 return *impl->m_VisualizationController;
             }

gui/src/TimeWidget/TimeWidget.cpp +17 0

             #include "TimeWidget/TimeWidget.h"
             #include "ui_TimeWidget.h"
             TimeWidget::TimeWidget(QWidget *parent) : QWidget{parent}, ui{new Ui::TimeWidget}
             {
                 ui->setupUi(this);
+                // Connection
+                connect(ui->startDateTimeEdit, &QDateTimeEdit::dateTimeChanged, this,
+                        &TimeWidget::onTimeUpdateRequested);
+                connect(ui->endDateTimeEdit, &QDateTimeEdit::dateTimeChanged, this,
+                        &TimeWidget::onTimeUpdateRequested);
             }
             TimeWidget::~TimeWidget()
             {
                 delete ui;
             }
+            void TimeWidget::onTimeUpdateRequested()
+            {
+                auto dateTime = SqpDateTime{
+                    static_cast<double>(ui->startDateTimeEdit->dateTime().toMSecsSinceEpoch() / 1000.),
+                    static_cast<double>(ui->endDateTimeEdit->dateTime().toMSecsSinceEpoch()) / 1000.};
+                emit timeUpdated(std::move(dateTime));
+            }

gui/src/Visualization/VisualizationGraphWidget.cpp +11 -2

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/GraphPlottablesFactory.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Variable/Variable.h>
             #include <unordered_map>
             namespace {
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                 // 1 variable -> n qcpplot
                 std::unordered_map<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMap;
             };
-            VisualizationGraphWidget::VisualizationGraphWidget(QWidget *parent)
+            VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
             {
                 ui->setupUi(this);
+                // qcpplot title
+                ui->widget->plotLayout()->insertRow(0);
+                ui->widget->plotLayout()->addElement(0, 0, new QCPTextElement{ui->widget, name});
                 // Set qcpplot properties :
                 // - Drag (on x-axis) and zoom are enabled
                 // - 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::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = GraphPlottablesFactory::create(variable, *ui->widget);
                 for (auto createdPlottable : qAsConst(createdPlottables)) {
                     impl->m_VariableToPlotMap.insert({variable, createdPlottable});
                 }
             }
             void VisualizationGraphWidget::accept(IVisualizationWidget *visitor)
             {
                 // TODO: manage the visitor
             }
             void VisualizationGraphWidget::close()
             {
                 // The main view cannot be directly closed.
                 return;
             }
             QString VisualizationGraphWidget::name() const
             {
-                return QStringLiteral("MainView");
+                if (auto title = dynamic_cast<QCPTextElement *>(ui->widget->plotLayout()->elementAt(0))) {
+                    return title->text();
+                }
+                else {
+                    return QString{};
+                }
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto zoomOrientations = QFlags<Qt::Orientation>{};
                 // Lambda that enables a zoom orientation if the key modifier related to this orientation has
                 // been pressed
                 auto enableOrientation
                     = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
                           auto orientationEnabled = event->modifiers().testFlag(modifier);
                           zoomOrientations.setFlag(orientation, orientationEnabled);
                       };
                 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
                 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
                 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
             }

gui/src/Visualization/VisualizationTabWidget.cpp +33 -5

             #include "Visualization/VisualizationTabWidget.h"
             #include "ui_VisualizationTabWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
+            namespace {
-            VisualizationTabWidget::VisualizationTabWidget(QWidget *parent)
+            /// Generates a default name for a new zone, according to the number of zones already displayed in
-                    : QWidget{parent}, ui{new Ui::VisualizationTabWidget}
+            /// the tab
+            QString defaultZoneName(const QLayout &layout)
+            {
+                auto count = 0;
+                for (auto i = 0; i < layout.count(); ++i) {
+                    if (dynamic_cast<VisualizationZoneWidget *>(layout.itemAt(i)->widget())) {
+                        count++;
+                    }
+                }
+                return QObject::tr("Zone %1").arg(count + 1);
+            }
+            } // namespace
+            struct VisualizationTabWidget::VisualizationTabWidgetPrivate {
+                explicit VisualizationTabWidgetPrivate(const QString &name) : m_Name{name} {}
+                QString m_Name;
+            };
+            VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *parent)
+                    : QWidget{parent},
+                      ui{new Ui::VisualizationTabWidget},
+                      impl{spimpl::make_unique_impl<VisualizationTabWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
             }
             VisualizationTabWidget::~VisualizationTabWidget()
             {
                 delete ui;
             }
             void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
             {
                 this->layout()->addWidget(zoneWidget);
             }
-            VisualizationZoneWidget *VisualizationTabWidget::createZone()
+            VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
             {
-                auto zoneWidget = new VisualizationZoneWidget{this};
+                auto zoneWidget = new VisualizationZoneWidget{defaultZoneName(*layout()), this};
                 this->addZone(zoneWidget);
+                // Creates a new graph into the zone
+                zoneWidget->createGraph(variable);
                 return zoneWidget;
             }
             void VisualizationTabWidget::removeZone(VisualizationZoneWidget *zone)
             {
             }
             void VisualizationTabWidget::accept(IVisualizationWidget *visitor)
             {
                 // TODO: manage the visitor
             }
             void VisualizationTabWidget::close()
             {
                 // The main view cannot be directly closed.
                 return;
             }
             QString VisualizationTabWidget::name() const
             {
-                return QStringLiteral("MainView");
+                return impl->m_Name;
             }

gui/src/Visualization/VisualizationWidget.cpp +7 -12

             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/qcustomplot.h"
             #include "ui_VisualizationWidget.h"
             #include <QToolButton>
             Q_LOGGING_CATEGORY(LOG_VisualizationWidget, "VisualizationWidget")
             VisualizationWidget::VisualizationWidget(QWidget *parent)
                     : QWidget{parent}, ui{new Ui::VisualizationWidget}
             {
                 ui->setupUi(this);
                 auto addTabViewButton = new QToolButton{ui->tabWidget};
                 addTabViewButton->setText(tr("Add View"));
                 addTabViewButton->setCursor(Qt::ArrowCursor);
                 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;
                     tabViewCornerWidget->setMinimumHeight(height);
                     tabViewCornerWidget->setMinimumWidth(width);
                     ui->tabWidget->setMinimumHeight(height);
                     ui->tabWidget->setMinimumWidth(width);
                 };
                 auto addTabView = [this, enableMinimumCornerWidgetSize]() {
-                    auto index = ui->tabWidget->addTab(new VisualizationTabWidget(ui->tabWidget),
+                    auto widget = new VisualizationTabWidget{QString{"View %1"}.arg(ui->tabWidget->count() + 1),
-                                                       QString("View %1").arg(ui->tabWidget->count() + 1));
+                                                             ui->tabWidget};
+                    auto index = ui->tabWidget->addTab(widget, widget->name());
                     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) {
                         enableMinimumCornerWidgetSize(true);
                     }
                     ui->tabWidget->removeTab(index);
                     qCInfo(LOG_VisualizationWidget()) << tr("remove the tab of index %1").arg(index);
                 };
                 ui->tabWidget->setTabsClosable(true);
                 connect(addTabViewButton, &QToolButton::clicked, addTabView);
                 connect(ui->tabWidget, &QTabWidget::tabCloseRequested, removeTabView);
+                // Adds default tab
+                addTabView();
             }
             VisualizationWidget::~VisualizationWidget()
             {
                 delete ui;
             }
             void VisualizationWidget::addTab(VisualizationTabWidget *tabWidget)
             {
                 // NOTE: check is this method has to be deleted because of its dupplicated version visible as
                 // lambda function (in the constructor)
             }
             VisualizationTabWidget *VisualizationWidget::createTab()
             {
             }
             void VisualizationWidget::removeTab(VisualizationTabWidget *tab)
             {
                 // NOTE: check is this method has to be deleted because of its dupplicated version visible as
                 // lambda function (in the constructor)
             }
             void VisualizationWidget::accept(IVisualizationWidget *visitor)
             {
                 // TODO: manage the visitor
             }
             void VisualizationWidget::close()
             {
                 // The main view cannot be directly closed.
                 return;
             }
             QString VisualizationWidget::name() const
             {
                 return QStringLiteral("MainView");
             }
             void VisualizationWidget::displayVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (auto currentTab = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->currentWidget())) {
-                    if (auto newZone = currentTab->createZone()) {
+                    if (!currentTab->createZone(variable)) {
-                        if (auto newGraph = newZone->createGraph()) {
-                            newGraph->addVariable(variable);
-                        else {
-                            qCCritical(LOG_VisualizationWidget())
-                                << tr("Can't display the variable : can't create the graph");
-                    else {
                         qCCritical(LOG_VisualizationWidget())
                             << tr("Can't display the variable : can't create a new zone in the current tab");
                     }
                 }
                 else {
                     qCCritical(LOG_VisualizationWidget())
                         << tr("Can't display the variable : there is no current tab");
                 }
             }

gui/src/Visualization/VisualizationZoneWidget.cpp +27 -4

             #include "Visualization/VisualizationZoneWidget.h"
             #include "ui_VisualizationZoneWidget.h"
             #include "Visualization/VisualizationGraphWidget.h"
-            VisualizationZoneWidget::VisualizationZoneWidget(QWidget *parent)
+            namespace {
+            /// Generates a default name for a new graph, according to the number of graphs already displayed in
+            /// the zone
+            QString defaultGraphName(const QLayout &layout)
+            {
+                auto count = 0;
+                for (auto i = 0; i < layout.count(); ++i) {
+                    if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
+                        count++;
+                    }
+                }
+                return QObject::tr("Graph %1").arg(count + 1);
+            }
+            } // namespace
+            VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
                     : QWidget{parent}, ui{new Ui::VisualizationZoneWidget}
             {
                 ui->setupUi(this);
+                ui->zoneNameLabel->setText(name);
             }
             VisualizationZoneWidget::~VisualizationZoneWidget()
             {
                 delete ui;
             }
             void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
             {
                 ui->visualizationZoneFrame->layout()->addWidget(graphWidget);
             }
-            VisualizationGraphWidget *VisualizationZoneWidget::createGraph()
+            VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
             {
-                auto graphWidget = new VisualizationGraphWidget{this};
+                auto graphWidget = new VisualizationGraphWidget{
+                    defaultGraphName(*ui->visualizationZoneFrame->layout()), this};
                 this->addGraph(graphWidget);
+                graphWidget->addVariable(variable);
                 return graphWidget;
             }
             void VisualizationZoneWidget::removeGraph(VisualizationGraphWidget *graph)
             {
             }
             void VisualizationZoneWidget::accept(IVisualizationWidget *visitor)
             {
                 // TODO: manage the visitor
             }
             void VisualizationZoneWidget::close()
             {
                 // The main view cannot be directly closed.
                 return;
             }
             QString VisualizationZoneWidget::name() const
             {
-                return QStringLiteral("MainView");
+                return ui->zoneNameLabel->text();
             }

gui/ui/Visualization/VisualizationWidget.ui +1 -14

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>VisualizationWidget</class>
              <widget class="QWidget" name="VisualizationWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>400</width>
                 <height>300</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QVBoxLayout" name="verticalLayout">
                <item>
                 <widget class="QTabWidget" name="tabWidget">
                  <property name="currentIndex">
-                  <number>0</number>
+                  <number>-1</number>
                  </property>
-                 <widget class="VisualizationTabWidget" name="firstView">
-                  <attribute name="title">
-                   <string>View 1</string>
-                  </attribute>
-                 </widget>
                 </widget>
                </item>
               </layout>
              </widget>
-             <customwidgets>
-              <customwidget>
-               <class>VisualizationTabWidget</class>
-               <extends>QWidget</extends>
-               <header location="global">Visualization/VisualizationTabWidget.h</header>
-               <container>1</container>
-              </customwidget>
-             </customwidgets>
              <resources/>
              <connections/>
             </ui>

gui/ui/Visualization/VisualizationZoneWidget.ui +28 -2

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>VisualizationZoneWidget</class>
              <widget class="QWidget" name="VisualizationZoneWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>400</width>
                 <height>300</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QVBoxLayout" name="verticalLayout_2">
-               <property name="spacing">
+               <item>
-                <number>3</number>
+                <widget class="QWidget" name="infobar" native="true">
+                 <property name="sizePolicy">
+                  <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
+                   <horstretch>0</horstretch>
+                   <verstretch>0</verstretch>
+                  </sizepolicy>
                  </property>
+                 <layout class="QHBoxLayout" name="horizontalLayout">
                   <property name="leftMargin">
                    <number>0</number>
                   </property>
                   <property name="topMargin">
                    <number>0</number>
                   </property>
                   <property name="rightMargin">
                    <number>0</number>
                   </property>
                   <property name="bottomMargin">
                    <number>0</number>
                   </property>
                   <item>
+                   <widget class="QLabel" name="zoneNameLabel">
+                    <property name="styleSheet">
+                     <string notr="true">color: rgb(127, 127, 127);
+            </string>
+                    </property>
+                    <property name="text">
+                     <string>TextLabel</string>
+                    </property>
+                   </widget>
+                  </item>
+                 </layout>
+                </widget>
+               </item>
+               <item>
                 <widget class="QFrame" name="visualizationZoneFrame">
+                 <property name="sizePolicy">
+                  <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
+                   <horstretch>0</horstretch>
+                   <verstretch>0</verstretch>
+                  </sizepolicy>
+                 </property>
                  <property name="frameShape">
                   <enum>QFrame::Box</enum>
                  </property>
                  <property name="frameShadow">
                   <enum>QFrame::Raised</enum>
                  </property>
                  <property name="lineWidth">
                   <number>1</number>
                  </property>
                  <layout class="QVBoxLayout" name="verticalLayout"/>
                 </widget>
                </item>
               </layout>
              </widget>
              <resources/>
              <connections/>
             </ui>

gui/vera-exclusions/exclusions.txt +2 0

             \.h:\d+:.IPSIS_S04.*found: ui
             qcustomplot\.h:\d+:.IPSIS
             qcustomplot\.cpp:\d+:.IPSIS
             # Ignore false positive relative to App macro
             SqpApplication\.h:\d+:.IPSIS_S03.*found: sqpApp
             SqpApplication\.h:\d+:.IPSIS_S04_VARIABLE.*found: sqpApp
             # Ignore false positive relative to unnamed namespace
             DataSourceTreeWidgetItem\.cpp:\d+:.*IPSIS_F13.*
+            VisualizationTabWidget\.cpp:\d+:.*IPSIS_F13.*
+            VisualizationZoneWidget\.cpp:\d+:.*IPSIS_F13.*

plugins/mockplugin/src/CosinusProvider.cpp +4 -2

             #include "CosinusProvider.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <cmath>
             std::unique_ptr<IDataSeries>
             CosinusProvider::retrieveData(const DataProviderParameters &parameters) const
             {
+                auto dateTime = parameters.m_Time;
                 // Gets the timerange from the parameters
-                auto start = parameters.m_TStart;
+                auto start = dateTime.m_TStart;
-                auto end = parameters.m_TEnd;
+                auto end = dateTime.m_TEnd;
                 // We assure that timerange is valid
                 if (end < start) {
                     std::swap(start, end);
                 }
                 // Generates scalar series containing cosinus values (one value per second)
                 auto scalarSeries
                     = std::make_unique<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));
                 }
                 return scalarSeries;
             }

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