GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1120:a02153d618e2

Selection of stacked zone via a dialog box

trabillard -

r1120:a02153d618e2

parent child

Context file:

r1120:a02153d618e2

gui/include/Visualization/VisualizationMultiZoneSelectionDialog.h created 644 +30 0

@@ -0,0 +1,30
	1	#ifndef SCIQLOP_VISUALIZATIONMULTIZONESELECTIONDIALOG_H
	2	#define SCIQLOP_VISUALIZATIONMULTIZONESELECTIONDIALOG_H
	3
	4	#include <Common/spimpl.h>
	5	#include <QDialog>
	6
	7	namespace Ui {
	8	class VisualizationMultiZoneSelectionDialog;
	9	}
	10
	11	class VisualizationSelectionZoneItem;
	12
	13	class VisualizationMultiZoneSelectionDialog : public QDialog {
	14	Q_OBJECT
	15
	16	public:
	17	explicit VisualizationMultiZoneSelectionDialog(QWidget *parent = 0);
	18	~VisualizationMultiZoneSelectionDialog();
	19
	20	void setZones(const QVector<VisualizationSelectionZoneItem *> &zones);
	21	QMap<VisualizationSelectionZoneItem *, bool> selectedZones() const;
	22
	23	private:
	24	Ui::VisualizationMultiZoneSelectionDialog *ui;
	25
	26	class VisualizationMultiZoneSelectionDialogPrivate;
	27	spimpl::unique_impl_ptr<VisualizationMultiZoneSelectionDialogPrivate> impl;
	28	};
	29
	30	#endif // SCIQLOP_VISUALIZATIONMULTIZONESELECTIONDIALOG_H

gui/src/Visualization/VisualizationMultiZoneSelectionDialog.cpp created 644 +69 0

@@ -0,0 +1,69
	1	#include "Visualization/VisualizationMultiZoneSelectionDialog.h"
	2	#include "ui_VisualizationMultiZoneSelectionDialog.h"
	3
	4	#include "Common/DateUtils.h"
	5	#include "Visualization/VisualizationSelectionZoneItem.h"
	6
	7	const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss");
	8
	9	struct VisualizationMultiZoneSelectionDialog::VisualizationMultiZoneSelectionDialogPrivate {
	10	QVector<VisualizationSelectionZoneItem *> m_Zones;
	11	};
	12
	13	VisualizationMultiZoneSelectionDialog::VisualizationMultiZoneSelectionDialog(QWidget *parent)
	14	: QDialog(parent, Qt::Tool),
	15	ui(new Ui::VisualizationMultiZoneSelectionDialog),
	16	impl{spimpl::make_unique_impl<VisualizationMultiZoneSelectionDialogPrivate>()}
	17	{
	18	ui->setupUi(this);
	19
	20	connect(ui->buttonBox, &QDialogButtonBox::accepted, this,
	21	&VisualizationMultiZoneSelectionDialog::accept);
	22	connect(ui->buttonBox, &QDialogButtonBox::rejected, this,
	23	&VisualizationMultiZoneSelectionDialog::reject);
	24	}
	25
	26	VisualizationMultiZoneSelectionDialog::~VisualizationMultiZoneSelectionDialog()
	27	{
	28	delete ui;
	29	}
	30
	31	void VisualizationMultiZoneSelectionDialog::setZones(
	32	const QVector<VisualizationSelectionZoneItem *> &zones)
	33	{
	34	impl->m_Zones = zones;
	35
	36	// Sorts the zones to display them in temporal order
	37	std::sort(impl->m_Zones.begin(), impl->m_Zones.end(), [](auto zone1, auto zone2) {
	38	return zone1->range().m_TStart < zone2->range().m_TStart;
	39	});
	40
	41	// Adds the zones in the listwidget
	42	for (auto zone : impl->m_Zones) {
	43	auto name = zone->name();
	44	if (!name.isEmpty()) {
	45	name += tr(": ");
	46	}
	47
	48	auto range = zone->range();
	49	name += DateUtils::dateTime(range.m_TStart).toString(DATETIME_FORMAT);
	50	name += " - ";
	51	name += DateUtils::dateTime(range.m_TEnd).toString(DATETIME_FORMAT);
	52
	53	auto item = new QListWidgetItem(name, ui->listWidget);
	54	item->setSelected(zone->selected());
	55	}
	56	}
	57
	58	QMap<VisualizationSelectionZoneItem *, bool>
	59	VisualizationMultiZoneSelectionDialog::selectedZones() const
	60	{
	61	QMap<VisualizationSelectionZoneItem *, bool> selectedZones;
	62
	63	for (auto i = 0; i < ui->listWidget->count(); ++i) {
	64	auto item = ui->listWidget->item(i);
	65	selectedZones[impl->m_Zones[i]] = item->isSelected();
	66	}
	67
	68	return selectedZones;
	69	}

gui/ui/Visualization/VisualizationMultiZoneSelectionDialog.ui created 644 +47 0

@@ -0,0 +1,47
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<ui version="4.0">
	3	<class>VisualizationMultiZoneSelectionDialog</class>
	4	<widget class="QDialog" name="VisualizationMultiZoneSelectionDialog">
	5	<property name="geometry">
	6	<rect>
	7	<x>0</x>
	8	<y>0</y>
	9	<width>270</width>
	10	<height>175</height>
	11	</rect>
	12	</property>
	13	<property name="windowTitle">
	14	<string>Select...</string>
	15	</property>
	16	<layout class="QVBoxLayout" name="verticalLayout">
	17	<property name="leftMargin">
	18	<number>0</number>
	19	</property>
	20	<property name="topMargin">
	21	<number>0</number>
	22	</property>
	23	<property name="rightMargin">
	24	<number>0</number>
	25	</property>
	26	<property name="bottomMargin">
	27	<number>0</number>
	28	</property>
	29	<item>
	30	<widget class="QListWidget" name="listWidget">
	31	<property name="selectionMode">
	32	<enum>QAbstractItemView::ExtendedSelection</enum>
	33	</property>
	34	</widget>
	35	</item>
	36	<item>
	37	<widget class="QDialogButtonBox" name="buttonBox">
	38	<property name="standardButtons">
	39	<set>QDialogButtonBox::Cancel\|QDialogButtonBox::Ok</set>
	40	</property>
	41	</widget>
	42	</item>
	43	</layout>
	44	</widget>
	45	<resources/>
	46	<connections/>
	47	</ui>

gui/include/Visualization/VisualizationSelectionZoneItem.h +4 0

             #ifndef SCIQLOP_VISUALIZATIONSELECTIONZONEITEM_H
             #define SCIQLOP_VISUALIZATIONSELECTIONZONEITEM_H
             #include <Common/spimpl.h>
             #include <Data/SqpRange.h>
             #include <Visualization/qcustomplot.h>
             class VisualizationGraphWidget;
             class VisualizationSelectionZoneItem : public QCPItemRect {
             public:
                 VisualizationSelectionZoneItem(QCustomPlot *plot);
                 virtual ~VisualizationSelectionZoneItem();
                 VisualizationGraphWidget *parentGraphWidget() const noexcept;
                 void setName(const QString &name);
                 QString name() const;
                 SqpRange range() const;
                 void setRange(double tstart, double tend);
                 void setStart(double tstart);
                 void setEnd(double tend);
                 void setColor(const QColor &color);
                 void setEditionEnabled(bool value);
                 bool isEditionEnabled() const;
+                /// Moves the item at the top of its QCPLayer. It will then receive the mouse events if multiple
+                /// items are stacked on top of each others.
+                void moveToTop();
                 Qt::CursorShape curshorShapeForPosition(const QPoint &position) const;
                 void setHovered(bool value);
                 /// Sets the zones which should be moved or reisized together with this zone
                 void setAssociatedEditedZones(const QVector<VisualizationSelectionZoneItem *> &associatedZones);
                 /// Align the specified zones with this one, vertically with the left border
                 bool alignZonesVerticallyOnLeft(const QVector<VisualizationSelectionZoneItem *> &zonesToAlign,
                                                 bool allowResize);
                 /// Align the specified zones with this one, vertically with the right border
                 bool alignZonesVerticallyOnRight(const QVector<VisualizationSelectionZoneItem *> &zonesToAlign,
                                                  bool allowResize);
                 /// Align the specified zones with this one, temporally with the left border
                 bool alignZonesTemporallyOnLeft(const QVector<VisualizationSelectionZoneItem *> &zonesToAlign,
                                                 bool allowResize);
                 /// Align the specified zones with this one, temporally with the right border
                 bool alignZonesTemporallyOnRight(const QVector<VisualizationSelectionZoneItem *> &zonesToAlign,
                                                  bool allowResize);
             protected:
                 void mousePressEvent(QMouseEvent *event, const QVariant &details) override;
                 void mouseMoveEvent(QMouseEvent *event, const QPointF &startPos) override;
                 void mouseReleaseEvent(QMouseEvent *event, const QPointF &startPos) override;
                 void resizeLeft(double pixelDiff);
                 void resizeRight(double pixelDiff);
                 void move(double pixelDiff);
             private:
                 class VisualizationSelectionZoneItemPrivate;
                 spimpl::unique_impl_ptr<VisualizationSelectionZoneItemPrivate> impl;
             };
             #endif // SCIQLOP_VISUALIZATIONSELECTIONZONEITEM_H

