##// END OF EJS Templates
GIT_REPOSITORIES » LPP » Users » mperrinel » SCIQLOP-Initialisation
RSS

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Add clang format from linux
perrinel -
r595:8e31780497af
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,274 +1,274
1 #include <Variable/Variable.h>
1 #include <Variable/Variable.h>
2 #include <Variable/VariableModel.h>
2 #include <Variable/VariableModel.h>
3
3
4 #include <Common/DateUtils.h>
4 #include <Common/DateUtils.h>
5
5
6 #include <Data/IDataSeries.h>
6 #include <Data/IDataSeries.h>
7
7
8 #include <QSize>
8 #include <QSize>
9 #include <unordered_map>
9 #include <unordered_map>
10
10
11 Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
11 Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
12
12
13 namespace {
13 namespace {
14
14
15 // Column indexes
15 // Column indexes
16 const auto NAME_COLUMN = 0;
16 const auto NAME_COLUMN = 0;
17 const auto TSTART_COLUMN = 1;
17 const auto TSTART_COLUMN = 1;
18 const auto TEND_COLUMN = 2;
18 const auto TEND_COLUMN = 2;
19 const auto UNIT_COLUMN = 3;
19 const auto UNIT_COLUMN = 3;
20 const auto MISSION_COLUMN = 4;
20 const auto MISSION_COLUMN = 4;
21 const auto PLUGIN_COLUMN = 5;
21 const auto PLUGIN_COLUMN = 5;
22 const auto NB_COLUMNS = 6;
22 const auto NB_COLUMNS = 6;
23
23
24 // Column properties
24 // Column properties
25 const auto DEFAULT_HEIGHT = 25;
25 const auto DEFAULT_HEIGHT = 25;
26 const auto DEFAULT_WIDTH = 100;
26 const auto DEFAULT_WIDTH = 100;
27
27
28 struct ColumnProperties {
28 struct ColumnProperties {
29 ColumnProperties(const QString &name = {}, int width = DEFAULT_WIDTH,
29 ColumnProperties(const QString &name = {}, int width = DEFAULT_WIDTH,
30 int height = DEFAULT_HEIGHT)
30 int height = DEFAULT_HEIGHT)
31 : m_Name{name}, m_Width{width}, m_Height{height}
31 : m_Name{name}, m_Width{width}, m_Height{height}
32 {
32 {
33 }
33 }
34
34
35 QString m_Name;
35 QString m_Name;
36 int m_Width;
36 int m_Width;
37 int m_Height;
37 int m_Height;
38 };
38 };
39
39
40 const auto COLUMN_PROPERTIES = QHash<int, ColumnProperties>{
40 const auto COLUMN_PROPERTIES = QHash<int, ColumnProperties>{
41 {NAME_COLUMN, {QObject::tr("Name")}}, {TSTART_COLUMN, {QObject::tr("tStart"), 180}},
41 {NAME_COLUMN, {QObject::tr("Name")}}, {TSTART_COLUMN, {QObject::tr("tStart"), 180}},
42 {TEND_COLUMN, {QObject::tr("tEnd"), 180}}, {UNIT_COLUMN, {QObject::tr("Unit")}},
42 {TEND_COLUMN, {QObject::tr("tEnd"), 180}}, {UNIT_COLUMN, {QObject::tr("Unit")}},
43 {MISSION_COLUMN, {QObject::tr("Mission")}}, {PLUGIN_COLUMN, {QObject::tr("Plugin")}}};
43 {MISSION_COLUMN, {QObject::tr("Mission")}}, {PLUGIN_COLUMN, {QObject::tr("Plugin")}}};
44
44
45 /// Format for datetimes
45 /// Format for datetimes
46 const auto DATETIME_FORMAT = QStringLiteral("dd/MM/yyyy \nhh:mm:ss:zzz");
46 const auto DATETIME_FORMAT = QStringLiteral("dd/MM/yyyy \nhh:mm:ss:zzz");
47
47
48
48
49 } // namespace
49 } // namespace
50
50
51 struct VariableModel::VariableModelPrivate {
51 struct VariableModel::VariableModelPrivate {
52 /// Variables created in SciQlop
52 /// Variables created in SciQlop
53 std::vector<std::shared_ptr<Variable> > m_Variables;
53 std::vector<std::shared_ptr<Variable> > m_Variables;
54 std::unordered_map<std::shared_ptr<Variable>, double> m_VariableToProgress;
54 std::unordered_map<std::shared_ptr<Variable>, double> m_VariableToProgress;
55
55
56 /// Return the row index of the variable. -1 if it's not found
56 /// Return the row index of the variable. -1 if it's not found
57 int indexOfVariable(Variable *variable) const noexcept;
57 int indexOfVariable(Variable *variable) const noexcept;
58 };
58 };
59
59
60 VariableModel::VariableModel(QObject *parent)
60 VariableModel::VariableModel(QObject *parent)
61 : QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
61 : QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
62 {
62 {
63 }
63 }
64
64
65 std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
65 std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
66 const SqpRange &dateTime,
66 const SqpRange &dateTime,
67 const QVariantHash &metadata) noexcept
67 const QVariantHash &metadata) noexcept
68 {
68 {
69 auto insertIndex = rowCount();
69 auto insertIndex = rowCount();
70 beginInsertRows({}, insertIndex, insertIndex);
70 beginInsertRows({}, insertIndex, insertIndex);
71
71
72 auto variable = std::make_shared<Variable>(name, dateTime, metadata);
72 auto variable = std::make_shared<Variable>(name, dateTime, metadata);
73
73
74 impl->m_Variables.push_back(variable);
74 impl->m_Variables.push_back(variable);
75 connect(variable.get(), &Variable::updated, this, &VariableModel::onVariableUpdated);
75 connect(variable.get(), &Variable::updated, this, &VariableModel::onVariableUpdated);
76
76
77 endInsertRows();
77 endInsertRows();
78
78
79 return variable;
79 return variable;
80 }
80 }
81
81
82 void VariableModel::deleteVariable(std::shared_ptr<Variable> variable) noexcept
82 void VariableModel::deleteVariable(std::shared_ptr<Variable> variable) noexcept
83 {
83 {
84 if (!variable) {
84 if (!variable) {
85 qCCritical(LOG_Variable()) << "Can't delete a null variable from the model";
85 qCCritical(LOG_Variable()) << "Can't delete a null variable from the model";
86 return;
86 return;
87 }
87 }
88
88
89 // Finds variable in the model
89 // Finds variable in the model
90 auto begin = impl->m_Variables.cbegin();
90 auto begin = impl->m_Variables.cbegin();
91 auto end = impl->m_Variables.cend();
91 auto end = impl->m_Variables.cend();
92 auto it = std::find(begin, end, variable);
92 auto it = std::find(begin, end, variable);
93 if (it != end) {
93 if (it != end) {
94 auto removeIndex = std::distance(begin, it);
94 auto removeIndex = std::distance(begin, it);
95
95
96 // Deletes variable
96 // Deletes variable
97 beginRemoveRows({}, removeIndex, removeIndex);
97 beginRemoveRows({}, removeIndex, removeIndex);
98 impl->m_Variables.erase(it);
98 impl->m_Variables.erase(it);
99 endRemoveRows();
99 endRemoveRows();
100 }
100 }
101 else {
101 else {
102 qCritical(LOG_VariableModel())
102 qCritical(LOG_VariableModel())
103 << tr("Can't delete variable %1 from the model: the variable is not in the model")
103 << tr("Can't delete variable %1 from the model: the variable is not in the model")
104 .arg(variable->name());
104 .arg(variable->name());
105 }
105 }
106
106
107 // Removes variable from progress map
107 // Removes variable from progress map
108 impl->m_VariableToProgress.erase(variable);
108 impl->m_VariableToProgress.erase(variable);
109 }
109 }
110
110
111
111
112 std::shared_ptr<Variable> VariableModel::variable(int index) const
112 std::shared_ptr<Variable> VariableModel::variable(int index) const
113 {
113 {
114 return (index >= 0 && index < impl->m_Variables.size()) ? impl->m_Variables[index] : nullptr;
114 return (index >= 0 && index < impl->m_Variables.size()) ? impl->m_Variables[index] : nullptr;
115 }
115 }
116
116
117 void VariableModel::setDataProgress(std::shared_ptr<Variable> variable, double progress)
117 void VariableModel::setDataProgress(std::shared_ptr<Variable> variable, double progress)
118 {
118 {
119 if (progress > 0.0) {
119 if (progress > 0.0) {
120 impl->m_VariableToProgress[variable] = progress;
120 impl->m_VariableToProgress[variable] = progress;
121 }
121 }
122 else {
122 else {
123 impl->m_VariableToProgress.erase(variable);
123 impl->m_VariableToProgress.erase(variable);
124 }
124 }
125 auto modelIndex = createIndex(impl->indexOfVariable(variable.get()), NAME_COLUMN);
125 auto modelIndex = createIndex(impl->indexOfVariable(variable.get()), NAME_COLUMN);
126
126
127 emit dataChanged(modelIndex, modelIndex);
127 emit dataChanged(modelIndex, modelIndex);
128 }
128 }
129
129
130 int VariableModel::columnCount(const QModelIndex &parent) const
130 int VariableModel::columnCount(const QModelIndex &parent) const
131 {
131 {
132 Q_UNUSED(parent);
132 Q_UNUSED(parent);
133
133
134 return NB_COLUMNS;
134 return NB_COLUMNS;
135 }
135 }
136
136
137 int VariableModel::rowCount(const QModelIndex &parent) const
137 int VariableModel::rowCount(const QModelIndex &parent) const
138 {
138 {
139 Q_UNUSED(parent);
139 Q_UNUSED(parent);
140
140
141 return impl->m_Variables.size();
141 return impl->m_Variables.size();
142 }
142 }
143
143
144 QVariant VariableModel::data(const QModelIndex &index, int role) const
144 QVariant VariableModel::data(const QModelIndex &index, int role) const
145 {
145 {
146 if (!index.isValid()) {
146 if (!index.isValid()) {
147 return QVariant{};
147 return QVariant{};
148 }
148 }
149
149
150 if (index.row() < 0 || index.row() >= rowCount()) {
150 if (index.row() < 0 || index.row() >= rowCount()) {
151 return QVariant{};
151 return QVariant{};
152 }
152 }
153
153
154 if (role == Qt::DisplayRole) {
154 if (role == Qt::DisplayRole) {
155 if (auto variable = impl->m_Variables.at(index.row()).get()) {
155 if (auto variable = impl->m_Variables.at(index.row()).get()) {
156 /// Lambda function that builds the variant to return for a time value
156 /// Lambda function that builds the variant to return for a time value
157 /// @param getValueFun function used to get for a data series the iterator on the entry
157 /// @param getValueFun function used to get for a data series the iterator on the entry
158 /// that contains the time value to display
158 /// that contains the time value to display
159 auto dateTimeVariant = [variable](const auto &getValueFun) {
159 auto dateTimeVariant = [variable](const auto &getValueFun) {
160 if (auto dataSeries = variable->dataSeries()) {
160 if (auto dataSeries = variable->dataSeries()) {
161 dataSeries->lockRead();
161 dataSeries->lockRead();
162 auto it = getValueFun(*dataSeries);
162 auto it = getValueFun(*dataSeries);
163 auto resVariant = (it != dataSeries->cend())
163 auto resVariant = (it != dataSeries->cend())
164 ? DateUtils::dateTime(it->x()).toString(DATETIME_FORMAT)
164 ? DateUtils::dateTime(it->x()).toString(DATETIME_FORMAT)
165 : QVariant{};
165 : QVariant{};
166 dataSeries->unlock();
166 dataSeries->unlock();
167 return resVariant;
167 return resVariant;
168 }
168 }
169 else {
169 else {
170 return QVariant{};
170 return QVariant{};
171 }
171 }
172 };
172 };
173
173
174 switch (index.column()) {
174 switch (index.column()) {
175 case NAME_COLUMN:
175 case NAME_COLUMN:
176 return variable->name();
176 return variable->name();
177 case TSTART_COLUMN:
177 case TSTART_COLUMN:
178 // Shows the min value of the data series above the range tstart
178 // Shows the min value of the data series above the range tstart
179 return dateTimeVariant([min = variable->range().m_TStart](
179 return dateTimeVariant([min = variable->range().m_TStart](
180 const auto &dataSeries) { return dataSeries.minXAxisData(min); });
180 const auto &dataSeries) { return dataSeries.minXAxisData(min); });
181 case TEND_COLUMN:
181 case TEND_COLUMN:
182 // Shows the max value of the data series under the range tend
182 // Shows the max value of the data series under the range tend
183 return dateTimeVariant([max = variable->range().m_TEnd](
183 return dateTimeVariant([max = variable->range().m_TEnd](
184 const auto &dataSeries) { return dataSeries.maxXAxisData(max); });
184 const auto &dataSeries) { return dataSeries.maxXAxisData(max); });
185 case UNIT_COLUMN:
185 case UNIT_COLUMN:
186 return variable->metadata().value(QStringLiteral("units"));
186 return variable->metadata().value(QStringLiteral("units"));
187 case MISSION_COLUMN:
187 case MISSION_COLUMN:
188 return variable->metadata().value(QStringLiteral("mission"));
188 return variable->metadata().value(QStringLiteral("mission"));
189 case PLUGIN_COLUMN:
189 case PLUGIN_COLUMN:
190 return variable->metadata().value(QStringLiteral("plugin"));
190 return variable->metadata().value(QStringLiteral("plugin"));
191 default:
191 default:
192 // No action
192 // No action
193 break;
193 break;
194 }
194 }
195
195
196 qWarning(LOG_VariableModel())
196 qWarning(LOG_VariableModel())
197 << tr("Can't get data (unknown column %1)").arg(index.column());
197 << tr("Can't get data (unknown column %1)").arg(index.column());
198 }
198 }
199 else {
199 else {
200 qWarning(LOG_VariableModel()) << tr("Can't get data (no variable)");
200 qWarning(LOG_VariableModel()) << tr("Can't get data (no variable)");
201 }
201 }
202 }
202 }
203 else if (role == VariableRoles::ProgressRole) {
203 else if (role == VariableRoles::ProgressRole) {
204 if (auto variable = impl->m_Variables.at(index.row())) {
204 if (auto variable = impl->m_Variables.at(index.row())) {
205
205
206 auto it = impl->m_VariableToProgress.find(variable);
206 auto it = impl->m_VariableToProgress.find(variable);
207 if (it != impl->m_VariableToProgress.cend()) {
207 if (it != impl->m_VariableToProgress.cend()) {
208 return it->second;
208 return it->second;
209 }
209 }
210 }
210 }
211 }
211 }
212
212
213 return QVariant{};
213 return QVariant{};
214 }
214 }
215
215
216 QVariant VariableModel::headerData(int section, Qt::Orientation orientation, int role) const
216 QVariant VariableModel::headerData(int section, Qt::Orientation orientation, int role) const
217 {
217 {
218 if (role != Qt::DisplayRole && role != Qt::SizeHintRole) {
218 if (role != Qt::DisplayRole && role != Qt::SizeHintRole) {
219 return QVariant{};
219 return QVariant{};
220 }
220 }
221
221
222 if (orientation == Qt::Horizontal) {
222 if (orientation == Qt::Horizontal) {
223 auto propertiesIt = COLUMN_PROPERTIES.find(section);
223 auto propertiesIt = COLUMN_PROPERTIES.find(section);
224 if (propertiesIt != COLUMN_PROPERTIES.cend()) {
224 if (propertiesIt != COLUMN_PROPERTIES.cend()) {
225 // Role is either DisplayRole or SizeHintRole
225 // Role is either DisplayRole or SizeHintRole
226 return (role == Qt::DisplayRole)
226 return (role == Qt::DisplayRole)
227 ? QVariant{propertiesIt->m_Name}
227 ? QVariant{propertiesIt->m_Name}
228 : QVariant{QSize{propertiesIt->m_Width, propertiesIt->m_Height}};
228 : QVariant{QSize{propertiesIt->m_Width, propertiesIt->m_Height}};
229 }
229 }
230 else {
230 else {
231 qWarning(LOG_VariableModel())
231 qWarning(LOG_VariableModel())
232 << tr("Can't get header data (unknown column %1)").arg(section);
232 << tr("Can't get header data (unknown column %1)").arg(section);
233 }
233 }
234 }
234 }
235
235
236 return QVariant{};
236 return QVariant{};
237 }
237 }
238
238
239 void VariableModel::abortProgress(const QModelIndex &index)
239 void VariableModel::abortProgress(const QModelIndex &index)
240 {
240 {
241 if (auto variable = impl->m_Variables.at(index.row())) {
241 if (auto variable = impl->m_Variables.at(index.row())) {
242 emit abortProgessRequested(variable);
242 emit abortProgessRequested(variable);
243 }
243 }
244 }
244 }
245
245
246 void VariableModel::onVariableUpdated() noexcept
246 void VariableModel::onVariableUpdated() noexcept
247 {
247 {
248 // Finds variable that has been updated in the model
248 // Finds variable that has been updated in the model
249 if (auto updatedVariable = dynamic_cast<Variable *>(sender())) {
249 if (auto updatedVariable = dynamic_cast<Variable *>(sender())) {
250 auto updatedVariableIndex = impl->indexOfVariable(updatedVariable);
250 auto updatedVariableIndex = impl->indexOfVariable(updatedVariable);
251
251
252 if (updatedVariableIndex > -1) {
252 if (updatedVariableIndex > -1) {
253 emit dataChanged(createIndex(updatedVariableIndex, 0),
253 emit dataChanged(createIndex(updatedVariableIndex, 0),
254 createIndex(updatedVariableIndex, columnCount() - 1));
254 createIndex(updatedVariableIndex, columnCount() - 1));
255 }
255 }
256 }
256 }
257 }
257 }
258
258
259 int VariableModel::VariableModelPrivate::indexOfVariable(Variable *variable) const noexcept
259 int VariableModel::VariableModelPrivate::indexOfVariable(Variable *variable) const noexcept
260 {
260 {
261 auto begin = std::cbegin(m_Variables);
261 auto begin = std::cbegin(m_Variables);
262 auto end = std::cend(m_Variables);
262 auto end = std::cend(m_Variables);
263 auto it
263 auto it
264 = std::find_if(begin, end, [variable](const auto &var) { return var.get() == variable; });
264 = std::find_if(begin, end, [variable](const auto &var) { return var.get() == variable; });
265
265
266 if (it != end) {
266 if (it != end) {
267 // Gets the index of the variable in the model: we assume here that views have the same
267 // Gets the index of the variable in the model: we assume here that views have the same
268 // order as the model
268 // order as the model
269 return std::distance(begin, it);
269 return std::distance(begin, it);
270 }
270 }
271 else {
271 else {
272 return -1;
272 return -1;
273 }
273 }
274 }
274 }
Show file before | Show file after | Hide comments
@@ -1,259 +1,260
1 #include "Visualization/VisualizationZoneWidget.h"
1 #include "Visualization/VisualizationZoneWidget.h"
2
2
3
3
4 #include "Visualization/IVisualizationWidgetVisitor.h"
4 #include "Visualization/IVisualizationWidgetVisitor.h"
5 #include "Visualization/VisualizationGraphWidget.h"
5 #include "Visualization/VisualizationGraphWidget.h"
6 #include "ui_VisualizationZoneWidget.h"
6 #include "ui_VisualizationZoneWidget.h"
7
7
8 #include <Data/SqpRange.h>
8 #include <Data/SqpRange.h>
9 #include <Variable/Variable.h>
9 #include <Variable/Variable.h>
10 #include <Variable/VariableController.h>
10 #include <Variable/VariableController.h>
11
11
12 #include <QUuid>
12 #include <QUuid>
13 #include <SqpApplication.h>
13 #include <SqpApplication.h>
14 #include <cmath>
14 #include <cmath>
15
15
16 Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
16 Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
17
17
18 namespace {
18 namespace {
19
19
20 /// Minimum height for graph added in zones (in pixels)
20 /// Minimum height for graph added in zones (in pixels)
21 const auto GRAPH_MINIMUM_HEIGHT = 300;
21 const auto GRAPH_MINIMUM_HEIGHT = 300;
22
22
23 /// Generates a default name for a new graph, according to the number of graphs already displayed in
23 /// Generates a default name for a new graph, according to the number of graphs already displayed in
24 /// the zone
24 /// the zone
25 QString defaultGraphName(const QLayout &layout)
25 QString defaultGraphName(const QLayout &layout)
26 {
26 {
27 auto count = 0;
27 auto count = 0;
28 for (auto i = 0; i < layout.count(); ++i) {
28 for (auto i = 0; i < layout.count(); ++i) {
29 if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
29 if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
30 count++;
30 count++;
31 }
31 }
32 }
32 }
33
33
34 return QObject::tr("Graph %1").arg(count + 1);
34 return QObject::tr("Graph %1").arg(count + 1);
35 }
35 }
36
36
37 } // namespace
37 } // namespace
38
38
39 struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
39 struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
40
40
41 explicit VisualizationZoneWidgetPrivate() : m_SynchronisationGroupId{QUuid::createUuid()} {}
41 explicit VisualizationZoneWidgetPrivate() : m_SynchronisationGroupId{QUuid::createUuid()} {}
42 QUuid m_SynchronisationGroupId;
42 QUuid m_SynchronisationGroupId;
43 };
43 };
44
44
45 VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
45 VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
46 : QWidget{parent},
46 : QWidget{parent},
47 ui{new Ui::VisualizationZoneWidget},
47 ui{new Ui::VisualizationZoneWidget},
48 impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
48 impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
49 {
49 {
50 ui->setupUi(this);
50 ui->setupUi(this);
51
51
52 ui->zoneNameLabel->setText(name);
52 ui->zoneNameLabel->setText(name);
53
53
54 // 'Close' options : widget is deleted when closed
54 // 'Close' options : widget is deleted when closed
55 setAttribute(Qt::WA_DeleteOnClose);
55 setAttribute(Qt::WA_DeleteOnClose);
56 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
56 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
57 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
57 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
58
58
59 // Synchronisation id
59 // Synchronisation id
60 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
60 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
61 Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
61 Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
62 }
62 }
63
63
64 VisualizationZoneWidget::~VisualizationZoneWidget()
64 VisualizationZoneWidget::~VisualizationZoneWidget()
65 {
65 {
66 delete ui;
66 delete ui;
67 }
67 }
68
68
69 void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
69 void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
70 {
70 {
71 ui->visualizationZoneFrame->layout()->addWidget(graphWidget);
71 ui->visualizationZoneFrame->layout()->addWidget(graphWidget);
72 }
72 }
73
73
74 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
74 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
75 {
75 {
76 auto graphWidget = new VisualizationGraphWidget{
76 auto graphWidget = new VisualizationGraphWidget{
77 defaultGraphName(*ui->visualizationZoneFrame->layout()), this};
77 defaultGraphName(*ui->visualizationZoneFrame->layout()), this};
78
78
79
79
80 // Set graph properties
80 // Set graph properties
81 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
81 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
82 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
82 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
83
83
84
84
85 // Lambda to synchronize zone widget
85 // Lambda to synchronize zone widget
86 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &graphRange,
86 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &graphRange,
87 const SqpRange &oldGraphRange) {
87 const SqpRange &oldGraphRange) {
88
88
89 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
89 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
90 auto frameLayout = ui->visualizationZoneFrame->layout();
90 auto frameLayout = ui->visualizationZoneFrame->layout();
91 for (auto i = 0; i < frameLayout->count(); ++i) {
91 for (auto i = 0; i < frameLayout->count(); ++i) {
92 auto graphChild
92 auto graphChild
93 = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
93 = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
94 if (graphChild && (graphChild != graphWidget)) {
94 if (graphChild && (graphChild != graphWidget)) {
95
95
96 auto graphChildRange = graphChild->graphRange();
96 auto graphChildRange = graphChild->graphRange();
97 switch (zoomType) {
97 switch (zoomType) {
98 case AcquisitionZoomType::ZoomIn: {
98 case AcquisitionZoomType::ZoomIn: {
99 auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
99 auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
100 auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
100 auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
101 graphChildRange.m_TStart += deltaLeft;
101 graphChildRange.m_TStart += deltaLeft;
102 graphChildRange.m_TEnd -= deltaRight;
102 graphChildRange.m_TEnd -= deltaRight;
103 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
103 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
104 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
104 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
105 << deltaLeft;
105 << deltaLeft;
106 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
106 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
107 << deltaRight;
107 << deltaRight;
108 qCDebug(LOG_VisualizationZoneWidget())
108 qCDebug(LOG_VisualizationZoneWidget())
109 << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
109 << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
110
110
111 break;
111 break;
112 }
112 }
113
113
114 case AcquisitionZoomType::ZoomOut: {
114 case AcquisitionZoomType::ZoomOut: {
115 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
115 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
116 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
116 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
117 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
117 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
118 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
118 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
119 << deltaLeft;
119 << deltaLeft;
120 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
120 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
121 << deltaRight;
121 << deltaRight;
122 qCDebug(LOG_VisualizationZoneWidget())
122 qCDebug(LOG_VisualizationZoneWidget())
123 << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
123 << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
124 graphChildRange.m_TStart -= deltaLeft;
124 graphChildRange.m_TStart -= deltaLeft;
125 graphChildRange.m_TEnd += deltaRight;
125 graphChildRange.m_TEnd += deltaRight;
126 break;
126 break;
127 }
127 }
128 case AcquisitionZoomType::PanRight: {
128 case AcquisitionZoomType::PanRight: {
129 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
129 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
130 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
130 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
131 graphChildRange.m_TStart += deltaRight;
131 graphChildRange.m_TStart += deltaRight;
132 graphChildRange.m_TEnd += deltaRight;
132 graphChildRange.m_TEnd += deltaRight;
133 qCDebug(LOG_VisualizationZoneWidget())
133 qCDebug(LOG_VisualizationZoneWidget())
134 << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
134 << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
135 break;
135 break;
136 }
136 }
137 case AcquisitionZoomType::PanLeft: {
137 case AcquisitionZoomType::PanLeft: {
138 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
138 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
139 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
139 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
140 graphChildRange.m_TStart -= deltaLeft;
140 graphChildRange.m_TStart -= deltaLeft;
141 graphChildRange.m_TEnd -= deltaLeft;
141 graphChildRange.m_TEnd -= deltaLeft;
142 break;
142 break;
143 }
143 }
144 case AcquisitionZoomType::Unknown: {
144 case AcquisitionZoomType::Unknown: {
145 qCDebug(LOG_VisualizationZoneWidget())
145 qCDebug(LOG_VisualizationZoneWidget())
146 << tr("Impossible to synchronize: zoom type unknown");
146 << tr("Impossible to synchronize: zoom type unknown");
147 break;
147 break;
148 }
148 }
149 default:
149 default:
150 qCCritical(LOG_VisualizationZoneWidget())
150 qCCritical(LOG_VisualizationZoneWidget())
151 << tr("Impossible to synchronize: zoom type not take into account");
151 << tr("Impossible to synchronize: zoom type not take into account");
152 // No action
152 // No action
153 break;
153 break;
154 }
154 }
155 graphChild->enableAcquisition(false);
155 graphChild->enableAcquisition(false);
156 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
156 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
157 << graphChild->graphRange();
157 << graphChild->graphRange();
158 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
158 qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
159 << graphChildRange;
159 << graphChildRange;
160 qCDebug(LOG_VisualizationZoneWidget())
160 qCDebug(LOG_VisualizationZoneWidget())
161 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
161 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
162 graphChild->setGraphRange(graphChildRange);
162 graphChild->setGraphRange(graphChildRange);
163 graphChild->enableAcquisition(true);
163 graphChild->enableAcquisition(true);
164 }
164 }
165 }
165 }
166 };
166 };
167
167
168 // connection for synchronization
168 // connection for synchronization
169 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
169 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
170 connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
170 connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
171 &VisualizationZoneWidget::onVariableAdded);
171 &VisualizationZoneWidget::onVariableAdded);
172
172
173 auto range = SqpRange{};
173 auto range = SqpRange{};
174
174
175 // Apply visitor to graph children
175 // Apply visitor to graph children
176 auto layout = ui->visualizationZoneFrame->layout();
176 auto layout = ui->visualizationZoneFrame->layout();
177 if (layout->count() > 0) {
177 if (layout->count() > 0) {
178 // Case of a new graph in a existant zone
178 // Case of a new graph in a existant zone
179 if (auto visualizationGraphWidget
179 if (auto visualizationGraphWidget
180 = dynamic_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
180 = dynamic_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
181 range = visualizationGraphWidget->graphRange();
181 range = visualizationGraphWidget->graphRange();
182 }
182 }
183 }
183 }
184 else {
184 else {
185 // Case of a new graph as the first of the zone
185 // Case of a new graph as the first of the zone
186 range = variable->range();
186 range = variable->range();
187 }
187 }
188
188
189 this->addGraph(graphWidget);
189 this->addGraph(graphWidget);
190
190
191 graphWidget->addVariable(variable, range);
191 graphWidget->addVariable(variable, range);
192
192
193 // get y using variable range
193 // get y using variable range
194 if (auto dataSeries = variable->dataSeries()) {
194 if (auto dataSeries = variable->dataSeries()) {
195 dataSeries->lockRead();
195 dataSeries->lockRead();
196 auto valuesBounds = dataSeries->valuesBounds(variable->range().m_TStart, variable->range().m_TEnd);
196 auto valuesBounds
197 = dataSeries->valuesBounds(variable->range().m_TStart, variable->range().m_TEnd);
197 auto end = dataSeries->cend();
198 auto end = dataSeries->cend();
198 if (valuesBounds.first != end && valuesBounds.second != end) {
199 if (valuesBounds.first != end && valuesBounds.second != end) {
199 auto rangeValue = [](const auto &value) { return std::isnan(value) ? 0. : value; };
200 auto rangeValue = [](const auto &value) { return std::isnan(value) ? 0. : value; };
200
201
201 auto minValue = rangeValue(valuesBounds.first->minValue());
202 auto minValue = rangeValue(valuesBounds.first->minValue());
202 auto maxValue = rangeValue(valuesBounds.second->maxValue());
203 auto maxValue = rangeValue(valuesBounds.second->maxValue());
203
204
204 graphWidget->setYRange(SqpRange{minValue, maxValue});
205 graphWidget->setYRange(SqpRange{minValue, maxValue});
205 }
206 }
206 dataSeries->unlock();
207 dataSeries->unlock();
207 }
208 }
208
209
209 return graphWidget;
210 return graphWidget;
210 }
211 }
211
212
212 void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
213 void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
213 {
214 {
214 if (visitor) {
215 if (visitor) {
215 visitor->visitEnter(this);
216 visitor->visitEnter(this);
216
217
217 // Apply visitor to graph children
218 // Apply visitor to graph children
218 auto layout = ui->visualizationZoneFrame->layout();
219 auto layout = ui->visualizationZoneFrame->layout();
219 for (auto i = 0; i < layout->count(); ++i) {
220 for (auto i = 0; i < layout->count(); ++i) {
220 if (auto item = layout->itemAt(i)) {
221 if (auto item = layout->itemAt(i)) {
221 // Widgets different from graphs are not visited (no action)
222 // Widgets different from graphs are not visited (no action)
222 if (auto visualizationGraphWidget
223 if (auto visualizationGraphWidget
223 = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
224 = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
224 visualizationGraphWidget->accept(visitor);
225 visualizationGraphWidget->accept(visitor);
225 }
226 }
226 }
227 }
227 }
228 }
228
229
229 visitor->visitLeave(this);
230 visitor->visitLeave(this);
230 }
231 }
231 else {
232 else {
232 qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
233 qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
233 }
234 }
234 }
235 }
235
236
236 bool VisualizationZoneWidget::canDrop(const Variable &variable) const
237 bool VisualizationZoneWidget::canDrop(const Variable &variable) const
237 {
238 {
238 // A tab can always accomodate a variable
239 // A tab can always accomodate a variable
239 Q_UNUSED(variable);
240 Q_UNUSED(variable);
240 return true;
241 return true;
241 }
242 }
242
243
243 bool VisualizationZoneWidget::contains(const Variable &variable) const
244 bool VisualizationZoneWidget::contains(const Variable &variable) const
244 {
245 {
245 Q_UNUSED(variable);
246 Q_UNUSED(variable);
246 return false;
247 return false;
247 }
248 }
248
249
249 QString VisualizationZoneWidget::name() const
250 QString VisualizationZoneWidget::name() const
250 {
251 {
251 return ui->zoneNameLabel->text();
252 return ui->zoneNameLabel->text();
252 }
253 }
253
254
254 void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
255 void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
255 {
256 {
256 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
257 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
257 Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
258 Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
258 Q_ARG(QUuid, impl->m_SynchronisationGroupId));
259 Q_ARG(QUuid, impl->m_SynchronisationGroupId));
259 }
260 }
General Comments 3
Under Review
perrinel
author
Comment #1958
Edit
Delete
|

Auto status change to "Under Review"

Approved
perrinel
author
Comment #1959
Edit
Delete
|

Status change > Approved

You need to be logged in to leave comments. Login now