##// END OF EJS Templates
HG_REPOSITORIES » LPP » SciQLOP_Repos » SciQLop
RSS
Time widget is now used with the variable createion request
perrinel -
r193:3a849a66be09
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,48 +1,51
1 #ifndef SCIQLOP_VARIABLECONTROLLER_H
1 #ifndef SCIQLOP_VARIABLECONTROLLER_H
2 #define SCIQLOP_VARIABLECONTROLLER_H
2 #define SCIQLOP_VARIABLECONTROLLER_H
3
3
4 #include <QLoggingCategory>
4 #include <QLoggingCategory>
5 #include <QObject>
5 #include <QObject>
6
6
7 #include <Common/spimpl.h>
7 #include <Common/spimpl.h>
8
8
9 class IDataProvider;
9 class IDataProvider;
10 class TimeController;
10 class Variable;
11 class Variable;
11 class VariableModel;
12 class VariableModel;
12
13
13 Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
14 Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
14
15
15 /**
16 /**
16 * @brief The VariableController class aims to handle the variables in SciQlop.
17 * @brief The VariableController class aims to handle the variables in SciQlop.
17 */
18 */
18 class VariableController : public QObject {
19 class VariableController : public QObject {
19 Q_OBJECT
20 Q_OBJECT
20 public:
21 public:
21 explicit VariableController(QObject *parent = 0);
22 explicit VariableController(QObject *parent = 0);
22 virtual ~VariableController();
23 virtual ~VariableController();
23
24
24 VariableModel *variableModel() noexcept;
25 VariableModel *variableModel() noexcept;
25
26
27 void setTimeController(TimeController *timeController) noexcept;
28
26 signals:
29 signals:
27 /// Signal emitted when a variable has been created
30 /// Signal emitted when a variable has been created
28 void variableCreated(std::shared_ptr<Variable> variable);
31 void variableCreated(std::shared_ptr<Variable> variable);
29
32
30 public slots:
33 public slots:
31 /**
34 /**
32 * Creates a new variable and adds it to the model
35 * Creates a new variable and adds it to the model
33 * @param name the name of the new variable
36 * @param name the name of the new variable
34 * @param provider the data provider for the new variable
37 * @param provider the data provider for the new variable
35 */
38 */
36 void createVariable(const QString &name, std::shared_ptr<IDataProvider> provider) noexcept;
39 void createVariable(const QString &name, std::shared_ptr<IDataProvider> provider) noexcept;
37
40
38 void initialize();
41 void initialize();
39 void finalize();
42 void finalize();
40
43
41 private:
44 private:
42 void waitForFinish();
45 void waitForFinish();
43
46
44 class VariableControllerPrivate;
47 class VariableControllerPrivate;
45 spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
48 spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
46 };
49 };
47
50
48 #endif // SCIQLOP_VARIABLECONTROLLER_H
51 #endif // SCIQLOP_VARIABLECONTROLLER_H
Show file before | Show file after | Hide comments
@@ -1,91 +1,110
1 #include <Variable/VariableController.h>
1 #include <Variable/VariableController.h>
2 #include <Variable/VariableModel.h>
2 #include <Variable/VariableModel.h>
3
3
4 #include <Data/DataProviderParameters.h>
4 #include <Data/DataProviderParameters.h>
5 #include <Data/IDataProvider.h>
5 #include <Data/IDataProvider.h>
6 #include <Data/IDataSeries.h>
6 #include <Data/IDataSeries.h>
7 #include <Time/TimeController.h>
7
8
8 #include <QDateTime>
9 #include <QDateTime>
9 #include <QMutex>
10 #include <QMutex>
10 #include <QThread>
11 #include <QThread>
11
12
12 Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
13 Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
13
14
14 namespace {
15 namespace {
15
16
16 /// @todo Generates default dataseries, according to the provider passed in parameter. This method
17 /// @todo Generates default dataseries, according to the provider passed in parameter. This method
17 /// will be deleted when the timerange is recovered from SciQlop
18 /// will be deleted when the timerange is recovered from SciQlop
18 std::unique_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider) noexcept
19 std::unique_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider,
20 const SqpDateTime &dateTime) noexcept
19 {
21 {
20 auto parameters = DataProviderParameters{
22 auto parameters = DataProviderParameters{dateTime};
21 // Remarks : we don't use toSecsSinceEpoch() here (method is for Qt 5.8 or above)
22 static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 00}}.toMSecsSinceEpoch()
23 / 1000.),
24 static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 01}}.toMSecsSinceEpoch())
25 / 1000.};
26
23
27 return provider.retrieveData(parameters);
24 return provider.retrieveData(parameters);
28 }
25 }
29
26
30 } // namespace
27 } // namespace
31
28
32 struct VariableController::VariableControllerPrivate {
29 struct VariableController::VariableControllerPrivate {
33 explicit VariableControllerPrivate(VariableController *parent)
30 explicit VariableControllerPrivate(VariableController *parent)
34 : m_WorkingMutex{}, m_VariableModel{new VariableModel{parent}}
31 : m_WorkingMutex{}, m_VariableModel{new VariableModel{parent}}
35 {
32 {
36 }
33 }
37
34
38 QMutex m_WorkingMutex;
35 QMutex m_WorkingMutex;
39 /// Variable model. The VariableController has the ownership
36 /// Variable model. The VariableController has the ownership
40 VariableModel *m_VariableModel;
37 VariableModel *m_VariableModel;
38
39 TimeController *m_TimeController;
41 };
40 };
42
41
43 VariableController::VariableController(QObject *parent)
42 VariableController::VariableController(QObject *parent)
44 : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
43 : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
45 {
44 {
46 qCDebug(LOG_VariableController()) << tr("VariableController construction")
45 qCDebug(LOG_VariableController()) << tr("VariableController construction")
47 << QThread::currentThread();
46 << QThread::currentThread();
48 }
47 }
49
48
50 VariableController::~VariableController()
49 VariableController::~VariableController()
51 {
50 {
52 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
51 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
53 << QThread::currentThread();
52 << QThread::currentThread();
54 this->waitForFinish();
53 this->waitForFinish();
55 }
54 }
56
55
57 VariableModel *VariableController::variableModel() noexcept
56 VariableModel *VariableController::variableModel() noexcept
58 {
57 {
59 return impl->m_VariableModel;
58 return impl->m_VariableModel;
60 }
59 }
61
60
61 void VariableController::setTimeController(TimeController *timeController) noexcept
62 {
63 impl->m_TimeController = timeController;
64 }
65
62 void VariableController::createVariable(const QString &name,
66 void VariableController::createVariable(const QString &name,
63 std::shared_ptr<IDataProvider> provider) noexcept
67 std::shared_ptr<IDataProvider> provider) noexcept
64 {
68 {
69 // TORM
70 // auto dateTime = SqpDateTime{
71 // // Remarks : we don't use toSecsSinceEpoch() here (method is for Qt 5.8 or above)
72 // static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 00}}.toMSecsSinceEpoch()
73 // / 1000.),
74 // static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 01}}.toMSecsSinceEpoch())
75 // / 1000.};
76
77 if (!impl->m_TimeController) {
78 qCCritical(LOG_VariableController())
79 << tr("Impossible to create variable: The time controller is null");
80 return;
81 }
82
83
65 /// @todo : for the moment :
84 /// @todo : for the moment :
66 /// - the provider is only used to retrieve data from the variable for its initialization, but
85 /// - the provider is only used to retrieve data from the variable for its initialization, but
67 /// it will be retained later
86 /// it will be retained later
68 /// - default data are generated for the variable, without taking into account the timerange set
87 /// - default data are generated for the variable, without taking into account the timerange set
69 /// in sciqlop
88 /// in sciqlop
70 if (auto newVariable
89 if (auto newVariable = impl->m_VariableModel->createVariable(
71 = impl->m_VariableModel->createVariable(name, generateDefaultDataSeries(*provider))) {
90 name, generateDefaultDataSeries(*provider, impl->m_TimeController->dateTime()))) {
72 emit variableCreated(newVariable);
91 emit variableCreated(newVariable);
73 }
92 }
74 }
93 }
75
94
76 void VariableController::initialize()
95 void VariableController::initialize()
77 {
96 {
78 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
97 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
79 impl->m_WorkingMutex.lock();
98 impl->m_WorkingMutex.lock();
80 qCDebug(LOG_VariableController()) << tr("VariableController init END");
99 qCDebug(LOG_VariableController()) << tr("VariableController init END");
81 }
100 }
82
101
83 void VariableController::finalize()
102 void VariableController::finalize()
84 {
103 {
85 impl->m_WorkingMutex.unlock();
104 impl->m_WorkingMutex.unlock();
86 }
105 }
87
106
88 void VariableController::waitForFinish()
107 void VariableController::waitForFinish()
89 {
108 {
90 QMutexLocker locker{&impl->m_WorkingMutex};
109 QMutexLocker locker{&impl->m_WorkingMutex};
91 }
110 }
Show file before | Show file after | Hide comments
@@ -1,48 +1,50
1 #ifndef SCIQLOP_SQPAPPLICATION_H
1 #ifndef SCIQLOP_SQPAPPLICATION_H
2 #define SCIQLOP_SQPAPPLICATION_H
2 #define SCIQLOP_SQPAPPLICATION_H
3
3
4 #include "SqpApplication.h"
4 #include "SqpApplication.h"
5
5
6 #include <QApplication>
6 #include <QApplication>
7 #include <QLoggingCategory>
7 #include <QLoggingCategory>
8
8
9 #include <Common/spimpl.h>
9 #include <Common/spimpl.h>
10
10
11 Q_DECLARE_LOGGING_CATEGORY(LOG_SqpApplication)
11 Q_DECLARE_LOGGING_CATEGORY(LOG_SqpApplication)
12
12
13 #if defined(sqpApp)
13 #if defined(sqpApp)
14 #undef sqpApp
14 #undef sqpApp
15 #endif
15 #endif
16 #define sqpApp (static_cast<SqpApplication *>(QCoreApplication::instance()))
16 #define sqpApp (static_cast<SqpApplication *>(QCoreApplication::instance()))
17
17
18 class DataSourceController;
18 class DataSourceController;
19 class TimeController;
19 class VariableController;
20 class VariableController;
20 class VisualizationController;
21 class VisualizationController;
21
22
22 /**
23 /**
23 * @brief The SqpApplication class aims to make the link between SciQlop
24 * @brief The SqpApplication class aims to make the link between SciQlop
24 * and its plugins. This is the intermediate class that SciQlop has to use
25 * and its plugins. This is the intermediate class that SciQlop has to use
25 * in the way to connect a data source. Please first use load method to initialize
26 * in the way to connect a data source. Please first use load method to initialize
26 * a plugin specified by its metadata name (JSON plugin source) then others specifics
27 * a plugin specified by its metadata name (JSON plugin source) then others specifics
27 * method will be able to access it.
28 * method will be able to access it.
28 * You can load a data source driver plugin then create a data source.
29 * You can load a data source driver plugin then create a data source.
29 */
30 */
30
31
31 class SqpApplication : public QApplication {
32 class SqpApplication : public QApplication {
32 Q_OBJECT
33 Q_OBJECT
33 public:
34 public:
34 explicit SqpApplication(int &argc, char **argv);
35 explicit SqpApplication(int &argc, char **argv);
35 virtual ~SqpApplication();
36 virtual ~SqpApplication();
36 void initialize();
37 void initialize();
37
38
38 /// Accessors for the differents sciqlop controllers
39 /// Accessors for the differents sciqlop controllers
39 DataSourceController &dataSourceController() noexcept;
40 DataSourceController &dataSourceController() noexcept;
41 TimeController &timeController() noexcept;
40 VariableController &variableController() noexcept;
42 VariableController &variableController() noexcept;
41 VisualizationController &visualizationController() noexcept;
43 VisualizationController &visualizationController() noexcept;
42
44
43 private:
45 private:
44 class SqpApplicationPrivate;
46 class SqpApplicationPrivate;
45 spimpl::unique_impl_ptr<SqpApplicationPrivate> impl;
47 spimpl::unique_impl_ptr<SqpApplicationPrivate> impl;
46 };
48 };
47
49
48 #endif // SCIQLOP_SQPAPPLICATION_H
50 #endif // SCIQLOP_SQPAPPLICATION_H
Show file before | Show file after | Hide comments
@@ -1,109 +1,120
1 #include "SqpApplication.h"
1 #include "SqpApplication.h"
2
2
3 #include <Data/IDataProvider.h>
3 #include <Data/IDataProvider.h>
4 #include <DataSource/DataSourceController.h>
4 #include <DataSource/DataSourceController.h>
5 #include <QThread>
5 #include <QThread>
6 #include <Time/TimeController.h>
6 #include <Variable/Variable.h>
7 #include <Variable/Variable.h>
7 #include <Variable/VariableController.h>
8 #include <Variable/VariableController.h>
8 #include <Visualization/VisualizationController.h>
9 #include <Visualization/VisualizationController.h>
9
10
10 Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
11 Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
11
12
12 class SqpApplication::SqpApplicationPrivate {
13 class SqpApplication::SqpApplicationPrivate {
13 public:
14 public:
14 SqpApplicationPrivate()
15 SqpApplicationPrivate()
15 : m_DataSourceController{std::make_unique<DataSourceController>()},
16 : m_DataSourceController{std::make_unique<DataSourceController>()},
17 m_TimeController{std::make_unique<TimeController>()},
16 m_VariableController{std::make_unique<VariableController>()},
18 m_VariableController{std::make_unique<VariableController>()},
17 m_VisualizationController{std::make_unique<VisualizationController>()}
19 m_VisualizationController{std::make_unique<VisualizationController>()}
18 {
20 {
19 // /////////////////////////////// //
21 // /////////////////////////////// //
20 // Connections between controllers //
22 // Connections between controllers //
21 // /////////////////////////////// //
23 // /////////////////////////////// //
22
24
23 // VariableController <-> DataSourceController
25 // VariableController <-> DataSourceController
24 qRegisterMetaType<std::shared_ptr<IDataProvider> >();
26 qRegisterMetaType<std::shared_ptr<IDataProvider> >();
25 connect(m_DataSourceController.get(),
27 connect(m_DataSourceController.get(),
26 SIGNAL(variableCreationRequested(const QString &, std::shared_ptr<IDataProvider>)),
28 SIGNAL(variableCreationRequested(const QString &, std::shared_ptr<IDataProvider>)),
27 m_VariableController.get(),
29 m_VariableController.get(),
28 SLOT(createVariable(const QString &, std::shared_ptr<IDataProvider>)));
30 SLOT(createVariable(const QString &, std::shared_ptr<IDataProvider>)));
29
31
30 // VariableController <-> VisualizationController
32 // VariableController <-> VisualizationController
31 qRegisterMetaType<std::shared_ptr<Variable> >();
33 qRegisterMetaType<std::shared_ptr<Variable> >();
32 connect(m_VariableController.get(), SIGNAL(variableCreated(std::shared_ptr<Variable>)),
34 connect(m_VariableController.get(), SIGNAL(variableCreated(std::shared_ptr<Variable>)),
33 m_VisualizationController.get(),
35 m_VisualizationController.get(),
34 SIGNAL(variableCreated(std::shared_ptr<Variable>)));
36 SIGNAL(variableCreated(std::shared_ptr<Variable>)));
35
37
36 m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
38 m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
37 m_VariableController->moveToThread(&m_VariableControllerThread);
39 m_VariableController->moveToThread(&m_VariableControllerThread);
38 m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
40 m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
41
42 // Additionnal init
43 m_VariableController->setTimeController(m_TimeController.get());
39 }
44 }
40
45
41 virtual ~SqpApplicationPrivate()
46 virtual ~SqpApplicationPrivate()
42 {
47 {
43 qCInfo(LOG_SqpApplication()) << tr("SqpApplicationPrivate destruction");
48 qCInfo(LOG_SqpApplication()) << tr("SqpApplicationPrivate destruction");
44 m_DataSourceControllerThread.quit();
49 m_DataSourceControllerThread.quit();
45 m_DataSourceControllerThread.wait();
50 m_DataSourceControllerThread.wait();
46
51
47 m_VariableControllerThread.quit();
52 m_VariableControllerThread.quit();
48 m_VariableControllerThread.wait();
53 m_VariableControllerThread.wait();
49
54
50 m_VisualizationControllerThread.quit();
55 m_VisualizationControllerThread.quit();
51 m_VisualizationControllerThread.wait();
56 m_VisualizationControllerThread.wait();
52 }
57 }
53
58
54 std::unique_ptr<DataSourceController> m_DataSourceController;
59 std::unique_ptr<DataSourceController> m_DataSourceController;
55 std::unique_ptr<VariableController> m_VariableController;
60 std::unique_ptr<VariableController> m_VariableController;
61 std::unique_ptr<TimeController> m_TimeController;
56 std::unique_ptr<VisualizationController> m_VisualizationController;
62 std::unique_ptr<VisualizationController> m_VisualizationController;
57 QThread m_DataSourceControllerThread;
63 QThread m_DataSourceControllerThread;
58 QThread m_VariableControllerThread;
64 QThread m_VariableControllerThread;
59 QThread m_VisualizationControllerThread;
65 QThread m_VisualizationControllerThread;
60 };
66 };
61
67
62
68
63 SqpApplication::SqpApplication(int &argc, char **argv)
69 SqpApplication::SqpApplication(int &argc, char **argv)
64 : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
70 : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
65 {
71 {
66 qCInfo(LOG_SqpApplication()) << tr("SqpApplication construction");
72 qCInfo(LOG_SqpApplication()) << tr("SqpApplication construction");
67
73
68 connect(&impl->m_DataSourceControllerThread, &QThread::started,
74 connect(&impl->m_DataSourceControllerThread, &QThread::started,
69 impl->m_DataSourceController.get(), &DataSourceController::initialize);
75 impl->m_DataSourceController.get(), &DataSourceController::initialize);
70 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
76 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
71 impl->m_DataSourceController.get(), &DataSourceController::finalize);
77 impl->m_DataSourceController.get(), &DataSourceController::finalize);
72
78
73 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
79 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
74 &VariableController::initialize);
80 &VariableController::initialize);
75 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
81 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
76 &VariableController::finalize);
82 &VariableController::finalize);
77
83
78 connect(&impl->m_VisualizationControllerThread, &QThread::started,
84 connect(&impl->m_VisualizationControllerThread, &QThread::started,
79 impl->m_VisualizationController.get(), &VisualizationController::initialize);
85 impl->m_VisualizationController.get(), &VisualizationController::initialize);
80 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
86 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
81 impl->m_VisualizationController.get(), &VisualizationController::finalize);
87 impl->m_VisualizationController.get(), &VisualizationController::finalize);
82
88
83 impl->m_DataSourceControllerThread.start();
89 impl->m_DataSourceControllerThread.start();
84 impl->m_VariableControllerThread.start();
90 impl->m_VariableControllerThread.start();
85 impl->m_VisualizationControllerThread.start();
91 impl->m_VisualizationControllerThread.start();
86 }
92 }
87
93
88 SqpApplication::~SqpApplication()
94 SqpApplication::~SqpApplication()
89 {
95 {
90 }
96 }
91
97
92 void SqpApplication::initialize()
98 void SqpApplication::initialize()
93 {
99 {
94 }
100 }
95
101
96 DataSourceController &SqpApplication::dataSourceController() noexcept
102 DataSourceController &SqpApplication::dataSourceController() noexcept
97 {
103 {
98 return *impl->m_DataSourceController;
104 return *impl->m_DataSourceController;
99 }
105 }
100
106
107 TimeController &SqpApplication::timeController() noexcept
108 {
109 return *impl->m_TimeController;
110 }
111
101 VariableController &SqpApplication::variableController() noexcept
112 VariableController &SqpApplication::variableController() noexcept
102 {
113 {
103 return *impl->m_VariableController;
114 return *impl->m_VariableController;
104 }
115 }
105
116
106 VisualizationController &SqpApplication::visualizationController() noexcept
117 VisualizationController &SqpApplication::visualizationController() noexcept
107 {
118 {
108 return *impl->m_VisualizationController;
119 return *impl->m_VisualizationController;
109 }
120 }
General Comments 0
You need to be logged in to leave comments. Login now