gui/meson.build +6 -3

             gui_moc_headers = [
               'include/DataSource/DataSourceWidget.h',
               'include/Settings/SqpSettingsDialog.h',
               'include/Settings/SqpSettingsGeneralWidget.h',
               'include/SidePane/SqpSidePane.h',
               'include/SqpApplication.h',
               'include/DragAndDrop/DragDropScroller.h',
               'include/DragAndDrop/DragDropTabSwitcher.h',
               'include/TimeWidget/TimeWidget.h',
               'include/Variable/VariableInspectorWidget.h',
               'include/Variable/RenameVariableDialog.h',
               'include/Visualization/qcustomplot.h',
               'include/Visualization/VisualizationGraphWidget.h',
               'include/Visualization/VisualizationTabWidget.h',
               'include/Visualization/VisualizationWidget.h',
               'include/Visualization/VisualizationZoneWidget.h',
               'include/Visualization/VisualizationDragDropContainer.h',
               'include/Visualization/VisualizationDragWidget.h',
               'include/Visualization/ColorScaleEditor.h',
-              'include/Visualization/SelectionZoneAction.h'
+              'include/Visualization/SelectionZoneAction.h',
+              'include/Visualization/VisualizationMultiZoneSelectionDialog.h'
             ]
             gui_ui_files = [
               'ui/DataSource/DataSourceWidget.ui',
               'ui/Settings/SqpSettingsDialog.ui',
               'ui/Settings/SqpSettingsGeneralWidget.ui',
               'ui/SidePane/SqpSidePane.ui',
               'ui/TimeWidget/TimeWidget.ui',
               'ui/Variable/VariableInspectorWidget.ui',
               'ui/Variable/RenameVariableDialog.ui',
               'ui/Variable/VariableMenuHeaderWidget.ui',
               'ui/Visualization/VisualizationGraphWidget.ui',
               'ui/Visualization/VisualizationTabWidget.ui',
               'ui/Visualization/VisualizationWidget.ui',
               'ui/Visualization/VisualizationZoneWidget.ui',
-              'ui/Visualization/ColorScaleEditor.ui'
+              'ui/Visualization/ColorScaleEditor.ui',
+              'ui/Visualization/VisualizationMultiZoneSelectionDialog.ui'
             ]
             gui_qresources = ['resources/sqpguiresources.qrc']
             gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers,
                                            ui_files : gui_ui_files,
                                            qresources : gui_qresources)
             gui_sources = [
               'src/SqpApplication.cpp',
               'src/DragAndDrop/DragDropHelper.cpp',
               'src/DragAndDrop/DragDropScroller.cpp',
               'src/DragAndDrop/DragDropTabSwitcher.cpp',
               'src/Common/ColorUtils.cpp',
               'src/Common/VisualizationDef.cpp',
               'src/DataSource/DataSourceTreeWidgetItem.cpp',
               'src/DataSource/DataSourceTreeWidgetHelper.cpp',
               'src/DataSource/DataSourceWidget.cpp',
               'src/DataSource/DataSourceTreeWidget.cpp',
               'src/Settings/SqpSettingsDialog.cpp',
               'src/Settings/SqpSettingsGeneralWidget.cpp',
               'src/SidePane/SqpSidePane.cpp',
               'src/TimeWidget/TimeWidget.cpp',
               'src/Variable/VariableInspectorWidget.cpp',
               'src/Variable/VariableInspectorTableView.cpp',
               'src/Variable/VariableMenuHeaderWidget.cpp',
               'src/Variable/RenameVariableDialog.cpp',
               'src/Visualization/VisualizationGraphHelper.cpp',
               'src/Visualization/VisualizationGraphRenderingDelegate.cpp',
               'src/Visualization/VisualizationGraphWidget.cpp',
               'src/Visualization/VisualizationTabWidget.cpp',
               'src/Visualization/VisualizationWidget.cpp',
               'src/Visualization/VisualizationZoneWidget.cpp',
               'src/Visualization/qcustomplot.cpp',
               'src/Visualization/QCustomPlotSynchronizer.cpp',
               'src/Visualization/operations/FindVariableOperation.cpp',
               'src/Visualization/operations/GenerateVariableMenuOperation.cpp',
               'src/Visualization/operations/MenuBuilder.cpp',
               'src/Visualization/operations/RemoveVariableOperation.cpp',
               'src/Visualization/operations/RescaleAxeOperation.cpp',
               'src/Visualization/VisualizationDragDropContainer.cpp',
               'src/Visualization/VisualizationDragWidget.cpp',
               'src/Visualization/AxisRenderingUtils.cpp',
               'src/Visualization/PlottablesRenderingUtils.cpp',
               'src/Visualization/MacScrollBarStyle.cpp',
               'src/Visualization/VisualizationCursorItem.cpp',
               'src/Visualization/ColorScaleEditor.cpp',
               'src/Visualization/SqpColorScale.cpp',
               'src/Visualization/QCPColorMapIterator.cpp',
               'src/Visualization/VisualizationSelectionZoneItem.cpp',
               'src/Visualization/VisualizationSelectionZoneManager.cpp',
               'src/Visualization/SelectionZoneAction.cpp',
               'src/Visualization/ActionsGuiController.cpp',
-              'src/Visualization/VisualizationActionManager.cpp'
+              'src/Visualization/VisualizationActionManager.cpp',
+              'src/Visualization/VisualizationMultiZoneSelectionDialog.cpp'
             ]
             gui_inc = include_directories(['include'])
             sciqlop_gui_lib = library('sciqlopgui',
                                    gui_sources,
                                    gui_moc_files,
                                    include_directories : [gui_inc],
                                    dependencies : [ qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core],
                                    install : true
                                    )
             sciqlop_gui = declare_dependency(link_with : sciqlop_gui_lib,
                                             include_directories : gui_inc,
                                             dependencies : [qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core])

gui/src/Visualization/VisualizationGraphWidget.cpp +66 -8

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationCursorItem.h"
             #include "Visualization/VisualizationDefs.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/VisualizationGraphRenderingDelegate.h"
