HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r194:435054a2a67e

Merge branch 'feature/TimeWidgetInUse' into develop

perrinel -

r194:435054a2a67e

parent child

Context file:

r194:435054a2a67e

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

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

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