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

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Corrects the problem of refreshing synchronized graphs from TimeWidget (2)...
Alexandre Leroux -
r1326:2f3864d52888
parent child
Show More
Side by Side Unified
Context file:
r1326:2f3864d52888 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,1003 +1,1004
1 1 #include "Visualization/VisualizationGraphWidget.h"
2 2 #include "Visualization/IVisualizationWidgetVisitor.h"
3 3 #include "Visualization/VisualizationCursorItem.h"
4 4 #include "Visualization/VisualizationDefs.h"
5 5 #include "Visualization/VisualizationGraphHelper.h"
6 6 #include "Visualization/VisualizationGraphRenderingDelegate.h"
7 7 #include "Visualization/VisualizationMultiZoneSelectionDialog.h"
8 8 #include "Visualization/VisualizationSelectionZoneItem.h"
9 9 #include "Visualization/VisualizationSelectionZoneManager.h"
10 10 #include "Visualization/VisualizationWidget.h"
11 11 #include "Visualization/VisualizationZoneWidget.h"
12 12 #include "ui_VisualizationGraphWidget.h"
13 13
14 14 #include <Actions/ActionsGuiController.h>
15 15 #include <Common/MimeTypesDef.h>
16 16 #include <Data/ArrayData.h>
17 17 #include <Data/IDataSeries.h>
18 18 #include <Data/SpectrogramSeries.h>
19 19 #include <DragAndDrop/DragDropGuiController.h>
20 20 #include <Settings/SqpSettingsDefs.h>
21 21 #include <SqpApplication.h>
22 22 #include <Time/TimeController.h>
23 23 #include <Variable/Variable.h>
24 24 #include <Variable/VariableController.h>
25 25
26 26 #include <unordered_map>
27 27
28 28 Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
29 29
30 30 namespace {
31 31
32 32 /// Key pressed to enable drag&drop in all modes
33 33 const auto DRAG_DROP_MODIFIER = Qt::AltModifier;
34 34
35 35 /// Key pressed to enable zoom on horizontal axis
36 36 const auto HORIZONTAL_ZOOM_MODIFIER = Qt::ControlModifier;
37 37
38 38 /// Key pressed to enable zoom on vertical axis
39 39 const auto VERTICAL_ZOOM_MODIFIER = Qt::ShiftModifier;
40 40
41 41 /// Speed of a step of a wheel event for a pan, in percentage of the axis range
42 42 const auto PAN_SPEED = 5;
43 43
44 44 /// Key pressed to enable a calibration pan
45 45 const auto VERTICAL_PAN_MODIFIER = Qt::AltModifier;
46 46
47 47 /// Key pressed to enable multi selection of selection zones
48 48 const auto MULTI_ZONE_SELECTION_MODIFIER = Qt::ControlModifier;
49 49
50 50 /// Minimum size for the zoom box, in percentage of the axis range
51 51 const auto ZOOM_BOX_MIN_SIZE = 0.8;
52 52
53 53 /// Format of the dates appearing in the label of a cursor
54 54 const auto CURSOR_LABELS_DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd\nhh:mm:ss:zzz");
55 55
56 56 } // namespace
57 57
58 58 struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
59 59
60 60 explicit VisualizationGraphWidgetPrivate(const QString &name)
61 61 : m_Name{name},
62 62 m_Flags{GraphFlag::EnableAll},
63 63 m_IsCalibration{false},
64 64 m_RenderingDelegate{nullptr}
65 65 {
66 66 }
67 67
68 68 void updateData(PlottablesMap &plottables, std::shared_ptr<IDataSeries> dataSeries,
69 69 const SqpRange &range)
70 70 {
71 71 VisualizationGraphHelper::updateData(plottables, dataSeries, range);
72 72
73 73 // Prevents that data has changed to update rendering
74 74 m_RenderingDelegate->onPlotUpdated();
75 75 }
76 76
77 77 QString m_Name;
78 78 // 1 variable -> n qcpplot
79 79 std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
80 80 GraphFlags m_Flags;
81 81 bool m_IsCalibration;
82 82 /// Delegate used to attach rendering features to the plot
83 83 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
84 84
85 85 QCPItemRect *m_DrawingZoomRect = nullptr;
86 86 QStack<QPair<QCPRange, QCPRange> > m_ZoomStack;
87 87
88 88 std::unique_ptr<VisualizationCursorItem> m_HorizontalCursor = nullptr;
89 89 std::unique_ptr<VisualizationCursorItem> m_VerticalCursor = nullptr;
90 90
91 91 VisualizationSelectionZoneItem *m_DrawingZone = nullptr;
92 92 VisualizationSelectionZoneItem *m_HoveredZone = nullptr;
93 93 QVector<VisualizationSelectionZoneItem *> m_SelectionZones;
94 94
95 95 bool m_HasMovedMouse = false; // Indicates if the mouse moved in a releaseMouse even
96 96
97 97 void startDrawingRect(const QPoint &pos, QCustomPlot &plot)
98 98 {
99 99 removeDrawingRect(plot);
100 100
101 101 auto axisPos = posToAxisPos(pos, plot);
102 102
103 103 m_DrawingZoomRect = new QCPItemRect{&plot};
104 104 QPen p;
105 105 p.setWidth(2);
106 106 m_DrawingZoomRect->setPen(p);
107 107
108 108 m_DrawingZoomRect->topLeft->setCoords(axisPos);
109 109 m_DrawingZoomRect->bottomRight->setCoords(axisPos);
110 110 }
111 111
112 112 void removeDrawingRect(QCustomPlot &plot)
113 113 {
114 114 if (m_DrawingZoomRect) {
115 115 plot.removeItem(m_DrawingZoomRect); // the item is deleted by QCustomPlot
116 116 m_DrawingZoomRect = nullptr;
117 117 plot.replot(QCustomPlot::rpQueuedReplot);
118 118 }
119 119 }
120 120
121 121 void startDrawingZone(const QPoint &pos, VisualizationGraphWidget *graph)
122 122 {
123 123 endDrawingZone(graph);
124 124
125 125 auto axisPos = posToAxisPos(pos, graph->plot());
126 126
127 127 m_DrawingZone = new VisualizationSelectionZoneItem{&graph->plot()};
128 128 m_DrawingZone->setRange(axisPos.x(), axisPos.x());
129 129 m_DrawingZone->setEditionEnabled(false);
130 130 }
131 131
132 132 void endDrawingZone(VisualizationGraphWidget *graph)
133 133 {
134 134 if (m_DrawingZone) {
135 135 auto drawingZoneRange = m_DrawingZone->range();
136 136 if (qAbs(drawingZoneRange.m_TEnd - drawingZoneRange.m_TStart) > 0) {
137 137 m_DrawingZone->setEditionEnabled(true);
138 138 addSelectionZone(m_DrawingZone);
139 139 }
140 140 else {
141 141 graph->plot().removeItem(m_DrawingZone); // the item is deleted by QCustomPlot
142 142 }
143 143
144 144 graph->plot().replot(QCustomPlot::rpQueuedReplot);
145 145 m_DrawingZone = nullptr;
146 146 }
147 147 }
148 148
149 149 void setSelectionZonesEditionEnabled(bool value)
150 150 {
151 151 for (auto s : m_SelectionZones) {
152 152 s->setEditionEnabled(value);
153 153 }
154 154 }
155 155
156 156 void addSelectionZone(VisualizationSelectionZoneItem *zone) { m_SelectionZones << zone; }
157 157
158 158 VisualizationSelectionZoneItem *selectionZoneAt(const QPoint &pos,
159 159 const QCustomPlot &plot) const
160 160 {
161 161 VisualizationSelectionZoneItem *selectionZoneItemUnderCursor = nullptr;
162 162 auto minDistanceToZone = -1;
163 163 for (auto zone : m_SelectionZones) {
164 164 auto distanceToZone = zone->selectTest(pos, false);
165 165 if ((minDistanceToZone < 0 || distanceToZone <= minDistanceToZone)
166 166 && distanceToZone >= 0 && distanceToZone < plot.selectionTolerance()) {
167 167 selectionZoneItemUnderCursor = zone;
168 168 }
169 169 }
170 170
171 171 return selectionZoneItemUnderCursor;
172 172 }
173 173
174 174 QVector<VisualizationSelectionZoneItem *> selectionZonesAt(const QPoint &pos,
175 175 const QCustomPlot &plot) const
176 176 {
177 177 QVector<VisualizationSelectionZoneItem *> zones;
178 178 for (auto zone : m_SelectionZones) {
179 179 auto distanceToZone = zone->selectTest(pos, false);
180 180 if (distanceToZone >= 0 && distanceToZone < plot.selectionTolerance()) {
181 181 zones << zone;
182 182 }
183 183 }
184 184
185 185 return zones;
186 186 }
187 187
188 188 void moveSelectionZoneOnTop(VisualizationSelectionZoneItem *zone, QCustomPlot &plot)
189 189 {
190 190 if (!m_SelectionZones.isEmpty() && m_SelectionZones.last() != zone) {
191 191 zone->moveToTop();
192 192 m_SelectionZones.removeAll(zone);
193 193 m_SelectionZones.append(zone);
194 194 }
195 195 }
196 196
197 197 QPointF posToAxisPos(const QPoint &pos, QCustomPlot &plot) const
198 198 {
199 199 auto axisX = plot.axisRect()->axis(QCPAxis::atBottom);
200 200 auto axisY = plot.axisRect()->axis(QCPAxis::atLeft);
201 201 return QPointF{axisX->pixelToCoord(pos.x()), axisY->pixelToCoord(pos.y())};
202 202 }
203 203
204 204 bool pointIsInAxisRect(const QPointF &axisPoint, QCustomPlot &plot) const
205 205 {
206 206 auto axisX = plot.axisRect()->axis(QCPAxis::atBottom);
207 207 auto axisY = plot.axisRect()->axis(QCPAxis::atLeft);
208 208 return axisX->range().contains(axisPoint.x()) && axisY->range().contains(axisPoint.y());
209 209 }
210 210 };
211 211
212 212 VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
213 213 : VisualizationDragWidget{parent},
214 214 ui{new Ui::VisualizationGraphWidget},
215 215 impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name)}
216 216 {
217 217 ui->setupUi(this);
218 218
219 219 // 'Close' options : widget is deleted when closed
220 220 setAttribute(Qt::WA_DeleteOnClose);
221 221
222 222 // Set qcpplot properties :
223 223 // - zoom is enabled
224 224 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
225 225 ui->widget->setInteractions(QCP::iRangeZoom);
226 226 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal | Qt::Vertical);
227 227
228 228 // The delegate must be initialized after the ui as it uses the plot
229 229 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*this);
230 230
231 231 // Init the cursors
232 232 impl->m_HorizontalCursor = std::make_unique<VisualizationCursorItem>(&plot());
233 233 impl->m_HorizontalCursor->setOrientation(Qt::Horizontal);
234 234 impl->m_VerticalCursor = std::make_unique<VisualizationCursorItem>(&plot());
235 235 impl->m_VerticalCursor->setOrientation(Qt::Vertical);
236 236
237 237 connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
238 238 connect(ui->widget, &QCustomPlot::mouseRelease, this,
239 239 &VisualizationGraphWidget::onMouseRelease);
240 240 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
241 241 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
242 242 connect(ui->widget, &QCustomPlot::mouseDoubleClick, this,
243 243 &VisualizationGraphWidget::onMouseDoubleClick);
244 244 connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
245 245 &QCPAxis::rangeChanged),
246 246 this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
247 247
248 248 // Activates menu when right clicking on the graph
249 249 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
250 250 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
251 251 &VisualizationGraphWidget::onGraphMenuRequested);
252 252
253 253 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
254 254 &VariableController::onRequestDataLoading);
255 255
256 256 connect(&sqpApp->variableController(), &VariableController::updateVarDisplaying, this,
257 257 &VisualizationGraphWidget::onUpdateVarDisplaying);
258 258
259 259 #ifdef Q_OS_MAC
260 260 plot().setPlottingHint(QCP::phFastPolylines, true);
261 261 #endif
262 262 }
263 263
264 264
265 265 VisualizationGraphWidget::~VisualizationGraphWidget()
266 266 {
267 267 delete ui;
268 268 }
269 269
270 270 VisualizationZoneWidget *VisualizationGraphWidget::parentZoneWidget() const noexcept
271 271 {
272 272 auto parent = parentWidget();
273 273 while (parent != nullptr && !qobject_cast<VisualizationZoneWidget *>(parent)) {
274 274 parent = parent->parentWidget();
275 275 }
276 276
277 277 return qobject_cast<VisualizationZoneWidget *>(parent);
278 278 }
279 279
280 280 VisualizationWidget *VisualizationGraphWidget::parentVisualizationWidget() const
281 281 {
282 282 auto parent = parentWidget();
283 283 while (parent != nullptr && !qobject_cast<VisualizationWidget *>(parent)) {
284 284 parent = parent->parentWidget();
285 285 }
286 286
287 287 return qobject_cast<VisualizationWidget *>(parent);
288 288 }
289 289
290 290 void VisualizationGraphWidget::setFlags(GraphFlags flags)
291 291 {
292 292 impl->m_Flags = std::move(flags);
293 293 }
294 294
295 295 void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
296 296 {
297 297 // Uses delegate to create the qcpplot components according to the variable
298 298 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
299 299
300 300 if (auto dataSeries = variable->dataSeries()) {
301 301 // Set axes properties according to the units of the data series
302 302 impl->m_RenderingDelegate->setAxesProperties(dataSeries);
303 303
304 304 // Sets rendering properties for the new plottables
305 305 // Warning: this method must be called after setAxesProperties(), as it can access to some
306 306 // axes properties that have to be initialized
307 307 impl->m_RenderingDelegate->setPlottablesProperties(dataSeries, createdPlottables);
308 308 }
309 309
310 310 impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
311 311
312 312 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
313 313
314 314 this->setFlags(GraphFlag::DisableAll);
315 315 this->setGraphRange(range);
316 316 this->setFlags(GraphFlag::EnableAll);
317 317
318 318 emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable, range, false);
319 319
320 320 emit variableAdded(variable);
321 321 }
322 322
323 323 void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
324 324 {
325 325 // Each component associated to the variable :
326 326 // - is removed from qcpplot (which deletes it)
327 327 // - is no longer referenced in the map
328 328 auto variableIt = impl->m_VariableToPlotMultiMap.find(variable);
329 329 if (variableIt != impl->m_VariableToPlotMultiMap.cend()) {
330 330 emit variableAboutToBeRemoved(variable);
331 331
332 332 auto &plottablesMap = variableIt->second;
333 333
334 334 for (auto plottableIt = plottablesMap.cbegin(), plottableEnd = plottablesMap.cend();
335 335 plottableIt != plottableEnd;) {
336 336 ui->widget->removePlottable(plottableIt->second);
337 337 plottableIt = plottablesMap.erase(plottableIt);
338 338 }
339 339
340 340 impl->m_VariableToPlotMultiMap.erase(variableIt);
341 341 }
342 342
343 343 // Updates graph
344 344 ui->widget->replot();
345 345 }
346 346
347 347 QList<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
348 348 {
349 349 auto variables = QList<std::shared_ptr<Variable> >{};
350 350 for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap);
351 351 it != std::cend(impl->m_VariableToPlotMultiMap); ++it) {
352 352 variables << it->first;
353 353 }
354 354
355 355 return variables;
356 356 }
357 357
358 358 void VisualizationGraphWidget::setYRange(std::shared_ptr<Variable> variable)
359 359 {
360 360 if (!variable) {
361 361 qCCritical(LOG_VisualizationGraphWidget()) << "Can't set y-axis range: variable is null";
362 362 return;
363 363 }
364 364
365 365 VisualizationGraphHelper::setYAxisRange(variable, *ui->widget);
366 366 }
367 367
368 368 SqpRange VisualizationGraphWidget::graphRange() const noexcept
369 369 {
370 370 auto graphRange = ui->widget->xAxis->range();
371 371 return SqpRange{graphRange.lower, graphRange.upper};
372 372 }
373 373
374 374 void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
375 375 {
376 376 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
377 377 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
378 378 ui->widget->replot();
379 379 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
380 380 }
381 381
382 382 QVector<SqpRange> VisualizationGraphWidget::selectionZoneRanges() const
383 383 {
384 384 QVector<SqpRange> ranges;
385 385 for (auto zone : impl->m_SelectionZones) {
386 386 ranges << zone->range();
387 387 }
388 388
389 389 return ranges;
390 390 }
391 391
392 392 void VisualizationGraphWidget::addSelectionZones(const QVector<SqpRange> &ranges)
393 393 {
394 394 for (const auto &range : ranges) {
395 395 // note: ownership is transfered to QCustomPlot
396 396 auto zone = new VisualizationSelectionZoneItem(&plot());
397 397 zone->setRange(range.m_TStart, range.m_TEnd);
398 398 impl->addSelectionZone(zone);
399 399 }
400 400
401 401 plot().replot(QCustomPlot::rpQueuedReplot);
402 402 }
403 403
404 404 void VisualizationGraphWidget::removeSelectionZone(VisualizationSelectionZoneItem *selectionZone)
405 405 {
406 406 parentVisualizationWidget()->selectionZoneManager().setSelected(selectionZone, false);
407 407
408 408 if (impl->m_HoveredZone == selectionZone) {
409 409 impl->m_HoveredZone = nullptr;
410 410 setCursor(Qt::ArrowCursor);
411 411 }
412 412
413 413 impl->m_SelectionZones.removeAll(selectionZone);
414 414 plot().removeItem(selectionZone);
415 415 plot().replot(QCustomPlot::rpQueuedReplot);
416 416 }
417 417
418 418 void VisualizationGraphWidget::undoZoom()
419 419 {
420 420 auto zoom = impl->m_ZoomStack.pop();
421 421 auto axisX = plot().axisRect()->axis(QCPAxis::atBottom);
422 422 auto axisY = plot().axisRect()->axis(QCPAxis::atLeft);
423 423
424 424 axisX->setRange(zoom.first);
425 425 axisY->setRange(zoom.second);
426 426
427 427 plot().replot(QCustomPlot::rpQueuedReplot);
428 428 }
429 429
430 430 void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
431 431 {
432 432 if (visitor) {
433 433 visitor->visit(this);
434 434 }
435 435 else {
436 436 qCCritical(LOG_VisualizationGraphWidget())
437 437 << tr("Can't visit widget : the visitor is null");
438 438 }
439 439 }
440 440
441 441 bool VisualizationGraphWidget::canDrop(const Variable &variable) const
442 442 {
443 443 auto isSpectrogram = [](const auto &variable) {
444 444 return std::dynamic_pointer_cast<SpectrogramSeries>(variable.dataSeries()) != nullptr;
445 445 };
446 446
447 447 // - A spectrogram series can't be dropped on graph with existing plottables
448 448 // - No data series can be dropped on graph with existing spectrogram series
449 449 return isSpectrogram(variable)
450 450 ? impl->m_VariableToPlotMultiMap.empty()
451 451 : std::none_of(
452 452 impl->m_VariableToPlotMultiMap.cbegin(), impl->m_VariableToPlotMultiMap.cend(),
453 453 [isSpectrogram](const auto &entry) { return isSpectrogram(*entry.first); });
454 454 }
455 455
456 456 bool VisualizationGraphWidget::contains(const Variable &variable) const
457 457 {
458 458 // Finds the variable among the keys of the map
459 459 auto variablePtr = &variable;
460 460 auto findVariable
461 461 = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
462 462
463 463 auto end = impl->m_VariableToPlotMultiMap.cend();
464 464 auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
465 465 return it != end;
466 466 }
467 467
468 468 QString VisualizationGraphWidget::name() const
469 469 {
470 470 return impl->m_Name;
471 471 }
472 472
473 473 QMimeData *VisualizationGraphWidget::mimeData(const QPoint &position) const
474 474 {
475 475 auto mimeData = new QMimeData;
476 476
477 477 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(position, plot());
478 478 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
479 479 && selectionZoneItemUnderCursor) {
480 480 mimeData->setData(MIME_TYPE_TIME_RANGE, TimeController::mimeDataForTimeRange(
481 481 selectionZoneItemUnderCursor->range()));
482 482 mimeData->setData(MIME_TYPE_SELECTION_ZONE, TimeController::mimeDataForTimeRange(
483 483 selectionZoneItemUnderCursor->range()));
484 484 }
485 485 else {
486 486 mimeData->setData(MIME_TYPE_GRAPH, QByteArray{});
487 487
488 488 auto timeRangeData = TimeController::mimeDataForTimeRange(graphRange());
489 489 mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
490 490 }
491 491
492 492 return mimeData;
493 493 }
494 494
495 495 QPixmap VisualizationGraphWidget::customDragPixmap(const QPoint &dragPosition)
496 496 {
497 497 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(dragPosition, plot());
498 498 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
499 499 && selectionZoneItemUnderCursor) {
500 500
501 501 auto zoneTopLeft = selectionZoneItemUnderCursor->topLeft->pixelPosition();
502 502 auto zoneBottomRight = selectionZoneItemUnderCursor->bottomRight->pixelPosition();
503 503
504 504 auto zoneSize = QSizeF{qAbs(zoneBottomRight.x() - zoneTopLeft.x()),
505 505 qAbs(zoneBottomRight.y() - zoneTopLeft.y())}
506 506 .toSize();
507 507
508 508 auto pixmap = QPixmap(zoneSize);
509 509 render(&pixmap, QPoint(), QRegion{QRect{zoneTopLeft.toPoint(), zoneSize}});
510 510
511 511 return pixmap;
512 512 }
513 513
514 514 return QPixmap();
515 515 }
516 516
517 517 bool VisualizationGraphWidget::isDragAllowed() const
518 518 {
519 519 return true;
520 520 }
521 521
522 522 void VisualizationGraphWidget::highlightForMerge(bool highlighted)
523 523 {
524 524 if (highlighted) {
525 525 plot().setBackground(QBrush(QColor("#BBD5EE")));
526 526 }
527 527 else {
528 528 plot().setBackground(QBrush(Qt::white));
529 529 }
530 530
531 531 plot().update();
532 532 }
533 533
534 534 void VisualizationGraphWidget::addVerticalCursor(double time)
535 535 {
536 536 impl->m_VerticalCursor->setPosition(time);
537 537 impl->m_VerticalCursor->setVisible(true);
538 538
539 539 auto text
540 540 = DateUtils::dateTime(time).toString(CURSOR_LABELS_DATETIME_FORMAT).replace(' ', '\n');
541 541 impl->m_VerticalCursor->setLabelText(text);
542 542 }
543 543
544 544 void VisualizationGraphWidget::addVerticalCursorAtViewportPosition(double position)
545 545 {
546 546 impl->m_VerticalCursor->setAbsolutePosition(position);
547 547 impl->m_VerticalCursor->setVisible(true);
548 548
549 549 auto axis = plot().axisRect()->axis(QCPAxis::atBottom);
550 550 auto text
551 551 = DateUtils::dateTime(axis->pixelToCoord(position)).toString(CURSOR_LABELS_DATETIME_FORMAT);
552 552 impl->m_VerticalCursor->setLabelText(text);
553 553 }
554 554
555 555 void VisualizationGraphWidget::removeVerticalCursor()
556 556 {
557 557 impl->m_VerticalCursor->setVisible(false);
558 558 plot().replot(QCustomPlot::rpQueuedReplot);
559 559 }
560 560
561 561 void VisualizationGraphWidget::addHorizontalCursor(double value)
562 562 {
563 563 impl->m_HorizontalCursor->setPosition(value);
564 564 impl->m_HorizontalCursor->setVisible(true);
565 565 impl->m_HorizontalCursor->setLabelText(QString::number(value));
566 566 }
567 567
568 568 void VisualizationGraphWidget::addHorizontalCursorAtViewportPosition(double position)
569 569 {
570 570 impl->m_HorizontalCursor->setAbsolutePosition(position);
571 571 impl->m_HorizontalCursor->setVisible(true);
572 572
573 573 auto axis = plot().axisRect()->axis(QCPAxis::atLeft);
574 574 impl->m_HorizontalCursor->setLabelText(QString::number(axis->pixelToCoord(position)));
575 575 }
576 576
577 577 void VisualizationGraphWidget::removeHorizontalCursor()
578 578 {
579 579 impl->m_HorizontalCursor->setVisible(false);
580 580 plot().replot(QCustomPlot::rpQueuedReplot);
581 581 }
582 582
583 583 void VisualizationGraphWidget::closeEvent(QCloseEvent *event)
584 584 {
585 585 Q_UNUSED(event);
586 586
587 587 // Prevents that all variables will be removed from graph when it will be closed
588 588 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
589 589 emit variableAboutToBeRemoved(variableEntry.first);
590 590 }
591 591 }
592 592
593 593 void VisualizationGraphWidget::enterEvent(QEvent *event)
594 594 {
595 595 Q_UNUSED(event);
596 596 impl->m_RenderingDelegate->showGraphOverlay(true);
597 597 }
598 598
599 599 void VisualizationGraphWidget::leaveEvent(QEvent *event)
600 600 {
601 601 Q_UNUSED(event);
602 602 impl->m_RenderingDelegate->showGraphOverlay(false);
603 603
604 604 if (auto parentZone = parentZoneWidget()) {
605 605 parentZone->notifyMouseLeaveGraph(this);
606 606 }
607 607 else {
608 608 qCWarning(LOG_VisualizationGraphWidget()) << "leaveEvent: No parent zone widget";
609 609 }
610 610
611 611 if (impl->m_HoveredZone) {
612 612 impl->m_HoveredZone->setHovered(false);
613 613 impl->m_HoveredZone = nullptr;
614 614 }
615 615 }
616 616
617 617 QCustomPlot &VisualizationGraphWidget::plot() const noexcept
618 618 {
619 619 return *ui->widget;
620 620 }
621 621
622 622 void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
623 623 {
624 624 QMenu graphMenu{};
625 625
626 626 // Iterates on variables (unique keys)
627 627 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
628 628 end = impl->m_VariableToPlotMultiMap.cend();
629 629 it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
630 630 // 'Remove variable' action
631 631 graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
632 632 [ this, var = it->first ]() { removeVariable(var); });
633 633 }
634 634
635 635 if (!impl->m_ZoomStack.isEmpty()) {
636 636 if (!graphMenu.isEmpty()) {
637 637 graphMenu.addSeparator();
638 638 }
639 639
640 640 graphMenu.addAction(tr("Undo Zoom"), [this]() { undoZoom(); });
641 641 }
642 642
643 643 // Selection Zone Actions
644 644 auto selectionZoneItem = impl->selectionZoneAt(pos, plot());
645 645 if (selectionZoneItem) {
646 646 auto selectedItems = parentVisualizationWidget()->selectionZoneManager().selectedItems();
647 647 selectedItems.removeAll(selectionZoneItem);
648 648 selectedItems.prepend(selectionZoneItem); // Put the current selection zone first
649 649
650 650 auto zoneActions = sqpApp->actionsGuiController().selectionZoneActions();
651 651 if (!zoneActions.isEmpty() && !graphMenu.isEmpty()) {
652 652 graphMenu.addSeparator();
653 653 }
654 654
655 655 QHash<QString, QMenu *> subMenus;
656 656 QHash<QString, bool> subMenusEnabled;
657 657
658 658 for (auto zoneAction : zoneActions) {
659 659
660 660 auto isEnabled = zoneAction->isEnabled(selectedItems);
661 661
662 662 auto menu = &graphMenu;
663 663 for (auto subMenuName : zoneAction->subMenuList()) {
664 664 if (!subMenus.contains(subMenuName)) {
665 665 menu = menu->addMenu(subMenuName);
666 666 subMenus[subMenuName] = menu;
667 667 subMenusEnabled[subMenuName] = isEnabled;
668 668 }
669 669 else {
670 670 menu = subMenus.value(subMenuName);
671 671 if (isEnabled) {
672 672 // The sub menu is enabled if at least one of its actions is enabled
673 673 subMenusEnabled[subMenuName] = true;
674 674 }
675 675 }
676 676 }
677 677
678 678 auto action = menu->addAction(zoneAction->name());
679 679 action->setEnabled(isEnabled);
680 680 action->setShortcut(zoneAction->displayedShortcut());
681 681 QObject::connect(action, &QAction::triggered,
682 682 [zoneAction, selectedItems]() { zoneAction->execute(selectedItems); });
683 683 }
684 684
685 685 for (auto it = subMenus.cbegin(); it != subMenus.cend(); ++it) {
686 686 it.value()->setEnabled(subMenusEnabled[it.key()]);
687 687 }
688 688 }
689 689
690 690 if (!graphMenu.isEmpty()) {
691 691 graphMenu.exec(QCursor::pos());
692 692 }
693 693 }
694 694
695 695 void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
696 696 {
697 697 qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
698 698 << QThread::currentThread()->objectName() << "DoAcqui"
699 699 << impl->m_Flags.testFlag(GraphFlag::EnableAcquisition);
700 700
701 701 auto graphRange = SqpRange{t1.lower, t1.upper};
702 702 auto oldGraphRange = SqpRange{t2.lower, t2.upper};
703 703
704 704 if (impl->m_Flags.testFlag(GraphFlag::EnableAcquisition)) {
705 705 QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
706 706
707 707 for (auto it = impl->m_VariableToPlotMultiMap.begin(),
708 708 end = impl->m_VariableToPlotMultiMap.end();
709 709 it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
710 710 variableUnderGraphVector.push_back(it->first);
711 711 }
712 712 emit requestDataLoading(std::move(variableUnderGraphVector), graphRange,
713 713 !impl->m_IsCalibration);
714 }
714 715
715 if (!impl->m_IsCalibration) {
716 qCDebug(LOG_VisualizationGraphWidget())
717 << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
718 << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
719 emit synchronize(graphRange, oldGraphRange);
720 }
716 if (impl->m_Flags.testFlag(GraphFlag::EnableSynchronization) && !impl->m_IsCalibration) {
717 qCDebug(LOG_VisualizationGraphWidget())
718 << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
719 << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
720 emit synchronize(graphRange, oldGraphRange);
721 721 }
722 722
723 723 auto pos = mapFromGlobal(QCursor::pos());
724 724 auto axisPos = impl->posToAxisPos(pos, plot());
725 725 if (auto parentZone = parentZoneWidget()) {
726 726 if (impl->pointIsInAxisRect(axisPos, plot())) {
727 727 parentZone->notifyMouseMoveInGraph(pos, axisPos, this);
728 728 }
729 729 else {
730 730 parentZone->notifyMouseLeaveGraph(this);
731 731 }
732 732 }
733 733 else {
734 734 qCWarning(LOG_VisualizationGraphWidget()) << "onMouseMove: No parent zone widget";
735 735 }
736
737 // Quits calibration
738 impl->m_IsCalibration = false;
736 739 }
737 740
738 741 void VisualizationGraphWidget::onMouseDoubleClick(QMouseEvent *event) noexcept
739 742 {
740 743 impl->m_RenderingDelegate->onMouseDoubleClick(event);
741 744 }
742 745
743 746 void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
744 747 {
745 748 // Handles plot rendering when mouse is moving
746 749 impl->m_RenderingDelegate->onMouseMove(event);
747 750
748 751 auto axisPos = impl->posToAxisPos(event->pos(), plot());
749 752
750 753 // Zoom box and zone drawing
751 754 if (impl->m_DrawingZoomRect) {
752 755 impl->m_DrawingZoomRect->bottomRight->setCoords(axisPos);
753 756 }
754 757 else if (impl->m_DrawingZone) {
755 758 impl->m_DrawingZone->setEnd(axisPos.x());
756 759 }
757 760
758 761 // Cursor
759 762 if (auto parentZone = parentZoneWidget()) {
760 763 if (impl->pointIsInAxisRect(axisPos, plot())) {
761 764 parentZone->notifyMouseMoveInGraph(event->pos(), axisPos, this);
762 765 }
763 766 else {
764 767 parentZone->notifyMouseLeaveGraph(this);
765 768 }
766 769 }
767 770 else {
768 771 qCWarning(LOG_VisualizationGraphWidget()) << "onMouseMove: No parent zone widget";
769 772 }
770 773
771 774 // Search for the selection zone under the mouse
772 775 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos(), plot());
773 776 if (selectionZoneItemUnderCursor && !impl->m_DrawingZone
774 777 && sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones) {
775 778
776 779 // Sets the appropriate cursor shape
777 780 auto cursorShape = selectionZoneItemUnderCursor->curshorShapeForPosition(event->pos());
778 781 setCursor(cursorShape);
779 782
780 783 // Manages the hovered zone
781 784 if (selectionZoneItemUnderCursor != impl->m_HoveredZone) {
782 785 if (impl->m_HoveredZone) {
783 786 impl->m_HoveredZone->setHovered(false);
784 787 }
785 788 selectionZoneItemUnderCursor->setHovered(true);
786 789 impl->m_HoveredZone = selectionZoneItemUnderCursor;
787 790 plot().replot(QCustomPlot::rpQueuedReplot);
788 791 }
789 792 }
790 793 else {
791 794 // There is no zone under the mouse or the interaction mode is not "selection zones"
792 795 if (impl->m_HoveredZone) {
793 796 impl->m_HoveredZone->setHovered(false);
794 797 impl->m_HoveredZone = nullptr;
795 798 }
796 799
797 800 setCursor(Qt::ArrowCursor);
798 801 }
799 802
800 803 impl->m_HasMovedMouse = true;
801 804 VisualizationDragWidget::mouseMoveEvent(event);
802 805 }
803 806
804 807 void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
805 808 {
806 809 auto value = event->angleDelta().x() + event->angleDelta().y();
807 810 if (value != 0) {
808 811
809 812 auto direction = value > 0 ? 1.0 : -1.0;
810 813 auto isZoomX = event->modifiers().testFlag(HORIZONTAL_ZOOM_MODIFIER);
811 814 auto isZoomY = event->modifiers().testFlag(VERTICAL_ZOOM_MODIFIER);
812 815 impl->m_IsCalibration = event->modifiers().testFlag(VERTICAL_PAN_MODIFIER);
813 816
814 817 auto zoomOrientations = QFlags<Qt::Orientation>{};
815 818 zoomOrientations.setFlag(Qt::Horizontal, isZoomX);
816 819 zoomOrientations.setFlag(Qt::Vertical, isZoomY);
817 820
818 821 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
819 822
820 823 if (!isZoomX && !isZoomY) {
821 824 auto axis = plot().axisRect()->axis(QCPAxis::atBottom);
822 825 auto diff = direction * (axis->range().size() * (PAN_SPEED / 100.0));
823 826
824 827 axis->setRange(axis->range() + diff);
825 828
826 829 if (plot().noAntialiasingOnDrag()) {
827 830 plot().setNotAntialiasedElements(QCP::aeAll);
828 831 }
829 832
830 833 plot().replot(QCustomPlot::rpQueuedReplot);
831 834 }
832 835 }
833 836 }
834 837
835 838 void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
836 839 {
837 840 auto isDragDropClick = event->modifiers().testFlag(DRAG_DROP_MODIFIER);
838 841 auto isSelectionZoneMode
839 842 = sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones;
840 843 auto isLeftClick = event->buttons().testFlag(Qt::LeftButton);
841 844
842 845 if (!isDragDropClick && isLeftClick) {
843 846 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::ZoomBox) {
844 847 // Starts a zoom box
845 848 impl->startDrawingRect(event->pos(), plot());
846 849 }
847 850 else if (isSelectionZoneMode && impl->m_DrawingZone == nullptr) {
848 851 // Starts a new selection zone
849 852 auto zoneAtPos = impl->selectionZoneAt(event->pos(), plot());
850 853 if (!zoneAtPos) {
851 854 impl->startDrawingZone(event->pos(), this);
852 855 }
853 856 }
854 857 }
855 858
856 859 // Allows mouse panning only in default mode
857 860 plot().setInteraction(QCP::iRangeDrag, sqpApp->plotsInteractionMode()
858 861 == SqpApplication::PlotsInteractionMode::None
859 862 && !isDragDropClick);
860 863
861 864 // Allows zone edition only in selection zone mode without drag&drop
862 865 impl->setSelectionZonesEditionEnabled(isSelectionZoneMode && !isDragDropClick);
863 866
864 867 // Selection / Deselection
865 868 if (isSelectionZoneMode) {
866 869 auto isMultiSelectionClick = event->modifiers().testFlag(MULTI_ZONE_SELECTION_MODIFIER);
867 870 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos(), plot());
868 871
869 872
870 873 if (selectionZoneItemUnderCursor && !selectionZoneItemUnderCursor->selected()
871 874 && !isMultiSelectionClick) {
872 875 parentVisualizationWidget()->selectionZoneManager().select(
873 876 {selectionZoneItemUnderCursor});
874 877 }
875 878 else if (!selectionZoneItemUnderCursor && !isMultiSelectionClick && isLeftClick) {
876 879 parentVisualizationWidget()->selectionZoneManager().clearSelection();
877 880 }
878 881 else {
879 882 // No selection change
880 883 }
881 884
882 885 if (selectionZoneItemUnderCursor && isLeftClick) {
883 886 selectionZoneItemUnderCursor->setAssociatedEditedZones(
884 887 parentVisualizationWidget()->selectionZoneManager().selectedItems());
885 888 }
886 889 }
887 890
888 891
889 892 impl->m_HasMovedMouse = false;
890 893 VisualizationDragWidget::mousePressEvent(event);
891 894 }
892 895
893 896 void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
894 897 {
895 898 if (impl->m_DrawingZoomRect) {
896 899
897 900 auto axisX = plot().axisRect()->axis(QCPAxis::atBottom);
898 901 auto axisY = plot().axisRect()->axis(QCPAxis::atLeft);
899 902
900 903 auto newAxisXRange = QCPRange{impl->m_DrawingZoomRect->topLeft->coords().x(),
901 904 impl->m_DrawingZoomRect->bottomRight->coords().x()};
902 905
903 906 auto newAxisYRange = QCPRange{impl->m_DrawingZoomRect->topLeft->coords().y(),
904 907 impl->m_DrawingZoomRect->bottomRight->coords().y()};
905 908
906 909 impl->removeDrawingRect(plot());
907 910
908 911 if (newAxisXRange.size() > axisX->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0)
909 912 && newAxisYRange.size() > axisY->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0)) {
910 913 impl->m_ZoomStack.push(qMakePair(axisX->range(), axisY->range()));
911 914 axisX->setRange(newAxisXRange);
912 915 axisY->setRange(newAxisYRange);
913 916
914 917 plot().replot(QCustomPlot::rpQueuedReplot);
915 918 }
916 919 }
917 920
918 921 impl->endDrawingZone(this);
919 922
920 impl->m_IsCalibration = false;
921
922 923 // Selection / Deselection
923 924 auto isSelectionZoneMode
924 925 = sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones;
925 926 if (isSelectionZoneMode) {
926 927 auto isMultiSelectionClick = event->modifiers().testFlag(MULTI_ZONE_SELECTION_MODIFIER);
927 928 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos(), plot());
928 929 if (selectionZoneItemUnderCursor && event->button() == Qt::LeftButton
929 930 && !impl->m_HasMovedMouse) {
930 931
931 932 auto zonesUnderCursor = impl->selectionZonesAt(event->pos(), plot());
932 933 if (zonesUnderCursor.count() > 1) {
933 934 // There are multiple zones under the mouse.
934 935 // Performs the selection with a selection dialog.
935 936 VisualizationMultiZoneSelectionDialog dialog{this};
936 937 dialog.setZones(zonesUnderCursor);
937 938 dialog.move(mapToGlobal(event->pos() - QPoint(dialog.width() / 2, 20)));
938 939 dialog.activateWindow();
939 940 dialog.raise();
940 941 if (dialog.exec() == QDialog::Accepted) {
941 942 auto selection = dialog.selectedZones();
942 943
943 944 if (!isMultiSelectionClick) {
944 945 parentVisualizationWidget()->selectionZoneManager().clearSelection();
945 946 }
946 947
947 948 for (auto it = selection.cbegin(); it != selection.cend(); ++it) {
948 949 auto zone = it.key();
949 950 auto isSelected = it.value();
950 951 parentVisualizationWidget()->selectionZoneManager().setSelected(zone,
951 952 isSelected);
952 953
953 954 if (isSelected) {
954 955 // Puts the zone on top of the stack so it can be moved or resized
955 956 impl->moveSelectionZoneOnTop(zone, plot());
956 957 }
957 958 }
958 959 }
959 960 }
960 961 else {
961 962 if (!isMultiSelectionClick) {
962 963 parentVisualizationWidget()->selectionZoneManager().select(
963 964 {selectionZoneItemUnderCursor});
964 965 impl->moveSelectionZoneOnTop(selectionZoneItemUnderCursor, plot());
965 966 }
966 967 else {
967 968 parentVisualizationWidget()->selectionZoneManager().setSelected(
968 969 selectionZoneItemUnderCursor, !selectionZoneItemUnderCursor->selected()
969 970 || event->button() == Qt::RightButton);
970 971 }
971 972 }
972 973 }
973 974 else {
974 975 // No selection change
975 976 }
976 977 }
977 978 }
978 979
979 980 void VisualizationGraphWidget::onDataCacheVariableUpdated()
980 981 {
981 982 auto graphRange = ui->widget->xAxis->range();
982 983 auto dateTime = SqpRange{graphRange.lower, graphRange.upper};
983 984
984 985 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
985 986 auto variable = variableEntry.first;
986 987 qCDebug(LOG_VisualizationGraphWidget())
987 988 << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
988 989 qCDebug(LOG_VisualizationGraphWidget())
989 990 << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
990 991 if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
991 992 impl->updateData(variableEntry.second, variable->dataSeries(), variable->range());
992 993 }
993 994 }
994 995 }
995 996
996 997 void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,
997 998 const SqpRange &range)
998 999 {
999 1000 auto it = impl->m_VariableToPlotMultiMap.find(variable);
1000 1001 if (it != impl->m_VariableToPlotMultiMap.end()) {
1001 1002 impl->updateData(it->second, variable->dataSeries(), range);
1002 1003 }
1003 1004 }
Show file before | Show file after | Hide comments
@@ -1,71 +1,73
1 1 #include "Visualization/operations/RescaleAxeOperation.h"
2 2 #include "Visualization/VisualizationGraphWidget.h"
3 3
4 4 Q_LOGGING_CATEGORY(LOG_RescaleAxeOperation, "RescaleAxeOperation")
5 5
6 6 struct RescaleAxeOperation::RescaleAxeOperationPrivate {
7 7 explicit RescaleAxeOperationPrivate(std::shared_ptr<Variable> variable, const SqpRange &range)
8 8 : m_Variable{variable}, m_Range{range}
9 9 {
10 10 }
11 11
12 12 std::shared_ptr<Variable> m_Variable;
13 13 SqpRange m_Range;
14 14 };
15 15
16 16 RescaleAxeOperation::RescaleAxeOperation(std::shared_ptr<Variable> variable, const SqpRange &range)
17 17 : impl{spimpl::make_unique_impl<RescaleAxeOperationPrivate>(variable, range)}
18 18 {
19 19 }
20 20
21 21 void RescaleAxeOperation::visitEnter(VisualizationWidget *widget)
22 22 {
23 23 // VisualizationWidget is not intended to contain a variable
24 24 Q_UNUSED(widget)
25 25 }
26 26
27 27 void RescaleAxeOperation::visitLeave(VisualizationWidget *widget)
28 28 {
29 29 // VisualizationWidget is not intended to contain a variable
30 30 Q_UNUSED(widget)
31 31 }
32 32
33 33 void RescaleAxeOperation::visitEnter(VisualizationTabWidget *tabWidget)
34 34 {
35 35 // VisualizationTabWidget is not intended to contain a variable
36 36 Q_UNUSED(tabWidget)
37 37 }
38 38
39 39 void RescaleAxeOperation::visitLeave(VisualizationTabWidget *tabWidget)
40 40 {
41 41 // VisualizationTabWidget is not intended to contain a variable
42 42 Q_UNUSED(tabWidget)
43 43 }
44 44
45 45 void RescaleAxeOperation::visitEnter(VisualizationZoneWidget *zoneWidget)
46 46 {
47 47 // VisualizationZoneWidget is not intended to contain a variable
48 48 Q_UNUSED(zoneWidget)
49 49 }
50 50
51 51 void RescaleAxeOperation::visitLeave(VisualizationZoneWidget *zoneWidget)
52 52 {
53 53 // VisualizationZoneWidget is not intended to contain a variable
54 54 Q_UNUSED(zoneWidget)
55 55 }
56 56
57 57 void RescaleAxeOperation::visit(VisualizationGraphWidget *graphWidget)
58 58 {
59 59 if (graphWidget) {
60 60 // If the widget contains the variable, rescale it
61 61 if (impl->m_Variable && graphWidget->contains(*impl->m_Variable)) {
62 graphWidget->setFlags(GraphFlag::DisableAll);
62 // During rescale, acquisition for the graph is disabled but synchronization is still
63 // enabled
64 graphWidget->setFlags(GraphFlag::EnableSynchronization);
63 65 graphWidget->setGraphRange(impl->m_Range);
64 66 graphWidget->setFlags(GraphFlag::EnableAll);
65 67 }
66 68 }
67 69 else {
68 70 qCCritical(LOG_RescaleAxeOperation(),
69 71 "Can't visit VisualizationGraphWidget : the widget is null");
70 72 }
71 73 }
General Comments 0
You need to be logged in to leave comments. Login now