+            #include "Visualization/VisualizationMultiZoneSelectionDialog.h"
             #include "Visualization/VisualizationSelectionZoneItem.h"
             #include "Visualization/VisualizationSelectionZoneManager.h"
             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Actions/ActionsGuiController.h>
             #include <Common/MimeTypesDef.h>
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <DragAndDrop/DragDropGuiController.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
             namespace {
             /// Key pressed to enable drag&drop in all modes
             const auto DRAG_DROP_MODIFIER = Qt::AltModifier;
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::ControlModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ShiftModifier;
             /// Speed of a step of a wheel event for a pan, in percentage of the axis range
             const auto PAN_SPEED = 5;
             /// Key pressed to enable a calibration pan
             const auto VERTICAL_PAN_MODIFIER = Qt::AltModifier;
             /// Key pressed to enable multi selection of selection zones
             const auto MULTI_ZONE_SELECTION_MODIFIER = Qt::ControlModifier;
             /// Minimum size for the zoom box, in percentage of the axis range
             const auto ZOOM_BOX_MIN_SIZE = 0.8;
             /// Format of the dates appearing in the label of a cursor
             const auto CURSOR_LABELS_DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd\nhh:mm:ss:zzz");
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                 explicit VisualizationGraphWidgetPrivate(const QString &name)
                         : m_Name{name},
                           m_DoAcquisition{true},
                           m_IsCalibration{false},
                           m_RenderingDelegate{nullptr}
                 {
                 }
                 void updateData(PlottablesMap &plottables, std::shared_ptr<IDataSeries> dataSeries,
                                 const SqpRange &range)
                 {
                     VisualizationGraphHelper::updateData(plottables, dataSeries, range);
                     // Prevents that data has changed to update rendering
                     m_RenderingDelegate->onPlotUpdated();
                 }
                 QString m_Name;
                 // 1 variable -> n qcpplot
                 std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
                 bool m_DoAcquisition;
                 bool m_IsCalibration;
                 /// Delegate used to attach rendering features to the plot
                 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
                 QCPItemRect *m_DrawingZoomRect = nullptr;
                 QStack<QPair<QCPRange, QCPRange> > m_ZoomStack;
                 std::unique_ptr<VisualizationCursorItem> m_HorizontalCursor = nullptr;
                 std::unique_ptr<VisualizationCursorItem> m_VerticalCursor = nullptr;
                 VisualizationSelectionZoneItem *m_DrawingZone = nullptr;
                 VisualizationSelectionZoneItem *m_HoveredZone = nullptr;
                 QVector<VisualizationSelectionZoneItem *> m_SelectionZones;
                 bool m_HasMovedMouse = false; // Indicates if the mouse moved in a releaseMouse even
                 void startDrawingRect(const QPoint &pos, QCustomPlot &plot)
                 {
                     removeDrawingRect(plot);
                     auto axisPos = posToAxisPos(pos, plot);
                     m_DrawingZoomRect = new QCPItemRect{&plot};
                     QPen p;
                     p.setWidth(2);
                     m_DrawingZoomRect->setPen(p);
                     m_DrawingZoomRect->topLeft->setCoords(axisPos);
                     m_DrawingZoomRect->bottomRight->setCoords(axisPos);
                 }
                 void removeDrawingRect(QCustomPlot &plot)
                 {
                     if (m_DrawingZoomRect) {
                         plot.removeItem(m_DrawingZoomRect); // the item is deleted by QCustomPlot
                         m_DrawingZoomRect = nullptr;
                         plot.replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 void startDrawingZone(const QPoint &pos, VisualizationGraphWidget *graph)
                 {
                     endDrawingZone(graph);
                     auto axisPos = posToAxisPos(pos, graph->plot());
                     m_DrawingZone = new VisualizationSelectionZoneItem{&graph->plot()};
                     m_DrawingZone->setRange(axisPos.x(), axisPos.x());
                     m_DrawingZone->setEditionEnabled(false);
                 }
                 void endDrawingZone(VisualizationGraphWidget *graph)
                 {
                     if (m_DrawingZone) {
                         auto drawingZoneRange = m_DrawingZone->range();
                         if (qAbs(drawingZoneRange.m_TEnd - drawingZoneRange.m_TStart) > 0) {
                             m_DrawingZone->setEditionEnabled(true);
                             addSelectionZone(m_DrawingZone);
                         }
                         else {
                             graph->plot().removeItem(m_DrawingZone); // the item is deleted by QCustomPlot
                         }
                         graph->plot().replot(QCustomPlot::rpQueuedReplot);
                         m_DrawingZone = nullptr;
                     }
                 }
                 void setSelectionZonesEditionEnabled(bool value)
                 {
                     for (auto s : m_SelectionZones) {
                         s->setEditionEnabled(value);
                     }
                 }
                 void addSelectionZone(VisualizationSelectionZoneItem *zone) { m_SelectionZones << zone; }
                 VisualizationSelectionZoneItem *selectionZoneAt(const QPoint &pos,
                                                                 const QCustomPlot &plot) const
                 {
                     VisualizationSelectionZoneItem *selectionZoneItemUnderCursor = nullptr;
                     auto minDistanceToZone = -1;
                     for (auto zone : m_SelectionZones) {
                         auto distanceToZone = zone->selectTest(pos, false);
                         if ((minDistanceToZone < 0 || distanceToZone <= minDistanceToZone)
                             && distanceToZone >= 0 && distanceToZone < plot.selectionTolerance()) {
                             selectionZoneItemUnderCursor = zone;
                         }
                     }
                     return selectionZoneItemUnderCursor;
                 }
+                QVector<VisualizationSelectionZoneItem *> selectionZonesAt(const QPoint &pos,
+                                                                           const QCustomPlot &plot) const
+                {
+                    QVector<VisualizationSelectionZoneItem *> zones;
+                    for (auto zone : m_SelectionZones) {
+                        auto distanceToZone = zone->selectTest(pos, false);
+                        if (distanceToZone >= 0 && distanceToZone < plot.selectionTolerance()) {
+                            zones << zone;
+                        }
+                    }
+                    return zones;
+                }
+                void moveSelectionZoneOnTop(VisualizationSelectionZoneItem *zone, QCustomPlot &plot)
+                {
+                    if (!m_SelectionZones.isEmpty() && m_SelectionZones.last() != zone) {
+                        zone->moveToTop();
+                        m_SelectionZones.removeAll(zone);
+                        m_SelectionZones.append(zone);
+                    }
+                }
                 QPointF posToAxisPos(const QPoint &pos, QCustomPlot &plot) const
                 {
                     auto axisX = plot.axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = plot.axisRect()->axis(QCPAxis::atLeft);
                     return QPointF{axisX->pixelToCoord(pos.x()), axisY->pixelToCoord(pos.y())};
                 }
                 bool pointIsInAxisRect(const QPointF &axisPoint, QCustomPlot &plot) const
                 {
                     auto axisX = plot.axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = plot.axisRect()->axis(QCPAxis::atLeft);
                     return axisX->range().contains(axisPoint.x()) && axisY->range().contains(axisPoint.y());
                 }
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 // Set qcpplot properties :
                 // - zoom is enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                 ui->widget->setInteractions(QCP::iRangeZoom);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal | Qt::Vertical);
                 // The delegate must be initialized after the ui as it uses the plot
                 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*this);
                 // Init the cursors
                 impl->m_HorizontalCursor = std::make_unique<VisualizationCursorItem>(&plot());
                 impl->m_HorizontalCursor->setOrientation(Qt::Horizontal);
                 impl->m_VerticalCursor = std::make_unique<VisualizationCursorItem>(&plot());
                 impl->m_VerticalCursor->setOrientation(Qt::Vertical);
                 connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
                 connect(ui->widget, &QCustomPlot::mouseRelease, this,
                         &VisualizationGraphWidget::onMouseRelease);
                 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
                 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
                 connect(ui->widget, &QCustomPlot::mouseDoubleClick, this,
                         &VisualizationGraphWidget::onMouseDoubleClick);
                 connect(
                     ui->widget->xAxis,
                     static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(&QCPAxis::rangeChanged),
                     this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
                 // Activates menu when right clicking on the graph
                 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
                         &VisualizationGraphWidget::onGraphMenuRequested);
                 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
                         &VariableController::onRequestDataLoading);
                 connect(&sqpApp->variableController(), &VariableController::updateVarDisplaying, this,
                         &VisualizationGraphWidget::onUpdateVarDisplaying);
             #ifdef Q_OS_MAC
                 plot().setPlottingHint(QCP::phFastPolylines, true);
             #endif
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
             VisualizationZoneWidget *VisualizationGraphWidget::parentZoneWidget() const noexcept
             {
                 auto parent = parentWidget();
                 while (parent != nullptr && !qobject_cast<VisualizationZoneWidget *>(parent)) {
                     parent = parent->parentWidget();
                 }
                 return qobject_cast<VisualizationZoneWidget *>(parent);
             }
             VisualizationWidget *VisualizationGraphWidget::parentVisualizationWidget() const
             {
                 auto parent = parentWidget();
                 while (parent != nullptr && !qobject_cast<VisualizationWidget *>(parent)) {
                     parent = parent->parentWidget();
                 }
                 return qobject_cast<VisualizationWidget *>(parent);
             }
             void VisualizationGraphWidget::enableAcquisition(bool enable)
             {
                 impl->m_DoAcquisition = enable;
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
                 if (auto dataSeries = variable->dataSeries()) {
                     // Set axes properties according to the units of the data series
                     impl->m_RenderingDelegate->setAxesProperties(dataSeries);
                     // Sets rendering properties for the new plottables
                     // Warning: this method must be called after setAxesProperties(), as it can access to some
                     // axes properties that have to be initialized
                     impl->m_RenderingDelegate->setPlottablesProperties(dataSeries, createdPlottables);
                 }
                 impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
                 this->enableAcquisition(false);
                 this->setGraphRange(range);
                 this->enableAcquisition(true);
                 emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable, range, false);
                 emit variableAdded(variable);
             }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 // Each component associated to the variable :
                 // - is removed from qcpplot (which deletes it)
                 // - is no longer referenced in the map
                 auto variableIt = impl->m_VariableToPlotMultiMap.find(variable);
                 if (variableIt != impl->m_VariableToPlotMultiMap.cend()) {
                     emit variableAboutToBeRemoved(variable);
                     auto &plottablesMap = variableIt->second;
                     for (auto plottableIt = plottablesMap.cbegin(), plottableEnd = plottablesMap.cend();
                          plottableIt != plottableEnd;) {
                         ui->widget->removePlottable(plottableIt->second);
                         plottableIt = plottablesMap.erase(plottableIt);
                     }
                     impl->m_VariableToPlotMultiMap.erase(variableIt);
                 }
                 // Updates graph
                 ui->widget->replot();
             }
             QList<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
             {
                 auto variables = QList<std::shared_ptr<Variable> >{};
                 for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap);
                      it != std::cend(impl->m_VariableToPlotMultiMap); ++it) {
                     variables << it->first;
                 }
                 return variables;
             }
             void VisualizationGraphWidget::setYRange(std::shared_ptr<Variable> variable)
             {
                 if (!variable) {
                     qCCritical(LOG_VisualizationGraphWidget()) << "Can't set y-axis range: variable is null";
                     return;
                 }
                 VisualizationGraphHelper::setYAxisRange(variable, *ui->widget);
             }
             SqpRange VisualizationGraphWidget::graphRange() const noexcept
             {
                 auto graphRange = ui->widget->xAxis->range();
                 return SqpRange{graphRange.lower, graphRange.upper};
             }
             void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
                 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                 ui->widget->replot();
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
             }
             QVector<SqpRange> VisualizationGraphWidget::selectionZoneRanges() const
             {
                 QVector<SqpRange> ranges;
                 for (auto zone : impl->m_SelectionZones) {
                     ranges << zone->range();
                 }
                 return ranges;
             }
             void VisualizationGraphWidget::addSelectionZones(const QVector<SqpRange> &ranges)
             {
                 for (const auto &range : ranges) {
                     // note: ownership is transfered to QCustomPlot
                     auto zone = new VisualizationSelectionZoneItem(&plot());
                     zone->setRange(range.m_TStart, range.m_TEnd);
                     impl->addSelectionZone(zone);
                 }
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::removeSelectionZone(VisualizationSelectionZoneItem *selectionZone)
             {
                 parentVisualizationWidget()->selectionZoneManager().setSelected(selectionZone, false);
                 if (impl->m_HoveredZone == selectionZone) {
                     impl->m_HoveredZone = nullptr;
                     setCursor(Qt::ArrowCursor);
                 }
                 impl->m_SelectionZones.removeAll(selectionZone);
                 plot().removeItem(selectionZone);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::undoZoom()
             {
                 auto zoom = impl->m_ZoomStack.pop();
                 auto axisX = plot().axisRect()->axis(QCPAxis::atBottom);
                 auto axisY = plot().axisRect()->axis(QCPAxis::atLeft);
                 axisX->setRange(zoom.first);
                 axisY->setRange(zoom.second);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visit(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationGraphWidget())
                         << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationGraphWidget::canDrop(const Variable &variable) const
             {
                 auto isSpectrogram = [](const auto &variable) {
                     return std::dynamic_pointer_cast<SpectrogramSeries>(variable.dataSeries()) != nullptr;
                 };
                 // - A spectrogram series can't be dropped on graph with existing plottables
                 // - No data series can be dropped on graph with existing spectrogram series
                 return isSpectrogram(variable)
                            ? impl->m_VariableToPlotMultiMap.empty()
                            : std::none_of(
                                  impl->m_VariableToPlotMultiMap.cbegin(), impl->m_VariableToPlotMultiMap.cend(),
                                  [isSpectrogram](const auto &entry) { return isSpectrogram(*entry.first); });
             }
             bool VisualizationGraphWidget::contains(const Variable &variable) const
             {
                 // Finds the variable among the keys of the map
                 auto variablePtr = &variable;
                 auto findVariable
                     = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
                 auto end = impl->m_VariableToPlotMultiMap.cend();
                 auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
                 return it != end;
             }
             QString VisualizationGraphWidget::name() const
             {
                 return impl->m_Name;
             }
             QMimeData *VisualizationGraphWidget::mimeData(const QPoint &position) const
             {
                 auto mimeData = new QMimeData;
                 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(position, plot());
                 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
                     && selectionZoneItemUnderCursor) {
                     mimeData->setData(MIME_TYPE_TIME_RANGE, TimeController::mimeDataForTimeRange(
                                                                 selectionZoneItemUnderCursor->range()));
                     mimeData->setData(MIME_TYPE_SELECTION_ZONE, TimeController::mimeDataForTimeRange(
                                                                     selectionZoneItemUnderCursor->range()));
                 }
                 else {
                     mimeData->setData(MIME_TYPE_GRAPH, QByteArray{});
                     auto timeRangeData = TimeController::mimeDataForTimeRange(graphRange());
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
                 }
                 return mimeData;
             }
             QPixmap VisualizationGraphWidget::customDragPixmap(const QPoint &dragPosition)
             {
                 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(dragPosition, plot());
                 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
                     && selectionZoneItemUnderCursor) {
                     auto zoneTopLeft = selectionZoneItemUnderCursor->topLeft->pixelPosition();
                     auto zoneBottomRight = selectionZoneItemUnderCursor->bottomRight->pixelPosition();
                     auto zoneSize = QSizeF{qAbs(zoneBottomRight.x() - zoneTopLeft.x()),
                                            qAbs(zoneBottomRight.y() - zoneTopLeft.y())}
                                         .toSize();
                     auto pixmap = QPixmap(zoneSize);
                     render(&pixmap, QPoint(), QRegion{QRect{zoneTopLeft.toPoint(), zoneSize}});
                     return pixmap;
                 }
                 return QPixmap();
             }
             bool VisualizationGraphWidget::isDragAllowed() const
             {
                 return true;
             }
             void VisualizationGraphWidget::highlightForMerge(bool highlighted)
             {
                 if (highlighted) {
                     plot().setBackground(QBrush(QColor("#BBD5EE")));
                 }
                 else {
                     plot().setBackground(QBrush(Qt::white));
                 }
                 plot().update();
             }
             void VisualizationGraphWidget::addVerticalCursor(double time)
             {
                 impl->m_VerticalCursor->setPosition(time);
                 impl->m_VerticalCursor->setVisible(true);
                 auto text
                     = DateUtils::dateTime(time).toString(CURSOR_LABELS_DATETIME_FORMAT).replace(' ', '\n');
                 impl->m_VerticalCursor->setLabelText(text);
             }
             void VisualizationGraphWidget::addVerticalCursorAtViewportPosition(double position)
             {
                 impl->m_VerticalCursor->setAbsolutePosition(position);
                 impl->m_VerticalCursor->setVisible(true);
                 auto axis = plot().axisRect()->axis(QCPAxis::atBottom);
                 auto text
                     = DateUtils::dateTime(axis->pixelToCoord(position)).toString(CURSOR_LABELS_DATETIME_FORMAT);
                 impl->m_VerticalCursor->setLabelText(text);
             }
             void VisualizationGraphWidget::removeVerticalCursor()
             {
                 impl->m_VerticalCursor->setVisible(false);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::addHorizontalCursor(double value)
             {
                 impl->m_HorizontalCursor->setPosition(value);
                 impl->m_HorizontalCursor->setVisible(true);
                 impl->m_HorizontalCursor->setLabelText(QString::number(value));
             }
             void VisualizationGraphWidget::addHorizontalCursorAtViewportPosition(double position)
             {
                 impl->m_HorizontalCursor->setAbsolutePosition(position);
                 impl->m_HorizontalCursor->setVisible(true);
                 auto axis = plot().axisRect()->axis(QCPAxis::atLeft);
                 impl->m_HorizontalCursor->setLabelText(QString::number(axis->pixelToCoord(position)));
             }
             void VisualizationGraphWidget::removeHorizontalCursor()
             {
                 impl->m_HorizontalCursor->setVisible(false);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::closeEvent(QCloseEvent *event)
             {
                 Q_UNUSED(event);
                 // Prevents that all variables will be removed from graph when it will be closed
                 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
                     emit variableAboutToBeRemoved(variableEntry.first);
                 }
             }
             void VisualizationGraphWidget::enterEvent(QEvent *event)
             {
                 Q_UNUSED(event);
                 impl->m_RenderingDelegate->showGraphOverlay(true);
             }
             void VisualizationGraphWidget::leaveEvent(QEvent *event)
             {
                 Q_UNUSED(event);
                 impl->m_RenderingDelegate->showGraphOverlay(false);
                 if (auto parentZone = parentZoneWidget()) {
                     parentZone->notifyMouseLeaveGraph(this);
                 }
                 else {
                     qCWarning(LOG_VisualizationGraphWidget()) << "leaveEvent: No parent zone widget";
                 }
                 if (impl->m_HoveredZone) {
                     impl->m_HoveredZone->setHovered(false);
                     impl->m_HoveredZone = nullptr;
                 }
             }
             QCustomPlot &VisualizationGraphWidget::plot() const noexcept
             {
                 return *ui->widget;
             }
             void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
             {
                 QMenu graphMenu{};
                 // Iterates on variables (unique keys)
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
                           end = impl->m_VariableToPlotMultiMap.cend();
                      it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                     // 'Remove variable' action
                     graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
                                         [ this, var = it->first ]() { removeVariable(var); });
                 }
                 if (!impl->m_ZoomStack.isEmpty()) {
                     if (!graphMenu.isEmpty()) {
                         graphMenu.addSeparator();
                     }
                     graphMenu.addAction(tr("Undo Zoom"), [this]() { undoZoom(); });
                 }
                 // Selection Zone Actions
                 auto selectionZoneItem = impl->selectionZoneAt(pos, plot());
                 if (selectionZoneItem) {
                     auto selectedItems = parentVisualizationWidget()->selectionZoneManager().selectedItems();
                     selectedItems.removeAll(selectionZoneItem);
                     selectedItems.prepend(selectionZoneItem); // Put the current selection zone first
                     auto zoneActions = sqpApp->actionsGuiController().selectionZoneActions();
                     if (!zoneActions.isEmpty() && !graphMenu.isEmpty()) {
                         graphMenu.addSeparator();
                     }
                     QHash<QString, QMenu *> subMenus;
                     QHash<QString, bool> subMenusEnabled;
                     for (auto zoneAction : zoneActions) {
                         auto isEnabled = zoneAction->isEnabled(selectedItems);
                         auto menu = &graphMenu;
                         for (auto subMenuName : zoneAction->subMenuList()) {
                             if (!subMenus.contains(subMenuName)) {
                                 menu = menu->addMenu(subMenuName);
                                 subMenus[subMenuName] = menu;
                                 subMenusEnabled[subMenuName] = isEnabled;
                             }
                             else {
                                 menu = subMenus.value(subMenuName);
                                 if (isEnabled) {
                                     // The sub menu is enabled if at least one of its actions is enabled
                                     subMenusEnabled[subMenuName] = true;
                                 }
                             }
                         }
                         auto action = menu->addAction(zoneAction->name());
                         action->setEnabled(isEnabled);
                         action->setShortcut(zoneAction->displayedShortcut());
                         QObject::connect(action, &QAction::triggered,
                                          [zoneAction, selectedItems]() { zoneAction->execute(selectedItems); });
                     }
                     for (auto it = subMenus.cbegin(); it != subMenus.cend(); ++it) {
                         it.value()->setEnabled(subMenusEnabled[it.key()]);
                     }
                 }
                 if (!graphMenu.isEmpty()) {
                     graphMenu.exec(QCursor::pos());
                 }
             }
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
             {
                 qCDebug(LOG_VisualizationGraphWidget())
                     << tr("TORM: VisualizationGraphWidget::onRangeChanged")
                     << QThread::currentThread()->objectName() << "DoAcqui" << impl->m_DoAcquisition;
                 auto graphRange = SqpRange{t1.lower, t1.upper};
                 auto oldGraphRange = SqpRange{t2.lower, t2.upper};
                 if (impl->m_DoAcquisition) {
                     QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
                     for (auto it = impl->m_VariableToPlotMultiMap.begin(),
                               end = impl->m_VariableToPlotMultiMap.end();
                          it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                         variableUnderGraphVector.push_back(it->first);
                     }
                     emit requestDataLoading(std::move(variableUnderGraphVector), graphRange,
                                             !impl->m_IsCalibration);
                     if (!impl->m_IsCalibration) {
                         qCDebug(LOG_VisualizationGraphWidget())
                             << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
                             << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
                         emit synchronize(graphRange, oldGraphRange);
                     }
                 }
                 auto pos = mapFromGlobal(QCursor::pos());
                 auto axisPos = impl->posToAxisPos(pos, plot());
                 if (auto parentZone = parentZoneWidget()) {
                     if (impl->pointIsInAxisRect(axisPos, plot())) {
                         parentZone->notifyMouseMoveInGraph(pos, axisPos, this);
                     }
                     else {
                         parentZone->notifyMouseLeaveGraph(this);
                     }
                 }
                 else {
                     qCWarning(LOG_VisualizationGraphWidget()) << "onMouseMove: No parent zone widget";
                 }
             }
             void VisualizationGraphWidget::onMouseDoubleClick(QMouseEvent *event) noexcept
             {
                 impl->m_RenderingDelegate->onMouseDoubleClick(event);
             }
             void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
             {
                 // Handles plot rendering when mouse is moving
                 impl->m_RenderingDelegate->onMouseMove(event);
                 auto axisPos = impl->posToAxisPos(event->pos(), plot());
                 // Zoom box and zone drawing
                 if (impl->m_DrawingZoomRect) {
                     impl->m_DrawingZoomRect->bottomRight->setCoords(axisPos);
                 }
                 else if (impl->m_DrawingZone) {
                     impl->m_DrawingZone->setEnd(axisPos.x());
                 }
                 // Cursor
                 if (auto parentZone = parentZoneWidget()) {
                     if (impl->pointIsInAxisRect(axisPos, plot())) {
                         parentZone->notifyMouseMoveInGraph(event->pos(), axisPos, this);
                     }
                     else {
                         parentZone->notifyMouseLeaveGraph(this);
                     }
                 }
                 else {
                     qCWarning(LOG_VisualizationGraphWidget()) << "onMouseMove: No parent zone widget";
                 }
                 // Search for the selection zone under the mouse
                 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos(), plot());
                 if (selectionZoneItemUnderCursor && !impl->m_DrawingZone
                     && sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones) {
                     // Sets the appropriate cursor shape
                     auto cursorShape = selectionZoneItemUnderCursor->curshorShapeForPosition(event->pos());
                     setCursor(cursorShape);
                     // Manages the hovered zone
                     if (selectionZoneItemUnderCursor != impl->m_HoveredZone) {
                         if (impl->m_HoveredZone) {
                             impl->m_HoveredZone->setHovered(false);
                         }
                         selectionZoneItemUnderCursor->setHovered(true);
                         impl->m_HoveredZone = selectionZoneItemUnderCursor;
                         plot().replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 else {
                     // There is no zone under the mouse or the interaction mode is not "selection zones"
                     if (impl->m_HoveredZone) {
                         impl->m_HoveredZone->setHovered(false);
                         impl->m_HoveredZone = nullptr;
                     }
                     setCursor(Qt::ArrowCursor);
                 }
                 impl->m_HasMovedMouse = true;
                 VisualizationDragWidget::mouseMoveEvent(event);
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto value = event->angleDelta().x() + event->angleDelta().y();
                 if (value != 0) {
                     auto direction = value > 0 ? 1.0 : -1.0;
                     auto isZoomX = event->modifiers().testFlag(HORIZONTAL_ZOOM_MODIFIER);
                     auto isZoomY = event->modifiers().testFlag(VERTICAL_ZOOM_MODIFIER);
                     impl->m_IsCalibration = event->modifiers().testFlag(VERTICAL_PAN_MODIFIER);
                     auto zoomOrientations = QFlags<Qt::Orientation>{};
                     zoomOrientations.setFlag(Qt::Horizontal, isZoomX);
                     zoomOrientations.setFlag(Qt::Vertical, isZoomY);
                     ui->widget->axisRect()->setRangeZoom(zoomOrientations);
                     if (!isZoomX && !isZoomY) {
                         auto axis = plot().axisRect()->axis(QCPAxis::atBottom);
                         auto diff = direction * (axis->range().size() * (PAN_SPEED / 100.0));
                         axis->setRange(axis->range() + diff);
                         if (plot().noAntialiasingOnDrag()) {
                             plot().setNotAntialiasedElements(QCP::aeAll);
                         }
                         plot().replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
             }
             void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
             {
                 auto isDragDropClick = event->modifiers().testFlag(DRAG_DROP_MODIFIER);
                 auto isSelectionZoneMode
                     = sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones;
                 auto isLeftClick = event->buttons().testFlag(Qt::LeftButton);
                 if (!isDragDropClick && isLeftClick) {
                     if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::ZoomBox) {
                         // Starts a zoom box
                         impl->startDrawingRect(event->pos(), plot());
                     }
                     else if (isSelectionZoneMode && impl->m_DrawingZone == nullptr) {
                         // Starts a new selection zone
                         auto zoneAtPos = impl->selectionZoneAt(event->pos(), plot());
                         if (!zoneAtPos) {
                             impl->startDrawingZone(event->pos(), this);
                         }
                     }
                 }
                 // Allows mouse panning only in default mode
                 plot().setInteraction(QCP::iRangeDrag, sqpApp->plotsInteractionMode()
                                                                == SqpApplication::PlotsInteractionMode::None
                                                            && !isDragDropClick);
                 // Allows zone edition only in selection zone mode without drag&drop
                 impl->setSelectionZonesEditionEnabled(isSelectionZoneMode && !isDragDropClick);
                 // Selection / Deselection
                 if (isSelectionZoneMode) {
                     auto isMultiSelectionClick = event->modifiers().testFlag(MULTI_ZONE_SELECTION_MODIFIER);
                     auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos(), plot());
                     if (selectionZoneItemUnderCursor && !selectionZoneItemUnderCursor->selected()
                         && !isMultiSelectionClick) {
                         parentVisualizationWidget()->selectionZoneManager().select(
                             {selectionZoneItemUnderCursor});
                     }
                     else if (!selectionZoneItemUnderCursor && !isMultiSelectionClick && isLeftClick) {
                         parentVisualizationWidget()->selectionZoneManager().clearSelection();
                     }
                     else {
                         // No selection change
                     }
                     if (selectionZoneItemUnderCursor && isLeftClick) {
                         selectionZoneItemUnderCursor->setAssociatedEditedZones(
                             parentVisualizationWidget()->selectionZoneManager().selectedItems());
                     }
                 }
                 impl->m_HasMovedMouse = false;
                 VisualizationDragWidget::mousePressEvent(event);
             }
             void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
             {
                 if (impl->m_DrawingZoomRect) {
                     auto axisX = plot().axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = plot().axisRect()->axis(QCPAxis::atLeft);
                     auto newAxisXRange = QCPRange{impl->m_DrawingZoomRect->topLeft->coords().x(),
                                                   impl->m_DrawingZoomRect->bottomRight->coords().x()};
                     auto newAxisYRange = QCPRange{impl->m_DrawingZoomRect->topLeft->coords().y(),
                                                   impl->m_DrawingZoomRect->bottomRight->coords().y()};
                     impl->removeDrawingRect(plot());
                     if (newAxisXRange.size() > axisX->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0)
                         && newAxisYRange.size() > axisY->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0)) {
                         impl->m_ZoomStack.push(qMakePair(axisX->range(), axisY->range()));
                         axisX->setRange(newAxisXRange);
                         axisY->setRange(newAxisYRange);
                         plot().replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 impl->endDrawingZone(this);
                 impl->m_IsCalibration = false;
                 // Selection / Deselection
                 auto isSelectionZoneMode
                     = sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones;
                 if (isSelectionZoneMode) {
                     auto isMultiSelectionClick = event->modifiers().testFlag(MULTI_ZONE_SELECTION_MODIFIER);
                     auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos(), plot());
-                    if (selectionZoneItemUnderCursor && event->button() == Qt::LeftButton) {
+                    if (selectionZoneItemUnderCursor && event->button() == Qt::LeftButton
-                        if (!isMultiSelectionClick && !impl->m_HasMovedMouse) {
+                        && !impl->m_HasMovedMouse) {
-                            parentVisualizationWidget()->selectionZoneManager().select(
-                                {selectionZoneItemUnderCursor});
+                        auto zonesUnderCursor = impl->selectionZonesAt(event->pos(), plot());
+                        if (zonesUnderCursor.count() > 1) {
+                            // There are multiple zones under the mouse.
+                            // Performs the selection with a selection dialog.
+                            VisualizationMultiZoneSelectionDialog dialog{this};
+                            dialog.setZones(zonesUnderCursor);
+                            dialog.move(mapToGlobal(event->pos() - QPoint(dialog.width() / 2, 20)));
+                            dialog.activateWindow();
+                            dialog.raise();
+                            if (dialog.exec() == QDialog::Accepted) {
+                                auto selection = dialog.selectedZones();
+                                if (!isMultiSelectionClick) {
+                                    parentVisualizationWidget()->selectionZoneManager().clearSelection();
+                                }
+                                for (auto it = selection.cbegin(); it != selection.cend(); ++it) {
+                                    auto zone = it.key();
+                                    auto isSelected = it.value();
+                                    parentVisualizationWidget()->selectionZoneManager().setSelected(zone,
+                                                                                                    isSelected);
+                                    if (isSelected) {
+                                        // Puts the zone on top of the stack so it can be moved or resized
+                                        impl->moveSelectionZoneOnTop(zone, plot());
+                                    }
+                                }
+                            }
                         }
-                        else if (!impl->m_HasMovedMouse) {
+                        else {
-                            parentVisualizationWidget()->selectionZoneManager().setSelected(
+                            if (!isMultiSelectionClick) {
-                                selectionZoneItemUnderCursor, !selectionZoneItemUnderCursor->selected()
+                                parentVisualizationWidget()->selectionZoneManager().select(
-                                                                  || event->button() == Qt::RightButton);
+                                    {selectionZoneItemUnderCursor});
+                                impl->moveSelectionZoneOnTop(selectionZoneItemUnderCursor, plot());
+                            }
+                            else {
+                                parentVisualizationWidget()->selectionZoneManager().setSelected(
+                                    selectionZoneItemUnderCursor, !selectionZoneItemUnderCursor->selected()
+                                                                      || event->button() == Qt::RightButton);
+                            }
                         }
                     }
                     else {
                         // No selection change
                     }
                 }
             }
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
                 auto graphRange = ui->widget->xAxis->range();
                 auto dateTime = SqpRange{graphRange.lower, graphRange.upper};
                 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
                     auto variable = variableEntry.first;
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
                     if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
                         impl->updateData(variableEntry.second, variable->dataSeries(), variable->range());
                     }
                 }
             }
             void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,
                                                                  const SqpRange &range)
             {
                 auto it = impl->m_VariableToPlotMultiMap.find(variable);
                 if (it != impl->m_VariableToPlotMultiMap.end()) {
                     impl->updateData(it->second, variable->dataSeries(), range);
                 }
             }

