##// END OF EJS Templates
GIT_REPOSITORIES » LPP » Users » mperrinel » SciQLop-fork
RSS

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Merge pull request 178 from SCIQLOP-Initialisation develop...
leroux -
r363:2c0a115f1697 merge
parent child
Show More
Show file before | Show file after | Hide comments
1 NO CONTENT: new file 100644, binary diff hidden
Show file before | Show file after | Hide comments
1 NO CONTENT: new file 100644, binary diff hidden
Show file before | Show file after | Hide comments
1 NO CONTENT: new file 100644, binary diff hidden
Show file before | Show file after | Hide comments
1 NO CONTENT: new file 100644, binary diff hidden
Show file before | Show file after | Hide comments
@@ -1,73 +1,94
1 1 #ifndef SCIQLOP_DATASOURCEITEM_H
2 2 #define SCIQLOP_DATASOURCEITEM_H
3 3
4 4 #include <Common/spimpl.h>
5 5
6 6 #include <QVariant>
7 7 #include <QVector>
8 8
9 9 class DataSourceItemAction;
10 10
11 11 /**
12 12 * Possible types of an item
13 13 */
14 enum class DataSourceItemType { NODE, PRODUCT };
14 enum class DataSourceItemType { NODE, PRODUCT, COMPONENT };
15 15
16 16 /**
17 17 * @brief The DataSourceItem class aims to represent a structure element of a data source.
18 18 * A data source has a tree structure that is made up of a main DataSourceItem object (root)
19 19 * containing other DataSourceItem objects (children).
20 20 * For each DataSourceItem can be associated a set of data representing it.
21 21 */
22 22 class DataSourceItem {
23 23 public:
24 explicit DataSourceItem(DataSourceItemType type, QVector<QVariant> data = {});
24 /// Key associated with the name of the item
25 static const QString NAME_DATA_KEY;
26
27 explicit DataSourceItem(DataSourceItemType type, const QString &name);
28 explicit DataSourceItem(DataSourceItemType type, QHash<QString, QVariant> data = {});
25 29
26 30 /// @return the actions of the item as a vector
27 31 QVector<DataSourceItemAction *> actions() const noexcept;
28 32
29 33 /**
30 34 * Adds an action to the item. The item takes ownership of the action, and the action is
31 35 * automatically associated to the item
32 36 * @param action the action to add
33 37 */
34 38 void addAction(std::unique_ptr<DataSourceItemAction> action) noexcept;
35 39
36 40 /**
37 41 * Adds a child to the item. The item takes ownership of the child.
38 42 * @param child the child to add
39 43 */
40 44 void appendChild(std::unique_ptr<DataSourceItem> child) noexcept;
41 45
42 46 /**
43 47 * Returns the item's child associated to an index
44 48 * @param childIndex the index to search
45 49 * @return a pointer to the child if index is valid, nullptr otherwise
46 50 */
47 51 DataSourceItem *child(int childIndex) const noexcept;
48 52
49 53 int childCount() const noexcept;
50 54
51 55 /**
52 * Get the data associated to an index
53 * @param dataIndex the index to search
54 * @return the data found if index is valid, default QVariant otherwise
56 * Get the data associated to a key
57 * @param key the key to search
58 * @return the data found if key is valid, default QVariant otherwise
55 59 */
56 QVariant data(int dataIndex) const noexcept;
60 QVariant data(const QString &key) const noexcept;
61
62 /// Gets all data
63 const QHash<QString, QVariant> &data() const noexcept;
64
65 bool isRoot() const noexcept;
57 66
58 67 QString name() const noexcept;
59 68
60 69 /**
61 70 * Get the item's parent
62 71 * @return a pointer to the parent if it exists, nullptr if the item is a root
63 72 */
64 73 DataSourceItem *parentItem() const noexcept;
65 74
75 /**
76 * Sets or appends a value to a key
77 * @param key the key
78 * @param value the value
79 * @param append if true, the value is added to the values already existing for the key,
80 * otherwise it replaces the existing values
81 */
82 void setData(const QString &key, const QVariant &value, bool append = false) noexcept;
83
66 84 DataSourceItemType type() const noexcept;
67 85
86 bool operator==(const DataSourceItem &other);
87 bool operator!=(const DataSourceItem &other);
88
68 89 private:
69 90 class DataSourceItemPrivate;
70 91 spimpl::unique_impl_ptr<DataSourceItemPrivate> impl;
71 92 };
72 93
73 94 #endif // SCIQLOP_DATASOURCEITEMMODEL_H
Show file before | Show file after | Hide comments
@@ -1,82 +1,80
1 1 #ifndef SCIQLOP_VARIABLECONTROLLER_H
2 2 #define SCIQLOP_VARIABLECONTROLLER_H
3 3
4 4 #include <Data/SqpDateTime.h>
5 5
6 6 #include <QLoggingCategory>
7 7 #include <QObject>
8 8
9 9 #include <Common/spimpl.h>
10 10
11 11 class IDataProvider;
12 12 class QItemSelectionModel;
13 13 class TimeController;
14 14 class Variable;
15 15 class VariableModel;
16 16
17 17 Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
18 18
19 19 /**
20 20 * @brief The VariableController class aims to handle the variables in SciQlop.
21 21 */
22 22 class VariableController : public QObject {
23 23 Q_OBJECT
24 24 public:
25 25 explicit VariableController(QObject *parent = 0);
26 26 virtual ~VariableController();
27 27
28 28 VariableModel *variableModel() noexcept;
29 29 QItemSelectionModel *variableSelectionModel() noexcept;
30 30
31 31 void setTimeController(TimeController *timeController) noexcept;
32 32
33 33 /**
34 34 * Deletes from the controller the variable passed in parameter.
35 35 *
36 36 * Delete a variable includes:
37 37 * - the deletion of the various references to the variable in SciQlop
38 38 * - the deletion of the model variable
39 39 * - the deletion of the provider associated with the variable
40 40 * - removing the cache associated with the variable
41 41 *
42 42 * @param variable the variable to delete from the controller.
43 43 */
44 44 void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
45 45
46 46 /**
47 47 * Deletes from the controller the variables passed in parameter.
48 48 * @param variables the variables to delete from the controller.
49 49 * @sa deleteVariable()
50 50 */
51 51 void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
52 52
53 53 signals:
54 54 /// Signal emitted when a variable is about to be deleted from the controller
55 55 void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
56 /// Signal emitted when a variable has been created
57 void variableCreated(std::shared_ptr<Variable> variable);
58 56
59 57 public slots:
60 58 /// Request the data loading of the variable whithin dateTime
61 59 void onRequestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
62 60 /**
63 61 * Creates a new variable and adds it to the model
64 62 * @param name the name of the new variable
65 63 * @param provider the data provider for the new variable
66 64 */
67 65 void createVariable(const QString &name, std::shared_ptr<IDataProvider> provider) noexcept;
68 66
69 67 /// Update the temporal parameters of every selected variable to dateTime
70 68 void onDateTimeOnSelection(const SqpDateTime &dateTime);
71 69
72 70 void initialize();
73 71 void finalize();
74 72
75 73 private:
76 74 void waitForFinish();
77 75
78 76 class VariableControllerPrivate;
79 77 spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
80 78 };
81 79
82 80 #endif // SCIQLOP_VARIABLECONTROLLER_H
Show file before | Show file after | Hide comments
@@ -1,46 +1,44
1 1 #ifndef SCIQLOP_VISUALIZATIONCONTROLLER_H
2 2 #define SCIQLOP_VISUALIZATIONCONTROLLER_H
3 3
4 4 #include <QLoggingCategory>
5 5 #include <QObject>
6 6 #include <QUuid>
7 7
8 8 #include <Common/spimpl.h>
9 9
10 10 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationController)
11 11
12 12 class DataSourceItem;
13 13 class Variable;
14 14
15 15 /**
16 16 * @brief The VisualizationController class aims to make the link between SciQlop and its plugins.
17 17 * This is the intermediate class that SciQlop has to use in the way to connect a data source.
18 18 * Please first use register method to initialize a plugin specified by its metadata name (JSON
19 19 * plugin source) then others specifics method will be able to access it. You can load a data source
20 20 * driver plugin then create a data source.
21 21 */
22 22 class VisualizationController : public QObject {
23 23 Q_OBJECT
24 24 public:
25 25 explicit VisualizationController(QObject *parent = 0);
26 26 virtual ~VisualizationController();
27 27
28 28 signals:
29 29 /// Signal emitted when a variable is about to be deleted from SciQlop
30 30 void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
31 /// Signal emitted when a variable has been created in SciQlop
32 void variableCreated(std::shared_ptr<Variable> variable);
33 31
34 32 public slots:
35 33 /// Manage init/end of the controller
36 34 void initialize();
37 35 void finalize();
38 36
39 37 private:
40 38 void waitForFinish();
41 39
42 40 class VisualizationControllerPrivate;
43 41 spimpl::unique_impl_ptr<VisualizationControllerPrivate> impl;
44 42 };
45 43
46 44 #endif // SCIQLOP_VISUALIZATIONCONTROLLER_H
Show file before | Show file after | Hide comments
@@ -1,86 +1,140
1 1 #include <DataSource/DataSourceItem.h>
2 2 #include <DataSource/DataSourceItemAction.h>
3 3
4 4 #include <QVector>
5 5
6 namespace {
7
8 /// Index of the 'name' value in the item
9 const auto NAME_INDEX = 0;
10
11 } // namespace
6 const QString DataSourceItem::NAME_DATA_KEY = QStringLiteral("name");
12 7
13 8 struct DataSourceItem::DataSourceItemPrivate {
14 explicit DataSourceItemPrivate(DataSourceItemType type, QVector<QVariant> data)
9 explicit DataSourceItemPrivate(DataSourceItemType type, QHash<QString, QVariant> data)
15 10 : m_Parent{nullptr}, m_Children{}, m_Type{type}, m_Data{std::move(data)}, m_Actions{}
16 11 {
17 12 }
18 13
19 14 DataSourceItem *m_Parent;
20 15 std::vector<std::unique_ptr<DataSourceItem> > m_Children;
21 16 DataSourceItemType m_Type;
22 QVector<QVariant> m_Data;
17 QHash<QString, QVariant> m_Data;
23 18 std::vector<std::unique_ptr<DataSourceItemAction> > m_Actions;
24 19 };
25 20
26 DataSourceItem::DataSourceItem(DataSourceItemType type, QVector<QVariant> data)
21 DataSourceItem::DataSourceItem(DataSourceItemType type, const QString &name)
22 : DataSourceItem{type, QHash<QString, QVariant>{{NAME_DATA_KEY, name}}}
23 {
24 }
25
26 DataSourceItem::DataSourceItem(DataSourceItemType type, QHash<QString, QVariant> data)
27 27 : impl{spimpl::make_unique_impl<DataSourceItemPrivate>(type, std::move(data))}
28 28 {
29 29 }
30 30
31 31 QVector<DataSourceItemAction *> DataSourceItem::actions() const noexcept
32 32 {
33 33 auto result = QVector<DataSourceItemAction *>{};
34 34
35 35 std::transform(std::cbegin(impl->m_Actions), std::cend(impl->m_Actions),
36 36 std::back_inserter(result), [](const auto &action) { return action.get(); });
37 37
38 38 return result;
39 39 }
40 40
41 41 void DataSourceItem::addAction(std::unique_ptr<DataSourceItemAction> action) noexcept
42 42 {
43 43 action->setDataSourceItem(this);
44 44 impl->m_Actions.push_back(std::move(action));
45 45 }
46 46
47 47 void DataSourceItem::appendChild(std::unique_ptr<DataSourceItem> child) noexcept
48 48 {
49 49 child->impl->m_Parent = this;
50 50 impl->m_Children.push_back(std::move(child));
51 51 }
52 52
53 53 DataSourceItem *DataSourceItem::child(int childIndex) const noexcept
54 54 {
55 55 if (childIndex < 0 || childIndex >= childCount()) {
56 56 return nullptr;
57 57 }
58 58 else {
59 59 return impl->m_Children.at(childIndex).get();
60 60 }
61 61 }
62 62
63 63 int DataSourceItem::childCount() const noexcept
64 64 {
65 65 return impl->m_Children.size();
66 66 }
67 67
68 QVariant DataSourceItem::data(int dataIndex) const noexcept
68 QVariant DataSourceItem::data(const QString &key) const noexcept
69 69 {
70 return impl->m_Data.value(dataIndex);
70 return impl->m_Data.value(key);
71 }
72
73 const QHash<QString, QVariant> &DataSourceItem::data() const noexcept
74 {
75 return impl->m_Data;
76 }
77
78 bool DataSourceItem::isRoot() const noexcept
79 {
80 return impl->m_Parent == nullptr;
71 81 }
72 82
73 83 QString DataSourceItem::name() const noexcept
74 84 {
75 return data(NAME_INDEX).toString();
85 return data(NAME_DATA_KEY).toString();
76 86 }
77 87
78 88 DataSourceItem *DataSourceItem::parentItem() const noexcept
79 89 {
80 90 return impl->m_Parent;
81 91 }
82 92
93 void DataSourceItem::setData(const QString &key, const QVariant &value, bool append) noexcept
94 {
95 auto it = impl->m_Data.constFind(key);
96 if (append && it != impl->m_Data.constEnd()) {
97 // Case of an existing value to which we want to add to the new value
98 if (it->canConvert<QVariantList>()) {
99 auto variantList = it->value<QVariantList>();
100 variantList.append(value);
101
102 impl->m_Data.insert(key, variantList);
103 }
104 else {
105 impl->m_Data.insert(key, QVariantList{*it, value});
106 }
107 }
108 else {
109 // Other cases :
110 // - new value in map OR
111 // - replacement of an existing value (not appending)
112 impl->m_Data.insert(key, value);
113 }
114 }
115
83 116 DataSourceItemType DataSourceItem::type() const noexcept
84 117 {
85 118 return impl->m_Type;
86 119 }
120
121 bool DataSourceItem::operator==(const DataSourceItem &other)
122 {
123 // Compares items' attributes
124 if (std::tie(impl->m_Type, impl->m_Data) == std::tie(other.impl->m_Type, other.impl->m_Data)) {
125 // Compares contents of items' children
126 return std::equal(std::cbegin(impl->m_Children), std::cend(impl->m_Children),
127 std::cbegin(other.impl->m_Children),
128 [](const auto &itemChild, const auto &otherChild) {
129 return *itemChild == *otherChild;
130 });
131 }
132 else {
133 return false;
134 }
135 }
136
137 bool DataSourceItem::operator!=(const DataSourceItem &other)
138 {
139 return !(*this == other);
140 }
Show file before | Show file after | Hide comments
@@ -1,209 +1,207
1 1 #include <Variable/Variable.h>
2 2 #include <Variable/VariableCacheController.h>
3 3 #include <Variable/VariableController.h>
4 4 #include <Variable/VariableModel.h>
5 5
6 6 #include <Data/DataProviderParameters.h>
7 7 #include <Data/IDataProvider.h>
8 8 #include <Data/IDataSeries.h>
9 9 #include <Time/TimeController.h>
10 10
11 11 #include <QDateTime>
12 12 #include <QMutex>
13 13 #include <QThread>
14 14 #include <QtCore/QItemSelectionModel>
15 15
16 16 #include <unordered_map>
17 17
18 18 Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
19 19
20 20 namespace {
21 21
22 22 /// @todo Generates default dataseries, according to the provider passed in parameter. This method
23 23 /// will be deleted when the timerange is recovered from SciQlop
24 24 std::shared_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider,
25 25 const SqpDateTime &dateTime) noexcept
26 26 {
27 27 auto parameters = DataProviderParameters{dateTime};
28 28
29 29 return provider.retrieveData(parameters);
30 30 }
31 31
32 32 } // namespace
33 33
34 34 struct VariableController::VariableControllerPrivate {
35 35 explicit VariableControllerPrivate(VariableController *parent)
36 36 : m_WorkingMutex{},
37 37 m_VariableModel{new VariableModel{parent}},
38 38 m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
39 39 m_VariableCacheController{std::make_unique<VariableCacheController>()}
40 40 {
41 41 }
42 42
43 43 QMutex m_WorkingMutex;
44 44 /// Variable model. The VariableController has the ownership
45 45 VariableModel *m_VariableModel;
46 46 QItemSelectionModel *m_VariableSelectionModel;
47 47
48 48
49 49 TimeController *m_TimeController{nullptr};
50 50 std::unique_ptr<VariableCacheController> m_VariableCacheController;
51 51
52 52 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
53 53 m_VariableToProviderMap;
54 54 };
55 55
56 56 VariableController::VariableController(QObject *parent)
57 57 : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
58 58 {
59 59 qCDebug(LOG_VariableController()) << tr("VariableController construction")
60 60 << QThread::currentThread();
61 61 }
62 62
63 63 VariableController::~VariableController()
64 64 {
65 65 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
66 66 << QThread::currentThread();
67 67 this->waitForFinish();
68 68 }
69 69
70 70 VariableModel *VariableController::variableModel() noexcept
71 71 {
72 72 return impl->m_VariableModel;
73 73 }
74 74
75 75 QItemSelectionModel *VariableController::variableSelectionModel() noexcept
76 76 {
77 77 return impl->m_VariableSelectionModel;
78 78 }
79 79
80 80 void VariableController::setTimeController(TimeController *timeController) noexcept
81 81 {
82 82 impl->m_TimeController = timeController;
83 83 }
84 84
85 85 void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
86 86 {
87 87 if (!variable) {
88 88 qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
89 89 return;
90 90 }
91 91
92 92 // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
93 93 // make some treatments before the deletion
94 94 emit variableAboutToBeDeleted(variable);
95 95
96 96 // Deletes provider
97 97 auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
98 98 qCDebug(LOG_VariableController())
99 99 << tr("Number of providers deleted for variable %1: %2")
100 100 .arg(variable->name(), QString::number(nbProvidersDeleted));
101 101
102 102 // Clears cache
103 103 impl->m_VariableCacheController->clear(variable);
104 104
105 105 // Deletes from model
106 106 impl->m_VariableModel->deleteVariable(variable);
107 107 }
108 108
109 109 void VariableController::deleteVariables(
110 110 const QVector<std::shared_ptr<Variable> > &variables) noexcept
111 111 {
112 112 for (auto variable : qAsConst(variables)) {
113 113 deleteVariable(variable);
114 114 }
115 115 }
116 116
117 117 void VariableController::createVariable(const QString &name,
118 118 std::shared_ptr<IDataProvider> provider) noexcept
119 119 {
120 120
121 121 if (!impl->m_TimeController) {
122 122 qCCritical(LOG_VariableController())
123 123 << tr("Impossible to create variable: The time controller is null");
124 124 return;
125 125 }
126 126
127 127
128 128 /// @todo : for the moment :
129 129 /// - the provider is only used to retrieve data from the variable for its initialization, but
130 130 /// it will be retained later
131 131 /// - default data are generated for the variable, without taking into account the timerange set
132 132 /// in sciqlop
133 133 auto dateTime = impl->m_TimeController->dateTime();
134 134 if (auto newVariable = impl->m_VariableModel->createVariable(name, dateTime)) {
135 135
136 136 // store the provider
137 137 impl->m_VariableToProviderMap[newVariable] = provider;
138 138
139 auto addDateTimeAcquired
140 = [this, newVariable](auto dataSeriesAcquired, auto dateTimeToPutInCache) {
141
142 impl->m_VariableCacheController->addDateTime(newVariable, dateTimeToPutInCache);
143 newVariable->setDataSeries(dataSeriesAcquired);
144
145 };
139 auto addDateTimeAcquired = [ this, varW = std::weak_ptr<Variable>{newVariable} ](
140 auto dataSeriesAcquired, auto dateTimeToPutInCache)
141 {
142 if (auto variable = varW.lock()) {
143 impl->m_VariableCacheController->addDateTime(variable, dateTimeToPutInCache);
144 variable->setDataSeries(dataSeriesAcquired);
145 }
146 };
146 147
147 148 connect(provider.get(), &IDataProvider::dataProvided, addDateTimeAcquired);
148 149 this->onRequestDataLoading(newVariable, dateTime);
149
150 // notify the creation
151 emit variableCreated(newVariable);
152 150 }
153 151 }
154 152
155 153 void VariableController::onDateTimeOnSelection(const SqpDateTime &dateTime)
156 154 {
157 155 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
158 156
159 157 for (const auto &selectedRow : qAsConst(selectedRows)) {
160 158 if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
161 159 selectedVariable->setDateTime(dateTime);
162 160 this->onRequestDataLoading(selectedVariable, dateTime);
163 161 }
164 162 }
165 163 }
166 164
167 165
168 166 void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
169 167 const SqpDateTime &dateTime)
170 168 {
171 169 // we want to load data of the variable for the dateTime.
172 170 // First we check if the cache contains some of them.
173 171 // For the other, we ask the provider to give them.
174 172 if (variable) {
175 173
176 174 auto dateTimeListNotInCache
177 175 = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
178 176
179 177 if (!dateTimeListNotInCache.empty()) {
180 178 // Ask the provider for each data on the dateTimeListNotInCache
181 179 impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
182 180 std::move(dateTimeListNotInCache));
183 181 }
184 182 else {
185 183 emit variable->updated();
186 184 }
187 185 }
188 186 else {
189 187 qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null");
190 188 }
191 189 }
192 190
193 191
194 192 void VariableController::initialize()
195 193 {
196 194 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
197 195 impl->m_WorkingMutex.lock();
198 196 qCDebug(LOG_VariableController()) << tr("VariableController init END");
199 197 }
200 198
201 199 void VariableController::finalize()
202 200 {
203 201 impl->m_WorkingMutex.unlock();
204 202 }
205 203
206 204 void VariableController::waitForFinish()
207 205 {
208 206 QMutexLocker locker{&impl->m_WorkingMutex};
209 207 }
Show file before | Show file after | Hide comments
@@ -1,51 +1,49
1 1 #include <DataSource/DataSourceController.h>
2 2 #include <DataSource/DataSourceItem.h>
3 3
4 4 #include <QObject>
5 5 #include <QtTest>
6 6
7 7 #include <memory>
8 8
9 9 class TestDataSourceController : public QObject {
10 10 Q_OBJECT
11 11 private slots:
12 12 void testRegisterDataSource();
13 13 void testSetDataSourceItem();
14 14 };
15 15
16 16 void TestDataSourceController::testRegisterDataSource()
17 17 {
18 18 DataSourceController dataSourceController{};
19 19
20 20 auto uid = dataSourceController.registerDataSource(QStringLiteral("Source1"));
21 21 QVERIFY(!uid.isNull());
22 22 }
23 23
24 24 void TestDataSourceController::testSetDataSourceItem()
25 25 {
26 26 DataSourceController dataSourceController{};
27 27
28 28 // Spy to test controllers' signals
29 29 QSignalSpy signalSpy{&dataSourceController, SIGNAL(dataSourceItemSet(DataSourceItem *))};
30 30
31 31 // Create a data source item
32 32 auto source1Name = QStringLiteral("Source1");
33 auto source1Values = QVector<QVariant>{source1Name};
34 auto source1Item
35 = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, std::move(source1Values));
33 auto source1Item = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, source1Name);
36 34
37 35 // Add data source item to the controller and check that a signal has been emitted after setting
38 36 // data source item in the controller
39 37 auto source1Uid = dataSourceController.registerDataSource(source1Name);
40 38 dataSourceController.setDataSourceItem(source1Uid, std::move(source1Item));
41 39 QCOMPARE(signalSpy.count(), 1);
42 40
43 41 // Try to a data source item with an unregistered uid and check that no signal has been emitted
44 42 auto unregisteredUid = QUuid::createUuid();
45 43 dataSourceController.setDataSourceItem(
46 44 unregisteredUid, std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT));
47 45 QCOMPARE(signalSpy.count(), 1);
48 46 }
49 47
50 48 QTEST_MAIN(TestDataSourceController)
51 49 #include "TestDataSourceController.moc"
Show file before | Show file after | Hide comments
@@ -1,10 +1,14
1 1 <RCC>
2 2 <qresource prefix="/">
3 <file>icones/dataSourceComponent.png</file>
4 <file>icones/dataSourceNode.png</file>
5 <file>icones/dataSourceProduct.png</file>
6 <file>icones/dataSourceRoot.png</file>
3 7 <file>icones/delete.png</file>
4 8 <file>icones/openInspector.png</file>
5 9 <file>icones/next.png</file>
6 10 <file>icones/plot.png</file>
7 11 <file>icones/previous.png</file>
8 12 <file>icones/unplot.png</file>
9 13 </qresource>
10 14 </RCC>
Show file before | Show file after | Hide comments
@@ -1,101 +1,171
1 1 #include <DataSource/DataSourceItem.h>
2 2 #include <DataSource/DataSourceItemAction.h>
3 3 #include <DataSource/DataSourceTreeWidgetItem.h>
4 4
5 #include <SqpApplication.h>
6
7 5 #include <QAction>
8 6
9 7 Q_LOGGING_CATEGORY(LOG_DataSourceTreeWidgetItem, "DataSourceTreeWidgetItem")
10 8
11 9 namespace {
12 10
11 // Column indexes
12 const auto NAME_COLUMN = 0;
13
13 14 QIcon itemIcon(const DataSourceItem *dataSource)
14 15 {
15 16 if (dataSource) {
16 17 auto dataSourceType = dataSource->type();
17 18 switch (dataSourceType) {
18 case DataSourceItemType::NODE:
19 return sqpApp->style()->standardIcon(QStyle::SP_DirIcon);
19 case DataSourceItemType::NODE: {
20 return dataSource->isRoot() ? QIcon{":/icones/dataSourceRoot.png"}
21 : QIcon{":/icones/dataSourceNode.png"};
22 }
20 23 case DataSourceItemType::PRODUCT:
21 return sqpApp->style()->standardIcon(QStyle::SP_FileIcon);
24 return QIcon{":/icones/dataSourceProduct.png"};
25 case DataSourceItemType::COMPONENT:
26 return QIcon{":/icones/dataSourceComponent.png"};
22 27 default:
23 28 // No action
24 29 break;
25 30 }
26 31
27 32 qCWarning(LOG_DataSourceTreeWidgetItem())
28 33 << QObject::tr("Can't set data source icon : unknown data source type");
29 34 }
30 35 else {
31 qCWarning(LOG_DataSourceTreeWidgetItem())
36 qCCritical(LOG_DataSourceTreeWidgetItem())
32 37 << QObject::tr("Can't set data source icon : the data source is null");
33 38 }
34 39
35 40 // Default cases
36 41 return QIcon{};
37 42 }
38 43
44 /// @return the tooltip text for a variant. The text depends on whether the data is a simple variant
45 /// or a list of variants
46 QString tooltipValue(const QVariant &variant) noexcept
47 {
48 // If the variant is a list of variants, the text of the tooltip is of the form: {val1, val2,
49 // ...}
50 if (variant.canConvert<QVariantList>()) {
51 auto valueString = QStringLiteral("{");
52
53 auto variantList = variant.value<QVariantList>();
54 for (auto it = variantList.cbegin(), end = variantList.cend(); it != end; ++it) {
55 valueString.append(it->toString());
56
57 if (std::distance(it, end) != 1) {
58 valueString.append(", ");
59 }
60 }
61
62 valueString.append(QStringLiteral("}"));
63
64 return valueString;
65 }
66 else {
67 return variant.toString();
68 }
69 }
70
71 QString itemTooltip(const DataSourceItem *dataSource) noexcept
72 {
73 // The tooltip displays all item's data
74 if (dataSource) {
75 auto result = QString{};
76
77 const auto &data = dataSource->data();
78 for (auto it = data.cbegin(), end = data.cend(); it != end; ++it) {
79 result.append(QString{"<b>%1:</b> %2<br/>"}.arg(it.key(), tooltipValue(it.value())));
80 }
81
82 return result;
83 }
84 else {
85 qCCritical(LOG_DataSourceTreeWidgetItem())
86 << QObject::tr("Can't set data source tooltip : the data source is null");
87
88 return QString{};
89 }
90 }
91
39 92 } // namespace
40 93
41 94 struct DataSourceTreeWidgetItem::DataSourceTreeWidgetItemPrivate {
42 95 explicit DataSourceTreeWidgetItemPrivate(const DataSourceItem *data) : m_Data{data} {}
43 96
44 97 /// Model used to retrieve data source information
45 98 const DataSourceItem *m_Data;
46 99 /// Actions associated to the item. The parent of the item (QTreeWidget) takes the ownership of
47 100 /// the actions
48 101 QList<QAction *> m_Actions;
49 102 };
50 103
51 104 DataSourceTreeWidgetItem::DataSourceTreeWidgetItem(const DataSourceItem *data, int type)
52 105 : DataSourceTreeWidgetItem{nullptr, data, type}
53 106 {
54 107 }
55 108
56 109 DataSourceTreeWidgetItem::DataSourceTreeWidgetItem(QTreeWidget *parent, const DataSourceItem *data,
57 110 int type)
58 111 : QTreeWidgetItem{parent, type},
59 112 impl{spimpl::make_unique_impl<DataSourceTreeWidgetItemPrivate>(data)}
60 113 {
61 // Sets the icon depending on the data source
114 // Sets the icon and the tooltip depending on the data source
62 115 setIcon(0, itemIcon(impl->m_Data));
116 setToolTip(0, itemTooltip(impl->m_Data));
63 117
64 118 // Generates tree actions based on the item actions
65 119 auto createTreeAction = [this, &parent](const auto &itemAction) {
66 120 auto treeAction = new QAction{itemAction->name(), parent};
67 121
68 122 // Executes item action when tree action is triggered
69 123 QObject::connect(treeAction, &QAction::triggered, itemAction,
70 124 &DataSourceItemAction::execute);
71 125
72 126 return treeAction;
73 127 };
74 128
75 129 auto itemActions = impl->m_Data->actions();
76 130 std::transform(std::cbegin(itemActions), std::cend(itemActions),
77 131 std::back_inserter(impl->m_Actions), createTreeAction);
78 132 }
79 133
80 134 QVariant DataSourceTreeWidgetItem::data(int column, int role) const
81 135 {
82 136 if (role == Qt::DisplayRole) {
83 return (impl->m_Data) ? impl->m_Data->data(column) : QVariant{};
137 if (impl->m_Data) {
138 switch (column) {
139 case NAME_COLUMN:
140 return impl->m_Data->name();
141 default:
142 // No action
143 break;
144 }
145
146 qCWarning(LOG_DataSourceTreeWidgetItem())
147 << QObject::tr("Can't get data (unknown column %1)").arg(column);
148 }
149 else {
150 qCCritical(LOG_DataSourceTreeWidgetItem()) << QObject::tr("Can't get data (null item)");
151 }
152
153 return QVariant{};
84 154 }
85 155 else {
86 156 return QTreeWidgetItem::data(column, role);
87 157 }
88 158 }
89 159
90 160 void DataSourceTreeWidgetItem::setData(int column, int role, const QVariant &value)
91 161 {
92 162 // Data can't be changed by edition
93 163 if (role != Qt::EditRole) {
94 164 QTreeWidgetItem::setData(column, role, value);
95 165 }
96 166 }
97 167
98 168 QList<QAction *> DataSourceTreeWidgetItem::actions() const noexcept
99 169 {
100 170 return impl->m_Actions;
101 171 }
Show file before | Show file after | Hide comments
@@ -1,122 +1,119
1 1 #include "SqpApplication.h"
2 2
3 3 #include <Data/IDataProvider.h>
4 4 #include <DataSource/DataSourceController.h>
5 5 #include <QThread>
6 6 #include <Time/TimeController.h>
7 7 #include <Variable/Variable.h>
8 8 #include <Variable/VariableController.h>
9 9 #include <Visualization/VisualizationController.h>
10 10
11 11 Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
12 12
13 13 class SqpApplication::SqpApplicationPrivate {
14 14 public:
15 15 SqpApplicationPrivate()
16 16 : m_DataSourceController{std::make_unique<DataSourceController>()},
17 17 m_TimeController{std::make_unique<TimeController>()},
18 18 m_VariableController{std::make_unique<VariableController>()},
19 19 m_VisualizationController{std::make_unique<VisualizationController>()}
20 20 {
21 21 // /////////////////////////////// //
22 22 // Connections between controllers //
23 23 // /////////////////////////////// //
24 24
25 25 // VariableController <-> DataSourceController
26 26 connect(m_DataSourceController.get(),
27 27 SIGNAL(variableCreationRequested(const QString &, std::shared_ptr<IDataProvider>)),
28 28 m_VariableController.get(),
29 29 SLOT(createVariable(const QString &, std::shared_ptr<IDataProvider>)));
30 30
31 31 // VariableController <-> VisualizationController
32 connect(m_VariableController.get(), SIGNAL(variableCreated(std::shared_ptr<Variable>)),
33 m_VisualizationController.get(),
34 SIGNAL(variableCreated(std::shared_ptr<Variable>)));
35 32 connect(m_VariableController.get(),
36 33 SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
37 34 m_VisualizationController.get(),
38 35 SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
39 36
40 37 m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
41 38 m_VariableController->moveToThread(&m_VariableControllerThread);
42 39 m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
43 40
44 41 // Additionnal init
45 42 m_VariableController->setTimeController(m_TimeController.get());
46 43 }
47 44
48 45 virtual ~SqpApplicationPrivate()
49 46 {
50 47 qCInfo(LOG_SqpApplication()) << tr("SqpApplicationPrivate destruction");
51 48 m_DataSourceControllerThread.quit();
52 49 m_DataSourceControllerThread.wait();
53 50
54 51 m_VariableControllerThread.quit();
55 52 m_VariableControllerThread.wait();
56 53
57 54 m_VisualizationControllerThread.quit();
58 55 m_VisualizationControllerThread.wait();
59 56 }
60 57
61 58 std::unique_ptr<DataSourceController> m_DataSourceController;
62 59 std::unique_ptr<VariableController> m_VariableController;
63 60 std::unique_ptr<TimeController> m_TimeController;
64 61 std::unique_ptr<VisualizationController> m_VisualizationController;
65 62 QThread m_DataSourceControllerThread;
66 63 QThread m_VariableControllerThread;
67 64 QThread m_VisualizationControllerThread;
68 65 };
69 66
70 67
71 68 SqpApplication::SqpApplication(int &argc, char **argv)
72 69 : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
73 70 {
74 71 qCInfo(LOG_SqpApplication()) << tr("SqpApplication construction");
75 72
76 73 connect(&impl->m_DataSourceControllerThread, &QThread::started,
77 74 impl->m_DataSourceController.get(), &DataSourceController::initialize);
78 75 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
79 76 impl->m_DataSourceController.get(), &DataSourceController::finalize);
80 77
81 78 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
82 79 &VariableController::initialize);
83 80 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
84 81 &VariableController::finalize);
85 82
86 83 connect(&impl->m_VisualizationControllerThread, &QThread::started,
87 84 impl->m_VisualizationController.get(), &VisualizationController::initialize);
88 85 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
89 86 impl->m_VisualizationController.get(), &VisualizationController::finalize);
90 87
91 88 impl->m_DataSourceControllerThread.start();
92 89 impl->m_VariableControllerThread.start();
93 90 impl->m_VisualizationControllerThread.start();
94 91 }
95 92
96 93 SqpApplication::~SqpApplication()
97 94 {
98 95 }
99 96
100 97 void SqpApplication::initialize()
101 98 {
102 99 }
103 100
104 101 DataSourceController &SqpApplication::dataSourceController() noexcept
105 102 {
106 103 return *impl->m_DataSourceController;
107 104 }
108 105
109 106 TimeController &SqpApplication::timeController() noexcept
110 107 {
111 108 return *impl->m_TimeController;
112 109 }
113 110
114 111 VariableController &SqpApplication::variableController() noexcept
115 112 {
116 113 return *impl->m_VariableController;
117 114 }
118 115
119 116 VisualizationController &SqpApplication::visualizationController() noexcept
120 117 {
121 118 return *impl->m_VisualizationController;
122 119 }
Show file before | Show file after | Hide comments
@@ -1,183 +1,196
1 1 #include "Visualization/operations/GenerateVariableMenuOperation.h"
2 2 #include "Visualization/operations/MenuBuilder.h"
3 3
4 4 #include "Visualization/VisualizationGraphWidget.h"
5 5 #include "Visualization/VisualizationTabWidget.h"
6 6 #include "Visualization/VisualizationZoneWidget.h"
7 7
8 8 #include <Variable/Variable.h>
9 9
10 10 #include <QMenu>
11 11 #include <QStack>
12 12
13 13 Q_LOGGING_CATEGORY(LOG_GenerateVariableMenuOperation, "GenerateVariableMenuOperation")
14 14
15 15 struct GenerateVariableMenuOperation::GenerateVariableMenuOperationPrivate {
16 16 explicit GenerateVariableMenuOperationPrivate(QMenu *menu, std::shared_ptr<Variable> variable)
17 17 : m_Variable{variable}, m_PlotMenuBuilder{menu}, m_UnplotMenuBuilder{menu}
18 18 {
19 19 }
20 20
21 21 void visitRootEnter()
22 22 {
23 23 // Creates the root menu
24 24 m_PlotMenuBuilder.addMenu(QObject::tr("Plot"), QIcon{":/icones/plot.png"});
25 25 m_UnplotMenuBuilder.addMenu(QObject::tr("Unplot"), QIcon{":/icones/unplot.png"});
26 26 }
27 27
28 28 void visitRootLeave()
29 29 {
30 30 // Closes the root menu
31 31 m_PlotMenuBuilder.closeMenu();
32 32 m_UnplotMenuBuilder.closeMenu();
33 33 }
34 34
35 35 void visitNodeEnter(const IVisualizationWidget &container)
36 36 {
37 37 // Opens a new menu associated to the node
38 38 m_PlotMenuBuilder.addMenu(container.name());
39 39 m_UnplotMenuBuilder.addMenu(container.name());
40 40 }
41 41
42 42 template <typename ActionFun>
43 43 void visitNodeLeavePlot(const IVisualizationWidget &container, const QString &actionName,
44 44 ActionFun actionFunction)
45 45 {
46 46 if (m_Variable && container.canDrop(*m_Variable)) {
47 47 m_PlotMenuBuilder.addSeparator();
48 48 m_PlotMenuBuilder.addAction(actionName, actionFunction);
49 49 }
50 50
51 51 // Closes the menu associated to the node
52 52 m_PlotMenuBuilder.closeMenu();
53 53 }
54 54
55 55 void visitNodeLeaveUnplot()
56 56 {
57 57 // Closes the menu associated to the node
58 58 m_UnplotMenuBuilder.closeMenu();
59 59 }
60 60
61 61 template <typename ActionFun>
62 62 void visitLeafPlot(const IVisualizationWidget &container, const QString &actionName,
63 63 ActionFun actionFunction)
64 64 {
65 65 if (m_Variable && container.canDrop(*m_Variable)) {
66 66 m_PlotMenuBuilder.addAction(actionName, actionFunction);
67 67 }
68 68 }
69 69
70 70 template <typename ActionFun>
71 71 void visitLeafUnplot(const IVisualizationWidget &container, const QString &actionName,
72 72 ActionFun actionFunction)
73 73 {
74 74 if (m_Variable && container.contains(*m_Variable)) {
75 75 m_UnplotMenuBuilder.addAction(actionName, actionFunction);
76 76 }
77 77 }
78 78
79 79 std::shared_ptr<Variable> m_Variable;
80 80 MenuBuilder m_PlotMenuBuilder; ///< Builder for the 'Plot' menu
81 81 MenuBuilder m_UnplotMenuBuilder; ///< Builder for the 'Unplot' menu
82 82 };
83 83
84 84 GenerateVariableMenuOperation::GenerateVariableMenuOperation(QMenu *menu,
85 85 std::shared_ptr<Variable> variable)
86 86 : impl{spimpl::make_unique_impl<GenerateVariableMenuOperationPrivate>(menu, variable)}
87 87 {
88 88 }
89 89
90 90 void GenerateVariableMenuOperation::visitEnter(VisualizationWidget *widget)
91 91 {
92 92 // VisualizationWidget is not intended to accommodate a variable
93 93 Q_UNUSED(widget)
94 94
95 95 // 'Plot' and 'Unplot' menus
96 96 impl->visitRootEnter();
97 97 }
98 98
99 99 void GenerateVariableMenuOperation::visitLeave(VisualizationWidget *widget)
100 100 {
101 101 // VisualizationWidget is not intended to accommodate a variable
102 102 Q_UNUSED(widget)
103 103
104 104 // 'Plot' and 'Unplot' menus
105 105 impl->visitRootLeave();
106 106 }
107 107
108 108 void GenerateVariableMenuOperation::visitEnter(VisualizationTabWidget *tabWidget)
109 109 {
110 110 if (tabWidget) {
111 111 // 'Plot' and 'Unplot' menus
112 112 impl->visitNodeEnter(*tabWidget);
113 113 }
114 114 else {
115 115 qCCritical(LOG_GenerateVariableMenuOperation(),
116 116 "Can't visit enter VisualizationTabWidget : the widget is null");
117 117 }
118 118 }
119 119
120 120 void GenerateVariableMenuOperation::visitLeave(VisualizationTabWidget *tabWidget)
121 121 {
122 122 if (tabWidget) {
123 123 // 'Plot' menu
124 impl->visitNodeLeavePlot(
125 *tabWidget, QObject::tr("Open in a new zone"),
126 [ var = impl->m_Variable, tabWidget ]() { tabWidget->createZone(var); });
124 impl->visitNodeLeavePlot(*tabWidget, QObject::tr("Open in a new zone"),
125 [ varW = std::weak_ptr<Variable>{impl->m_Variable}, tabWidget ]() {
126 if (auto var = varW.lock()) {
127 tabWidget->createZone(var);
128 }
129 });
127 130
128 131 // 'Unplot' menu
129 132 impl->visitNodeLeaveUnplot();
130 133 }
131 134 else {
132 135 qCCritical(LOG_GenerateVariableMenuOperation(),
133 136 "Can't visit leave VisualizationTabWidget : the widget is null");
134 137 }
135 138 }
136 139
137 140 void GenerateVariableMenuOperation::visitEnter(VisualizationZoneWidget *zoneWidget)
138 141 {
139 142 if (zoneWidget) {
140 143 // 'Plot' and 'Unplot' menus
141 144 impl->visitNodeEnter(*zoneWidget);
142 145 }
143 146 else {
144 147 qCCritical(LOG_GenerateVariableMenuOperation(),
145 148 "Can't visit enter VisualizationZoneWidget : the widget is null");
146 149 }
147 150 }
148 151
149 152 void GenerateVariableMenuOperation::visitLeave(VisualizationZoneWidget *zoneWidget)
150 153 {
151 154 if (zoneWidget) {
152 155 // 'Plot' menu
153 156 impl->visitNodeLeavePlot(
154 157 *zoneWidget, QObject::tr("Open in a new graph"),
155 [ var = impl->m_Variable, zoneWidget ]() { zoneWidget->createGraph(var); });
158 [ varW = std::weak_ptr<Variable>{impl->m_Variable}, zoneWidget ]() {
159 if (auto var = varW.lock()) {
160 zoneWidget->createGraph(var);
161 }
162 });
156 163
157 164 // 'Unplot' menu
158 165 impl->visitNodeLeaveUnplot();
159 166 }
160 167 else {
161 168 qCCritical(LOG_GenerateVariableMenuOperation(),
162 169 "Can't visit leave VisualizationZoneWidget : the widget is null");
163 170 }
164 171 }
165 172
166 173 void GenerateVariableMenuOperation::visit(VisualizationGraphWidget *graphWidget)
167 174 {
168 175 if (graphWidget) {
169 176 // 'Plot' menu
170 impl->visitLeafPlot(
171 *graphWidget, QObject::tr("Open in %1").arg(graphWidget->name()),
172 [ var = impl->m_Variable, graphWidget ]() { graphWidget->addVariableUsingGraph(var); });
177 impl->visitLeafPlot(*graphWidget, QObject::tr("Open in %1").arg(graphWidget->name()),
178 [ varW = std::weak_ptr<Variable>{impl->m_Variable}, graphWidget ]() {
179 if (auto var = varW.lock()) {
180 graphWidget->addVariableUsingGraph(var);
181 }
182 });
173 183
174 184 // 'Unplot' menu
175 impl->visitLeafUnplot(
176 *graphWidget, QObject::tr("Remove from %1").arg(graphWidget->name()),
177 [ var = impl->m_Variable, graphWidget ]() { graphWidget->removeVariable(var); });
185 impl->visitLeafUnplot(*graphWidget, QObject::tr("Remove from %1").arg(graphWidget->name()),
186 [ varW = std::weak_ptr<Variable>{impl->m_Variable}, graphWidget ]() {
187 if (auto var = varW.lock()) {
188 graphWidget->removeVariable(var);
189 }
190 });
178 191 }
179 192 else {
180 193 qCCritical(LOG_GenerateVariableMenuOperation(),
181 194 "Can't visit VisualizationGraphWidget : the widget is null");
182 195 }
183 196 }
Show file before | Show file after | Hide comments
@@ -1,81 +1,79
1 1 #include "MockPlugin.h"
2 2 #include "CosinusProvider.h"
3 3
4 4 #include <DataSource/DataSourceController.h>
5 5 #include <DataSource/DataSourceItem.h>
6 6 #include <DataSource/DataSourceItemAction.h>
7 7
8 8 #include <SqpApplication.h>
9 9
10 10 Q_LOGGING_CATEGORY(LOG_MockPlugin, "MockPlugin")
11 11
12 12 namespace {
13 13
14 14 /// Name of the data source
15 15 const auto DATA_SOURCE_NAME = QStringLiteral("MMS");
16 16
17 17 /// Creates the data provider relative to the plugin
18 18 std::unique_ptr<IDataProvider> createDataProvider() noexcept
19 19 {
20 20 return std::make_unique<CosinusProvider>();
21 21 }
22 22
23 23 std::unique_ptr<DataSourceItem> createProductItem(const QString &productName,
24 24 const QUuid &dataSourceUid)
25 25 {
26 auto result = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT,
27 QVector<QVariant>{productName});
26 auto result = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, productName);
28 27
29 28 // Add action to load product from DataSourceController
30 29 result->addAction(std::make_unique<DataSourceItemAction>(
31 30 QObject::tr("Load %1 product").arg(productName),
32 31 [productName, dataSourceUid](DataSourceItem &item) {
33 32 if (auto app = sqpApp) {
34 33 app->dataSourceController().loadProductItem(dataSourceUid, item);
35 34 }
36 35 }));
37 36
38 37 return result;
39 38 }
40 39
41 40 /// Creates the data source item relative to the plugin
42 41 std::unique_ptr<DataSourceItem> createDataSourceItem(const QUuid &dataSourceUid) noexcept
43 42 {
44 43 // Magnetic field products
45 auto magneticFieldFolder = std::make_unique<DataSourceItem>(
46 DataSourceItemType::NODE, QVector<QVariant>{QStringLiteral("Magnetic field")});
44 auto magneticFieldFolder = std::make_unique<DataSourceItem>(DataSourceItemType::NODE,
45 QStringLiteral("Magnetic field"));
47 46 magneticFieldFolder->appendChild(createProductItem(QStringLiteral("FGM"), dataSourceUid));
48 47 magneticFieldFolder->appendChild(createProductItem(QStringLiteral("SC"), dataSourceUid));
49 48
50 49 // Electric field products
51 auto electricFieldFolder = std::make_unique<DataSourceItem>(
52 DataSourceItemType::NODE, QVector<QVariant>{QStringLiteral("Electric field")});
50 auto electricFieldFolder = std::make_unique<DataSourceItem>(DataSourceItemType::NODE,
51 QStringLiteral("Electric field"));
53 52
54 53 // Root
55 auto root = std::make_unique<DataSourceItem>(DataSourceItemType::NODE,
56 QVector<QVariant>{DATA_SOURCE_NAME});
54 auto root = std::make_unique<DataSourceItem>(DataSourceItemType::NODE, DATA_SOURCE_NAME);
57 55 root->appendChild(std::move(magneticFieldFolder));
58 56 root->appendChild(std::move(electricFieldFolder));
59 57
60 58 return root;
61 59 }
62 60
63 61 } // namespace
64 62
65 63 void MockPlugin::initialize()
66 64 {
67 65 if (auto app = sqpApp) {
68 66 // Registers to the data source controller
69 67 auto &dataSourceController = app->dataSourceController();
70 68 auto dataSourceUid = dataSourceController.registerDataSource(DATA_SOURCE_NAME);
71 69
72 70 // Sets data source tree
73 71 dataSourceController.setDataSourceItem(dataSourceUid, createDataSourceItem(dataSourceUid));
74 72
75 73 // Sets data provider
76 74 dataSourceController.setDataProvider(dataSourceUid, createDataProvider());
77 75 }
78 76 else {
79 77 qCWarning(LOG_MockPlugin()) << tr("Can't access to SciQlop application");
80 78 }
81 79 }
General Comments 0
You need to be logged in to leave comments. Login now