gui/src/Visualization/VisualizationSelectionZoneItem.cpp +9 0

             #include "Visualization/VisualizationSelectionZoneItem.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationSelectionZoneManager.h"
             #include "Visualization/VisualizationWidget.h"
             const QString &DEFAULT_COLOR = QStringLiteral("#E79D41");
             struct VisualizationSelectionZoneItem::VisualizationSelectionZoneItemPrivate {
                 QCustomPlot *m_Plot;
                 double m_T1 = 0;
                 double m_T2 = 0;
                 QColor m_Color;
                 bool m_IsEditionEnabled = true;
                 double m_MovedOrinalT1 = 0;
                 double m_MovedOrinalT2 = 0;
                 QCPItemStraightLine *m_LeftLine;
                 QCPItemStraightLine *m_RightLine;
                 QCPItemText *m_NameLabelItem = nullptr;
                 enum class EditionMode { NoEdition, ResizeLeft, ResizeRight, Move };
                 EditionMode m_CurrentEditionMode;
                 QVector<VisualizationSelectionZoneItem *> m_AssociatedEditedZones;
                 VisualizationSelectionZoneItemPrivate(QCustomPlot *plot)
                         : m_Plot(plot), m_Color(Qt::blue), m_CurrentEditionMode(EditionMode::NoEdition)
                 {
                 }
                 void updatePosition(VisualizationSelectionZoneItem *item)
                 {
                     item->topLeft->setCoords(m_T1, 0);
                     item->bottomRight->setCoords(m_T2, 1);
                 }
                 EditionMode getEditionMode(const QPoint &pos, const VisualizationSelectionZoneItem *zoneItem)
                 {
                     auto distanceLeft = m_LeftLine->selectTest(pos, false);
                     auto distanceRight = m_RightLine->selectTest(pos, false);
                     auto distance = zoneItem->selectTest(pos, false);
                     if (distanceRight <= distance) {
                         return VisualizationSelectionZoneItemPrivate::EditionMode::ResizeRight;
                     }
                     else if (distanceLeft <= distance) {
                         return VisualizationSelectionZoneItemPrivate::EditionMode::ResizeLeft;
                     }
                     return VisualizationSelectionZoneItemPrivate::EditionMode::Move;
                 }
                 double pixelSizeToAxisXSize(double pixels)
                 {
                     auto axis = m_Plot->axisRect()->axis(QCPAxis::atBottom);
                     return axis->pixelToCoord(pixels) - axis->pixelToCoord(0);
                 }
                 bool alignZones(VisualizationSelectionZoneItem *referenceZone,
                                 const QVector<VisualizationSelectionZoneItem *> &zonesToAlign, bool alignOnLeft,
                                 bool allowResize, bool vertically)
                 {
                     auto result = false;
                     auto referenceTime
                         = alignOnLeft ? referenceZone->range().m_TStart : referenceZone->range().m_TEnd;
                     auto referenceBottomAxis = m_Plot->axisRect()->axis(QCPAxis::atBottom);
                     auto referenceVerticalPosition = referenceBottomAxis->coordToPixel(referenceTime);
                     for (auto otherZone : zonesToAlign) {
                         auto otherZoneRange = otherZone->range();
                         auto newZoneStart = otherZoneRange.m_TStart;
                         auto newZoneEnd = otherZoneRange.m_TEnd;
                         auto alignedTime = referenceTime;
                         if (vertically) {
                             auto otherZoneAxis = otherZone->parentPlot()->axisRect()->axis(QCPAxis::atBottom);
                             alignedTime = otherZoneAxis->pixelToCoord(referenceVerticalPosition);
                         }
                         if (alignOnLeft) {
                             newZoneStart = alignedTime;
                             if (!allowResize) {
                                 newZoneEnd = alignedTime + (otherZoneRange.m_TEnd - otherZoneRange.m_TStart);
                             }
                         }
                         else { // align on right
                             newZoneEnd = alignedTime;
                             if (!allowResize) {
                                 newZoneStart = alignedTime - (otherZoneRange.m_TEnd - otherZoneRange.m_TStart);
                             }
                         }
                         if (newZoneStart < newZoneEnd) {
                             result = true;
                             otherZone->setRange(newZoneStart, newZoneEnd);
                             otherZone->parentPlot()->replot();
                         }
                     }
                     return result;
                 }
             };
             VisualizationSelectionZoneItem::VisualizationSelectionZoneItem(QCustomPlot *plot)
                     : QCPItemRect(plot),
                       impl{spimpl::make_unique_impl<VisualizationSelectionZoneItemPrivate>(plot)}
             {
                 topLeft->setTypeX(QCPItemPosition::ptPlotCoords);
                 topLeft->setTypeY(QCPItemPosition::ptAxisRectRatio);
                 bottomRight->setTypeX(QCPItemPosition::ptPlotCoords);
                 bottomRight->setTypeY(QCPItemPosition::ptAxisRectRatio);
                 setSelectable(false);
                 impl->m_RightLine = new QCPItemStraightLine(plot);
                 impl->m_RightLine->point1->setParentAnchor(topRight);
                 impl->m_RightLine->point2->setParentAnchor(bottomRight);
                 impl->m_RightLine->point1->setTypeX(QCPItemPosition::ptAbsolute);
                 impl->m_RightLine->point1->setTypeY(QCPItemPosition::ptAbsolute);
                 impl->m_RightLine->point2->setTypeX(QCPItemPosition::ptAbsolute);
                 impl->m_RightLine->point2->setTypeY(QCPItemPosition::ptAbsolute);
                 impl->m_RightLine->setSelectable(false);
                 impl->m_LeftLine = new QCPItemStraightLine(plot);
                 impl->m_LeftLine->point1->setParentAnchor(topLeft);
                 impl->m_LeftLine->point2->setParentAnchor(bottomLeft);
                 impl->m_LeftLine->point1->setTypeX(QCPItemPosition::ptAbsolute);
                 impl->m_LeftLine->point1->setTypeY(QCPItemPosition::ptAbsolute);
                 impl->m_LeftLine->point2->setTypeX(QCPItemPosition::ptAbsolute);
                 impl->m_LeftLine->point2->setTypeY(QCPItemPosition::ptAbsolute);
                 impl->m_LeftLine->setSelectable(false);
                 connect(this, &VisualizationSelectionZoneItem::selectionChanged, impl->m_RightLine,
                         &QCPItemStraightLine::setSelected);
                 connect(this, &VisualizationSelectionZoneItem::selectionChanged, impl->m_LeftLine,
                         &QCPItemStraightLine::setSelected);
                 setColor(QColor(DEFAULT_COLOR));
             }
             VisualizationSelectionZoneItem::~VisualizationSelectionZoneItem()
             {
                 impl->m_Plot->removeItem(impl->m_RightLine);
                 impl->m_Plot->removeItem(impl->m_LeftLine);
             }
             VisualizationGraphWidget *VisualizationSelectionZoneItem::parentGraphWidget() const noexcept
             {
                 auto parent = impl->m_Plot->parentWidget();
                 while (parent != nullptr && !qobject_cast<VisualizationGraphWidget *>(parent)) {
                     parent = parent->parentWidget();
                 }
                 return qobject_cast<VisualizationGraphWidget *>(parent);
             }
             void VisualizationSelectionZoneItem::setName(const QString &name)
             {
                 if (name.isEmpty() && impl->m_NameLabelItem) {
                     impl->m_Plot->removeItem(impl->m_NameLabelItem);
                     impl->m_NameLabelItem = nullptr;
                 }
                 else if (!impl->m_NameLabelItem) {
                     impl->m_NameLabelItem = new QCPItemText(impl->m_Plot);
                     impl->m_NameLabelItem->setText(name);
                     impl->m_NameLabelItem->setPositionAlignment(Qt::AlignHCenter | Qt::AlignTop);
                     impl->m_NameLabelItem->setColor(impl->m_Color);
                     impl->m_NameLabelItem->position->setParentAnchor(top);
                 }
             }
             QString VisualizationSelectionZoneItem::name() const
             {
                 if (!impl->m_NameLabelItem) {
                     return QString();
                 }
                 return impl->m_NameLabelItem->text();
             }
             SqpRange VisualizationSelectionZoneItem::range() const
             {
                 SqpRange range;
                 range.m_TStart = impl->m_T1 <= impl->m_T2 ? impl->m_T1 : impl->m_T2;
                 range.m_TEnd = impl->m_T1 > impl->m_T2 ? impl->m_T1 : impl->m_T2;
                 return range;
             }
             void VisualizationSelectionZoneItem::setRange(double tstart, double tend)
             {
                 impl->m_T1 = tstart;
                 impl->m_T2 = tend;
                 impl->updatePosition(this);
             }
             void VisualizationSelectionZoneItem::setStart(double tstart)
             {
                 impl->m_T1 = tstart;
                 impl->updatePosition(this);
             }
             void VisualizationSelectionZoneItem::setEnd(double tend)
             {
                 impl->m_T2 = tend;
                 impl->updatePosition(this);
             }
             void VisualizationSelectionZoneItem::setColor(const QColor &color)
             {
                 impl->m_Color = color;
                 auto brushColor = color;
                 brushColor.setAlpha(80);
                 setBrush(QBrush(brushColor));
                 setPen(QPen(Qt::NoPen));
                 auto selectedBrushColor = brushColor;
                 selectedBrushColor.setAlpha(150);
                 setSelectedBrush(QBrush(selectedBrushColor));
                 setSelectedPen(QPen(Qt::NoPen));
                 auto linePen = QPen(color);
                 linePen.setStyle(Qt::SolidLine);
                 linePen.setWidth(4);
                 auto selectedLinePen = linePen;
                 selectedLinePen.setColor(color.darker(120));
                 selectedLinePen.setWidth(4);
                 impl->m_LeftLine->setPen(linePen);
                 impl->m_RightLine->setPen(linePen);
                 impl->m_LeftLine->setSelectedPen(selectedLinePen);
                 impl->m_RightLine->setSelectedPen(selectedLinePen);
             }
             void VisualizationSelectionZoneItem::setEditionEnabled(bool value)
             {
                 impl->m_IsEditionEnabled = value;
                 setSelectable(value);
                 if (!value) {
                     setSelected(false);
                     impl->m_CurrentEditionMode = VisualizationSelectionZoneItemPrivate::EditionMode::NoEdition;
                 }
             }
             bool VisualizationSelectionZoneItem::isEditionEnabled() const
             {
                 return impl->m_IsEditionEnabled;
             }
+            void VisualizationSelectionZoneItem::moveToTop()
+            {
+                moveToLayer(layer(), false);
+            }
             Qt::CursorShape
             VisualizationSelectionZoneItem::curshorShapeForPosition(const QPoint &position) const
             {
                 auto mode = impl->m_CurrentEditionMode
                                     == VisualizationSelectionZoneItemPrivate::EditionMode::NoEdition
                                 ? impl->getEditionMode(position, this)
                                 : impl->m_CurrentEditionMode;
                 switch (mode) {
                     case VisualizationSelectionZoneItemPrivate::EditionMode::Move:
                         return Qt::SizeAllCursor;
                     case VisualizationSelectionZoneItemPrivate::EditionMode::ResizeLeft:
                     case VisualizationSelectionZoneItemPrivate::EditionMode::ResizeRight: // fallthrough
                         return Qt::SizeHorCursor;
                     default:
                         return Qt::ArrowCursor;
                 }
             }
             void VisualizationSelectionZoneItem::setHovered(bool value)
             {
                 if (value) {
                     auto linePen = impl->m_LeftLine->pen();
                     linePen.setStyle(Qt::DotLine);
                     linePen.setWidth(3);
                     auto selectedLinePen = impl->m_LeftLine->selectedPen();
                     ;
                     selectedLinePen.setStyle(Qt::DotLine);
                     selectedLinePen.setWidth(3);
                     impl->m_LeftLine->setPen(linePen);
                     impl->m_RightLine->setPen(linePen);
                     impl->m_LeftLine->setSelectedPen(selectedLinePen);
                     impl->m_RightLine->setSelectedPen(selectedLinePen);
                 }
                 else {
                     setColor(impl->m_Color);
                 }
             }
             void VisualizationSelectionZoneItem::setAssociatedEditedZones(
                 const QVector<VisualizationSelectionZoneItem *> &associatedZones)
             {
                 impl->m_AssociatedEditedZones = associatedZones;
                 impl->m_AssociatedEditedZones.removeAll(this);
             }
             bool VisualizationSelectionZoneItem::alignZonesVerticallyOnLeft(
                 const QVector<VisualizationSelectionZoneItem *> &zonesToAlign, bool allowResize)
             {
                 return impl->alignZones(this, zonesToAlign, true, allowResize, true);
             }
             bool VisualizationSelectionZoneItem::alignZonesVerticallyOnRight(
                 const QVector<VisualizationSelectionZoneItem *> &zonesToAlign, bool allowResize)
             {
                 return impl->alignZones(this, zonesToAlign, false, allowResize, true);
             }
             bool VisualizationSelectionZoneItem::alignZonesTemporallyOnLeft(
                 const QVector<VisualizationSelectionZoneItem *> &zonesToAlign, bool allowResize)
             {
                 return impl->alignZones(this, zonesToAlign, true, allowResize, false);
             }
             bool VisualizationSelectionZoneItem::alignZonesTemporallyOnRight(
                 const QVector<VisualizationSelectionZoneItem *> &zonesToAlign, bool allowResize)
             {
                 return impl->alignZones(this, zonesToAlign, false, allowResize, false);
             }
             void VisualizationSelectionZoneItem::mousePressEvent(QMouseEvent *event, const QVariant &details)
             {
+                Q_UNUSED(details);
                 if (isEditionEnabled() && event->button() == Qt::LeftButton) {
                     impl->m_CurrentEditionMode = impl->getEditionMode(event->pos(), this);
                     impl->m_MovedOrinalT1 = impl->m_T1;
                     impl->m_MovedOrinalT2 = impl->m_T2;
                     for (auto associatedZone : impl->m_AssociatedEditedZones) {
                         associatedZone->impl->m_MovedOrinalT1 = associatedZone->impl->m_T1;
                         associatedZone->impl->m_MovedOrinalT2 = associatedZone->impl->m_T2;
                     }
                 }
                 else {
                     impl->m_CurrentEditionMode = VisualizationSelectionZoneItemPrivate::EditionMode::NoEdition;
                     event->ignore();
                 }
             }
             void VisualizationSelectionZoneItem::mouseMoveEvent(QMouseEvent *event, const QPointF &startPos)
             {
                 if (isEditionEnabled()) {
                     if (!selected()) {
                         // Force the item to be selected during the edition
                         parentGraphWidget()->parentVisualizationWidget()->selectionZoneManager().setSelected(
                             this, true);
                     }
                     auto axis = impl->m_Plot->axisRect()->axis(QCPAxis::atBottom);
                     auto pixelDiff = event->pos().x() - startPos.x();
                     auto diff = impl->pixelSizeToAxisXSize(pixelDiff);
                     switch (impl->m_CurrentEditionMode) {
                         case VisualizationSelectionZoneItemPrivate::EditionMode::Move:
                             setRange(impl->m_MovedOrinalT1 + diff, impl->m_MovedOrinalT2 + diff);
                             for (auto associatedZone : impl->m_AssociatedEditedZones) {
                                 associatedZone->move(pixelDiff);
                             }
                             break;
                         case VisualizationSelectionZoneItemPrivate::EditionMode::ResizeLeft:
                             setStart(impl->m_MovedOrinalT1 + diff);
                             for (auto associatedZone : impl->m_AssociatedEditedZones) {
                                 impl->m_MovedOrinalT1 < impl->m_MovedOrinalT2
                                     ? associatedZone->resizeLeft(pixelDiff)
                                     : associatedZone->resizeRight(pixelDiff);
                             }
                             break;
                         case VisualizationSelectionZoneItemPrivate::EditionMode::ResizeRight:
                             setEnd(impl->m_MovedOrinalT2 + diff);
                             for (auto associatedZone : impl->m_AssociatedEditedZones) {
                                 impl->m_MovedOrinalT1 < impl->m_MovedOrinalT2
                                     ? associatedZone->resizeRight(pixelDiff)
                                     : associatedZone->resizeLeft(pixelDiff);
                             }
                             break;
                         default:
                             break;
                     }
                     for (auto associatedZone : impl->m_AssociatedEditedZones) {
                         associatedZone->parentPlot()->replot();
                     }
                 }
                 else {
                     event->ignore();
                 }
             }
             void VisualizationSelectionZoneItem::mouseReleaseEvent(QMouseEvent *event, const QPointF &startPos)
             {
+                Q_UNUSED(startPos);
                 if (isEditionEnabled()) {
                     impl->m_CurrentEditionMode = VisualizationSelectionZoneItemPrivate::EditionMode::NoEdition;
                 }
                 else {
                     event->ignore();
                 }
                 impl->m_AssociatedEditedZones.clear();
             }
             void VisualizationSelectionZoneItem::resizeLeft(double pixelDiff)
             {
                 auto diff = impl->pixelSizeToAxisXSize(pixelDiff);
                 if (impl->m_MovedOrinalT1 <= impl->m_MovedOrinalT2) {
                     setStart(impl->m_MovedOrinalT1 + diff);
                 }
                 else {
                     setEnd(impl->m_MovedOrinalT2 + diff);
                 }
             }
             void VisualizationSelectionZoneItem::resizeRight(double pixelDiff)
             {
                 auto diff = impl->pixelSizeToAxisXSize(pixelDiff);
                 if (impl->m_MovedOrinalT1 > impl->m_MovedOrinalT2) {
                     setStart(impl->m_MovedOrinalT1 + diff);
                 }
                 else {
                     setEnd(impl->m_MovedOrinalT2 + diff);
                 }
             }
             void VisualizationSelectionZoneItem::move(double pixelDiff)
             {
                 auto diff = impl->pixelSizeToAxisXSize(pixelDiff);
                 setRange(impl->m_MovedOrinalT1 + diff, impl->m_MovedOrinalT2 + diff);
             }

gui/src/Visualization/VisualizationSelectionZoneManager.cpp +1 -1

             #include "Visualization/VisualizationSelectionZoneManager.h"
             #include "Visualization/VisualizationSelectionZoneItem.h"
             struct VisualizationSelectionZoneManager::VisualizationSelectionZoneManagerPrivate {
                 QVector<VisualizationSelectionZoneItem *> m_SelectedItems;
             };
             VisualizationSelectionZoneManager::VisualizationSelectionZoneManager()
                     : impl{spimpl::make_unique_impl<VisualizationSelectionZoneManagerPrivate>()}
             {
             }
             void VisualizationSelectionZoneManager::select(
                 const QVector<VisualizationSelectionZoneItem *> &items)
             {
                 clearSelection();
                 for (auto item : items) {
                     setSelected(item, true);
                 }
             }
             void VisualizationSelectionZoneManager::setSelected(VisualizationSelectionZoneItem *item,
                                                                 bool value)
             {
                 if (value != item->selected()) {
                     item->setSelected(value);
                     item->parentPlot()->replot(QCustomPlot::rpQueuedReplot);
                 }
                 if (!value && impl->m_SelectedItems.contains(item)) {
                     impl->m_SelectedItems.removeAll(item);
                 }
                 else if (value) {
                     impl->m_SelectedItems << item;
                 }
             }
             void VisualizationSelectionZoneManager::clearSelection()
             {
                 for (auto item : impl->m_SelectedItems) {
                     item->setSelected(false);
-                    item->parentPlot()->replot();
+                    item->parentPlot()->replot(QCustomPlot::rpQueuedReplot);
                 }
                 impl->m_SelectedItems.clear();
             }
             QVector<VisualizationSelectionZoneItem *> VisualizationSelectionZoneManager::selectedItems() const
             {
                 return impl->m_SelectedItems;
             }

General Comments 4

trabillard

|

Auto status change to "Under Review"

perrinel

|

Status change > Approved

perrinel

|

Status change > Approved

Write
Preview

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

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages