HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1044:dd81862d7e96

Display of selection zones on a graph

trabillard -

r1044:dd81862d7e96

parent child

Context file:

r1044:dd81862d7e96

gui/include/Visualization/VisualizationSelectionZoneItem.h created 644 +39 0

@@ -0,0 +1,39
	1	#ifndef SCIQLOP_VISUALIZATIONSELECTIONZONEITEM_H
	2	#define SCIQLOP_VISUALIZATIONSELECTIONZONEITEM_H
	3
	4	#include <Common/spimpl.h>
	5	#include <Data/SqpRange.h>
	6	#include <Visualization/qcustomplot.h>
	7
	8	class VisualizationSelectionZoneItem : public QCPItemRect {
	9	public:
	10	VisualizationSelectionZoneItem(QCustomPlot *plot);
	11	virtual ~VisualizationSelectionZoneItem();
	12
	13	void setName(const QString &name);
	14	QString name() const;
	15
	16	SqpRange range() const;
	17	void setRange(double tstart, double tend);
	18	void setStart(double tstart);
	19	void setEnd(double tend);
	20
	21	void setColor(const QColor &color);
	22
	23	void setEditionEnabled(bool value);
	24	bool isEditionEnabled() const;
	25
	26	Qt::CursorShape curshorShapeForPosition(const QPoint &position) const;
	27	void setHovered(bool value);
	28
	29	protected:
	30	void mousePressEvent(QMouseEvent *event, const QVariant &details) override;
	31	void mouseMoveEvent(QMouseEvent *event, const QPointF &startPos) override;
	32	void mouseReleaseEvent(QMouseEvent *event, const QPointF &startPos) override;
	33
	34	private:
	35	class VisualizationSelectionZoneItemPrivate;
	36	spimpl::unique_impl_ptr<VisualizationSelectionZoneItemPrivate> impl;
	37	};
	38
	39	#endif // SCIQLOP_VISUALIZATIONSELECTIONZONEITEM_H

gui/src/Visualization/VisualizationSelectionZoneItem.cpp created 644 +271 0

@@ -0,0 +1,271
	1	#include "Visualization/VisualizationSelectionZoneItem.h"
	2
	3	struct VisualizationSelectionZoneItem::VisualizationSelectionZoneItemPrivate {
	4
	5	QCustomPlot *m_Plot;
	6	double m_T1 = 0;
	7	double m_T2 = 0;
	8	QColor m_Color;
	9
	10	bool m_IsEditionEnabled = true;
	11	double m_MovedOrinalT1 = 0;
	12	double m_MovedOrinalT2 = 0;
	13
	14	QCPItemStraightLine *m_LeftLine;
	15	QCPItemStraightLine *m_RightLine;
	16	QCPItemText *m_NameLabelItem = nullptr;
	17
	18	enum class EditionMode { NoEdition, ResizeLeft, ResizeRight, Move };
	19	EditionMode m_CurrentEditionMode;
	20
	21	VisualizationSelectionZoneItemPrivate(QCustomPlot *plot)
	22	: m_Plot(plot), m_Color(Qt::blue), m_CurrentEditionMode(EditionMode::NoEdition)
	23	{
	24	}
	25
	26	void updatePosition(VisualizationSelectionZoneItem *item)
	27	{
	28	item->topLeft->setCoords(m_T1, 0);
	29	item->bottomRight->setCoords(m_T2, 1);
	30	}
	31
	32	EditionMode getEditionMode(const QPoint &pos, const VisualizationSelectionZoneItem *zoneItem)
	33	{
	34	auto distanceLeft = m_LeftLine->selectTest(pos, false);
	35	auto distanceRight = m_RightLine->selectTest(pos, false);
	36	auto distance = zoneItem->selectTest(pos, true);
	37
	38	if (distanceRight <= distance) {
	39	return VisualizationSelectionZoneItemPrivate::EditionMode::ResizeRight;
	40	}
	41	else if (distanceLeft <= distance) {
	42	return VisualizationSelectionZoneItemPrivate::EditionMode::ResizeLeft;
	43	}
	44
	45	return VisualizationSelectionZoneItemPrivate::EditionMode::Move;
	46	}
	47	};
	48
	49	VisualizationSelectionZoneItem::VisualizationSelectionZoneItem(QCustomPlot *plot)
	50	: QCPItemRect(plot),
	51	impl{spimpl::make_unique_impl<VisualizationSelectionZoneItemPrivate>(plot)}
	52	{
	53	topLeft->setTypeX(QCPItemPosition::ptPlotCoords);
	54	topLeft->setTypeY(QCPItemPosition::ptAxisRectRatio);
	55	bottomRight->setTypeX(QCPItemPosition::ptPlotCoords);
	56	bottomRight->setTypeY(QCPItemPosition::ptAxisRectRatio);
	57
	58	impl->m_RightLine = new QCPItemStraightLine(plot);
	59	impl->m_RightLine->point1->setParentAnchor(topRight);
	60	impl->m_RightLine->point2->setParentAnchor(bottomRight);
	61	impl->m_RightLine->point1->setTypeX(QCPItemPosition::ptAbsolute);
	62	impl->m_RightLine->point1->setTypeY(QCPItemPosition::ptAbsolute);
	63	impl->m_RightLine->point2->setTypeX(QCPItemPosition::ptAbsolute);
	64	impl->m_RightLine->point2->setTypeY(QCPItemPosition::ptAbsolute);
	65
	66	impl->m_LeftLine = new QCPItemStraightLine(plot);
	67	impl->m_LeftLine->point1->setParentAnchor(topLeft);
	68	impl->m_LeftLine->point2->setParentAnchor(bottomLeft);
	69	impl->m_LeftLine->point1->setTypeX(QCPItemPosition::ptAbsolute);
	70	impl->m_LeftLine->point1->setTypeY(QCPItemPosition::ptAbsolute);
	71	impl->m_LeftLine->point2->setTypeX(QCPItemPosition::ptAbsolute);
	72	impl->m_LeftLine->point2->setTypeY(QCPItemPosition::ptAbsolute);
	73
	74	impl->m_RightLine->setSelectable(false);
	75	impl->m_LeftLine->setSelectable(false);
	76
	77	// connect(this, &VisualizationSelectionZoneItem::selectionChanged, impl->m_RightLine,
	78	// &QCPItemStraightLine::setSelected);
	79	// connect(this, &VisualizationSelectionZoneItem::selectionChanged, impl->m_LeftLine,
	80	// &QCPItemStraightLine::setSelected);
	81
	82	setColor(QColor("#E79D41"));
	83	}
	84
	85	VisualizationSelectionZoneItem::~VisualizationSelectionZoneItem()
	86	{
	87	impl->m_Plot->removeItem(impl->m_RightLine);
	88	impl->m_Plot->removeItem(impl->m_LeftLine);
	89	}
	90
	91	void VisualizationSelectionZoneItem::setName(const QString &name)
	92	{
	93	if (name.isEmpty() && impl->m_NameLabelItem) {
	94	impl->m_Plot->removeItem(impl->m_NameLabelItem);
	95	impl->m_NameLabelItem = nullptr;
	96	}
	97	else if (!impl->m_NameLabelItem) {
	98	impl->m_NameLabelItem = new QCPItemText(impl->m_Plot);
	99	impl->m_NameLabelItem->setText(name);
	100	impl->m_NameLabelItem->setPositionAlignment(Qt::AlignHCenter \| Qt::AlignTop);
	101	impl->m_NameLabelItem->setColor(impl->m_Color);
	102	impl->m_NameLabelItem->position->setParentAnchor(top);
	103	}
	104	}
	105
	106	QString VisualizationSelectionZoneItem::name() const
	107	{
	108	if (!impl->m_NameLabelItem) {
	109	return QString();
	110	}
	111
	112	return impl->m_NameLabelItem->text();
	113	}
	114
	115	SqpRange VisualizationSelectionZoneItem::range() const
	116	{
	117	SqpRange range;
	118	range.m_TStart = impl->m_T1 <= impl->m_T2 ? impl->m_T1 : impl->m_T2;
	119	range.m_TEnd = impl->m_T1 > impl->m_T2 ? impl->m_T1 : impl->m_T2;
	120	return range;
	121	}
	122
	123	void VisualizationSelectionZoneItem::setRange(double tstart, double tend)
	124	{
	125	impl->m_T1 = tstart;
	126	impl->m_T2 = tend;
	127	impl->updatePosition(this);
	128	}
	129
	130	void VisualizationSelectionZoneItem::setStart(double tstart)
	131	{
	132	impl->m_T1 = tstart;
	133	impl->updatePosition(this);
	134	}
	135
	136	void VisualizationSelectionZoneItem::setEnd(double tend)
	137	{
	138	impl->m_T2 = tend;
	139	impl->updatePosition(this);
	140	}
	141
	142	void VisualizationSelectionZoneItem::setColor(const QColor &color)
	143	{
	144	impl->m_Color = color;
	145
	146	auto brushColor = color;
	147	brushColor.setAlpha(40);
	148	setBrush(QBrush(brushColor));
	149	setPen(QPen(Qt::NoPen));
	150
	151	auto selectedBrushColor = brushColor;
	152	selectedBrushColor.setAlpha(65);
	153	setSelectedBrush(QBrush(selectedBrushColor));
	154	setSelectedPen(QPen(Qt::NoPen));
	155
	156	auto linePen = QPen(color);
	157	linePen.setStyle(Qt::SolidLine);
	158	linePen.setWidth(2);
	159
	160	auto selectedLinePen = linePen;
	161	selectedLinePen.setColor(color.darker(30));
	162
	163	impl->m_LeftLine->setPen(linePen);
	164	impl->m_RightLine->setPen(linePen);
	165
	166	impl->m_LeftLine->setSelectedPen(selectedLinePen);
	167	impl->m_RightLine->setSelectedPen(selectedLinePen);
	168	}
	169
	170	void VisualizationSelectionZoneItem::setEditionEnabled(bool value)
	171	{
	172	impl->m_IsEditionEnabled = value;
	173	setSelectable(value);
	174	if (!value) {
	175	setSelected(false);
	176	}
	177	}
	178
	179	bool VisualizationSelectionZoneItem::isEditionEnabled() const
	180	{
	181	return impl->m_IsEditionEnabled;
	182	}
	183
	184	Qt::CursorShape
	185	VisualizationSelectionZoneItem::curshorShapeForPosition(const QPoint &position) const
	186	{
	187	auto mode = impl->m_CurrentEditionMode
	188	== VisualizationSelectionZoneItemPrivate::EditionMode::NoEdition
	189	? impl->getEditionMode(position, this)
	190	: impl->m_CurrentEditionMode;
	191	switch (mode) {
	192	case VisualizationSelectionZoneItemPrivate::EditionMode::Move:
	193	return Qt::SizeAllCursor;
	194	case VisualizationSelectionZoneItemPrivate::EditionMode::ResizeLeft:
	195	case VisualizationSelectionZoneItemPrivate::EditionMode::ResizeRight: // fallthrough
	196	return Qt::SizeHorCursor;
	197	default:
	198	return Qt::ArrowCursor;
	199	}
	200	}
	201
	202	void VisualizationSelectionZoneItem::setHovered(bool value)
	203	{
	204	if (value) {
	205	auto linePen = impl->m_LeftLine->pen();
	206	linePen.setStyle(Qt::DotLine);
	207	linePen.setWidth(3);
	208
	209	auto selectedLinePen = impl->m_LeftLine->selectedPen();
	210	;
	211	selectedLinePen.setStyle(Qt::DotLine);
	212	selectedLinePen.setWidth(3);
	213
	214	impl->m_LeftLine->setPen(linePen);
	215	impl->m_RightLine->setPen(linePen);
	216
	217	impl->m_LeftLine->setSelectedPen(selectedLinePen);
	218	impl->m_RightLine->setSelectedPen(selectedLinePen);
	219	}
	220	else {
	221	setColor(impl->m_Color);
	222	}
	223	}
	224
	225	void VisualizationSelectionZoneItem::mousePressEvent(QMouseEvent *event, const QVariant &details)
	226	{
	227	if (isEditionEnabled()) {
	228	impl->m_CurrentEditionMode = impl->getEditionMode(event->pos(), this);
	229
	230	impl->m_MovedOrinalT1 = impl->m_T1;
	231	impl->m_MovedOrinalT2 = impl->m_T2;
	232	}
	233	else {
	234	event->ignore();
	235	}
	236	}
	237
	238	void VisualizationSelectionZoneItem::mouseMoveEvent(QMouseEvent *event, const QPointF &startPos)
	239	{
	240	if (isEditionEnabled()) {
	241	auto axis = impl->m_Plot->axisRect()->axis(QCPAxis::atBottom);
	242	auto diff = axis->pixelToCoord(event->pos().x()) - axis->pixelToCoord(startPos.x());
	243
	244	switch (impl->m_CurrentEditionMode) {
	245	case VisualizationSelectionZoneItemPrivate::EditionMode::Move:
	246	setRange(impl->m_MovedOrinalT1 + diff, impl->m_MovedOrinalT2 + diff);
	247	break;
	248	case VisualizationSelectionZoneItemPrivate::EditionMode::ResizeLeft:
	249	setStart(impl->m_MovedOrinalT1 + diff);
	250	break;
	251	case VisualizationSelectionZoneItemPrivate::EditionMode::ResizeRight:
	252	setEnd(impl->m_MovedOrinalT2 + diff);
	253	break;
	254	// default:
	255	// unknown edition mode
	256	}
	257	}
	258	else {
	259	event->ignore();
	260	}
	261	}
	262
	263	void VisualizationSelectionZoneItem::mouseReleaseEvent(QMouseEvent *event, const QPointF &startPos)
	264	{
	265	if (isEditionEnabled()) {
	266	impl->m_CurrentEditionMode = VisualizationSelectionZoneItemPrivate::EditionMode::NoEdition;
	267	}
	268	else {
	269	event->ignore();
	270	}
	271	}

gui/meson.build +2 -1

             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'
             ]
             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'
             ]
             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/QCPColorMapIterator.cpp',
+              'src/Visualization/VisualizationSelectionZoneItem.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/VisualizationGraphRenderingDelegate.cpp +2 0

             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "Visualization/AxisRenderingUtils.h"
             #include "Visualization/ColorScaleEditor.h"
             #include "Visualization/PlottablesRenderingUtils.h"
             #include "Visualization/SqpColorScale.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/qcustomplot.h"
             #include <Common/DateUtils.h>
             #include <Data/IDataSeries.h>
             #include <SqpApplication.h>
             namespace {
             /// Name of the axes layer in QCustomPlot
             const auto AXES_LAYER = QStringLiteral("axes");
             /// Icon used to show x-axis properties
             const auto HIDE_AXIS_ICON_PATH = QStringLiteral(":/icones/down.png");
             /// Name of the overlay layer in QCustomPlot
             const auto OVERLAY_LAYER = QStringLiteral("overlay");
             /// Pixmap used to show x-axis properties
             const auto SHOW_AXIS_ICON_PATH = QStringLiteral(":/icones/up.png");
             /// Tooltip format for graphs
             const auto GRAPH_TOOLTIP_FORMAT = QStringLiteral("key: %1\nvalue: %2");
             /// Tooltip format for colormaps
             const auto COLORMAP_TOOLTIP_FORMAT = QStringLiteral("x: %1\ny: %2\nvalue: %3");
             /// Offset used to shift the tooltip of the mouse
             const auto TOOLTIP_OFFSET = QPoint{20, 20};
             /// Tooltip display rectangle (the tooltip is hidden when the mouse leaves this rectangle)
             const auto TOOLTIP_RECT = QRect{10, 10, 10, 10};
             /// Timeout after which the tooltip is displayed
             const auto TOOLTIP_TIMEOUT = 500;
             void initPointTracerStyle(QCPItemTracer &tracer) noexcept
             {
                 tracer.setInterpolating(false);
                 tracer.setStyle(QCPItemTracer::tsCircle);
                 tracer.setSize(3);
                 tracer.setPen(QPen(Qt::black));
                 tracer.setBrush(Qt::black);
+                tracer.setSelectable(false);
             }
             QPixmap pixmap(const QString &iconPath) noexcept
             {
                 return QIcon{iconPath}.pixmap(QSize{16, 16});
             }
             void initClosePixmapStyle(QCPItemPixmap &pixmap) noexcept
             {
                 // Icon
                 pixmap.setPixmap(
                     sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton).pixmap(QSize{16, 16}));
                 // Position
                 pixmap.topLeft->setType(QCPItemPosition::ptAxisRectRatio);
                 pixmap.topLeft->setCoords(1, 0);
                 pixmap.setClipToAxisRect(false);
                 // Can be selected
                 pixmap.setSelectable(true);
             }
             void initXAxisPixmapStyle(QCPItemPixmap &itemPixmap) noexcept
             {
                 // Icon
                 itemPixmap.setPixmap(pixmap(HIDE_AXIS_ICON_PATH));
                 // Position
                 itemPixmap.topLeft->setType(QCPItemPosition::ptAxisRectRatio);
                 itemPixmap.topLeft->setCoords(0, 1);
                 itemPixmap.setClipToAxisRect(false);
                 // Can be selected
                 itemPixmap.setSelectable(true);
             }
             void initTitleTextStyle(QCPItemText &text) noexcept
             {
                 // Font and background styles
                 text.setColor(Qt::gray);
                 text.setBrush(Qt::white);
                 // Position
                 text.setPositionAlignment(Qt::AlignTop | Qt::AlignLeft);
                 text.position->setType(QCPItemPosition::ptAxisRectRatio);
                 text.position->setCoords(0.5, 0);
+                text.setSelectable(false);
             }
             /**
              * Returns the cell index (x or y) of a colormap according to the coordinate passed in parameter.
              * This method handles the fact that a colormap axis can be logarithmic or linear.
              * @param colormap the colormap for which to calculate the index
              * @param coord the coord to convert to cell index
              * @param xCoord calculates the x index if true, calculates y index if false
              * @return the cell index
              */
             int colorMapCellIndex(const QCPColorMap &colormap, double coord, bool xCoord)
             {
                 // Determines the axis of the colormap according to xCoord, and whether it is logarithmic or not
                 auto isLogarithmic = (xCoord ? colormap.keyAxis() : colormap.valueAxis())->scaleType()
                                      == QCPAxis::stLogarithmic;
                 if (isLogarithmic) {
                     // For a logarithmic axis we can't use the conversion method of colormap, so we calculate
                     // the index manually based on the position of the coordinate on the axis
                     // Gets the axis range and the number of values between range bounds to calculate the step
                     // between each value of the range
                     auto range = xCoord ? colormap.data()->keyRange() : colormap.data()->valueRange();
                     auto nbValues = (xCoord ? colormap.data()->keySize() : colormap.data()->valueSize()) - 1;
                     auto valueStep
                         = (std::log10(range.upper) - std::log10(range.lower)) / static_cast<double>(nbValues);
                     // According to the coord position, calculates the closest index in the range
                     return std::round((std::log10(coord) - std::log10(range.lower)) / valueStep);
                 }
                 else {
                     // For a linear axis, we use the conversion method of colormap
                     int index;
                     if (xCoord) {
                         colormap.data()->coordToCell(coord, 0., &index, nullptr);
                     }
                     else {
                         colormap.data()->coordToCell(0., coord, nullptr, &index);
                     }
                     return index;
                 }
             }
             } // namespace
             struct VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegatePrivate {
                 explicit VisualizationGraphRenderingDelegatePrivate(VisualizationGraphWidget &graphWidget)
                         : m_Plot{graphWidget.plot()},
                           m_PointTracer{new QCPItemTracer{&m_Plot}},
                           m_TracerTimer{},
                           m_ClosePixmap{new QCPItemPixmap{&m_Plot}},
                           m_TitleText{new QCPItemText{&m_Plot}},
                           m_XAxisPixmap{new QCPItemPixmap{&m_Plot}},
                           m_ShowXAxis{true},
                           m_XAxisLabel{},
                           m_ColorScale{SqpColorScale{m_Plot}}
                 {
                     initPointTracerStyle(*m_PointTracer);
                     m_TracerTimer.setInterval(TOOLTIP_TIMEOUT);
                     m_TracerTimer.setSingleShot(true);
                     // Inits "close button" in plot overlay
                     m_ClosePixmap->setLayer(OVERLAY_LAYER);
                     initClosePixmapStyle(*m_ClosePixmap);
                     // Connects pixmap selection to graph widget closing
                     QObject::connect(m_ClosePixmap, &QCPItemPixmap::selectionChanged,
                                      [&graphWidget](bool selected) {
                                          if (selected) {
                                              graphWidget.close();
                                          }
                                      });
                     // Inits graph name in plot overlay
                     m_TitleText->setLayer(OVERLAY_LAYER);
                     m_TitleText->setText(graphWidget.name());
                     initTitleTextStyle(*m_TitleText);
                     // Inits "show x-axis button" in plot overlay
                     m_XAxisPixmap->setLayer(OVERLAY_LAYER);
                     initXAxisPixmapStyle(*m_XAxisPixmap);
                     // Connects pixmap selection to graph x-axis showing/hiding
                     QObject::connect(m_XAxisPixmap, &QCPItemPixmap::selectionChanged, [this]() {
                         if (m_XAxisPixmap->selected()) {
                             // Changes the selection state and refreshes the x-axis
                             m_ShowXAxis = !m_ShowXAxis;
                             updateXAxisState();
                             m_Plot.layer(AXES_LAYER)->replot();
                             // Deselects the x-axis pixmap and updates icon
                             m_XAxisPixmap->setSelected(false);
                             m_XAxisPixmap->setPixmap(
                                 pixmap(m_ShowXAxis ? HIDE_AXIS_ICON_PATH : SHOW_AXIS_ICON_PATH));
                             m_Plot.layer(OVERLAY_LAYER)->replot();
                         }
                     });
                 }
                 /// Updates state of x-axis according to the current selection of x-axis pixmap
                 /// @remarks the method doesn't call plot refresh
                 void updateXAxisState() noexcept
                 {
                     m_Plot.xAxis->setTickLabels(m_ShowXAxis);
                     m_Plot.xAxis->setLabel(m_ShowXAxis ? m_XAxisLabel : QString{});
                 }
                 QCustomPlot &m_Plot;
                 QCPItemTracer *m_PointTracer;
                 QTimer m_TracerTimer;
                 QCPItemPixmap *m_ClosePixmap; /// Graph's close button
                 QCPItemText *m_TitleText;     /// Graph's title
                 QCPItemPixmap *m_XAxisPixmap;
                 bool m_ShowXAxis; /// X-axis properties are shown or hidden
                 QString m_XAxisLabel;
                 SqpColorScale m_ColorScale; /// Color scale used for some types of graphs (as spectrograms)
             };
             VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegate(
                 VisualizationGraphWidget &graphWidget)
                     : impl{spimpl::make_unique_impl<VisualizationGraphRenderingDelegatePrivate>(graphWidget)}
             {
             }
             void VisualizationGraphRenderingDelegate::onMouseDoubleClick(QMouseEvent *event) noexcept
             {
                 // Opens color scale editor if color scale is double clicked
                 auto colorScale = static_cast<QCPColorScale *>(impl->m_Plot.layoutElementAt(event->pos()));
                 if (impl->m_ColorScale.m_Scale == colorScale) {
                     if (ColorScaleEditor{impl->m_ColorScale}.exec() == QDialog::Accepted) {
                         impl->m_Plot.replot();
                     }
                 }
             }
             void VisualizationGraphRenderingDelegate::onMouseMove(QMouseEvent *event) noexcept
             {
                 // Cancels pending refresh
                 impl->m_TracerTimer.disconnect();
                 // Reinits tracers
                 impl->m_PointTracer->setGraph(nullptr);
                 impl->m_PointTracer->setVisible(false);
                 impl->m_Plot.replot();
                 QString tooltip{};
                 // Gets the graph under the mouse position
                 auto eventPos = event->pos();
                 if (auto graph = qobject_cast<QCPGraph *>(impl->m_Plot.plottableAt(eventPos))) {
                     auto mouseKey = graph->keyAxis()->pixelToCoord(eventPos.x());
                     auto graphData = graph->data();
                     // Gets the closest data point to the mouse
                     auto graphDataIt = graphData->findBegin(mouseKey);
                     if (graphDataIt != graphData->constEnd()) {
                         // Sets tooltip
                         auto key = formatValue(graphDataIt->key, *graph->keyAxis());
                         auto value = formatValue(graphDataIt->value, *graph->valueAxis());
                         tooltip = GRAPH_TOOLTIP_FORMAT.arg(key, value);
                         // Displays point tracer
                         impl->m_PointTracer->setGraph(graph);
                         impl->m_PointTracer->setGraphKey(graphDataIt->key);
                         impl->m_PointTracer->setLayer(
                             impl->m_Plot.layer("main")); // Tracer is set on top of the plot's main layer
                         impl->m_PointTracer->setVisible(true);
                         impl->m_Plot.replot();
                     }
                 }
                 else if (auto colorMap = qobject_cast<QCPColorMap *>(impl->m_Plot.plottableAt(eventPos))) {
                     // Gets x and y coords
                     auto x = colorMap->keyAxis()->pixelToCoord(eventPos.x());
                     auto y = colorMap->valueAxis()->pixelToCoord(eventPos.y());
                     // Calculates x and y cell indexes, and retrieves the underlying value
                     auto xCellIndex = colorMapCellIndex(*colorMap, x, true);
                     auto yCellIndex = colorMapCellIndex(*colorMap, y, false);
                     auto value = colorMap->data()->cell(xCellIndex, yCellIndex);
                     // Sets tooltips
                     tooltip = COLORMAP_TOOLTIP_FORMAT.arg(formatValue(x, *colorMap->keyAxis()),
                                                           formatValue(y, *colorMap->valueAxis()),
                                                           formatValue(value, *colorMap->colorScale()->axis()));
                 }
                 if (!tooltip.isEmpty()) {
                     // Starts timer to show tooltip after timeout
                     auto showTooltip = [tooltip, eventPos, this]() {
                         QToolTip::showText(impl->m_Plot.mapToGlobal(eventPos) + TOOLTIP_OFFSET, tooltip,
                                            &impl->m_Plot, TOOLTIP_RECT);
                     };
                     QObject::connect(&impl->m_TracerTimer, &QTimer::timeout, showTooltip);
                     impl->m_TracerTimer.start();
                 }
             }
             void VisualizationGraphRenderingDelegate::onPlotUpdated() noexcept
             {
                 // Updates color scale bounds
                 impl->m_ColorScale.updateDataRange();
                 impl->m_Plot.replot();
             }
             void VisualizationGraphRenderingDelegate::setAxesProperties(
                 std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 // Stores x-axis label to be able to retrieve it when x-axis pixmap is unselected
                 impl->m_XAxisLabel = dataSeries->xAxisUnit().m_Name;
                 auto axisHelper = IAxisHelperFactory::create(dataSeries);
                 axisHelper->setProperties(impl->m_Plot, impl->m_ColorScale);
                 // Updates x-axis state
                 impl->updateXAxisState();
                 impl->m_Plot.layer(AXES_LAYER)->replot();
             }
             void VisualizationGraphRenderingDelegate::setPlottablesProperties(
                 std::shared_ptr<IDataSeries> dataSeries, PlottablesMap &plottables) noexcept
             {
                 auto plottablesHelper = IPlottablesHelperFactory::create(dataSeries);
                 plottablesHelper->setProperties(plottables);
             }
             void VisualizationGraphRenderingDelegate::showGraphOverlay(bool show) noexcept
             {
                 auto overlay = impl->m_Plot.layer(OVERLAY_LAYER);
                 overlay->setVisible(show);
                 overlay->replot();
             }

gui/src/Visualization/VisualizationGraphWidget.cpp +125 -25

             #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/VisualizationSelectionZoneItem.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Common/MimeTypesDef.h>
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <DragAndDrop/DragDropHelper.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 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;
             /// 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_DrawingRect = nullptr;
+                QCPItemRect *m_DrawingZoomRect = nullptr;
                 std::unique_ptr<VisualizationCursorItem> m_HorizontalCursor = nullptr;
                 std::unique_ptr<VisualizationCursorItem> m_VerticalCursor = nullptr;
-                void configureDrawingRect()
+                VisualizationSelectionZoneItem *m_DrawingZone = nullptr;
+                VisualizationSelectionZoneItem *m_HoveredZone = nullptr;
-                    if (m_DrawingRect) {
+                QVector<VisualizationSelectionZoneItem *> m_SelectionZones;
-                        QPen p;
-                        p.setWidth(2);
-                        m_DrawingRect->setPen(p);
                 void startDrawingRect(const QPoint &pos, QCustomPlot &plot)
                 {
                     removeDrawingRect(plot);
                     auto axisPos = posToAxisPos(pos, plot);
-                    m_DrawingRect = new QCPItemRect{&plot};
+                    m_DrawingZoomRect = new QCPItemRect{&plot};
-                    configureDrawingRect();
+                    QPen p;
+                    p.setWidth(2);
+                    m_DrawingZoomRect->setPen(p);
-                    m_DrawingRect->topLeft->setCoords(axisPos);
+                    m_DrawingZoomRect->topLeft->setCoords(axisPos);
-                    m_DrawingRect->bottomRight->setCoords(axisPos);
+                    m_DrawingZoomRect->bottomRight->setCoords(axisPos);
                 }
                 void removeDrawingRect(QCustomPlot &plot)
                 {
-                    if (m_DrawingRect) {
+                    if (m_DrawingZoomRect) {
-                        plot.removeItem(m_DrawingRect); // the item is deleted by QCustomPlot
+                        plot.removeItem(m_DrawingZoomRect); // the item is deleted by QCustomPlot
-                        m_DrawingRect = nullptr;
+                        m_DrawingZoomRect = nullptr;
                         plot.replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
+                void startDrawingZone(const QPoint &pos, QCustomPlot &plot)
+                {
+                    endDrawingZone(plot);
+                    auto axisPos = posToAxisPos(pos, plot);
+                    m_DrawingZone = new VisualizationSelectionZoneItem{&plot};
+                    m_DrawingZone->setRange(axisPos.x(), axisPos.x());
+                    m_DrawingZone->setEditionEnabled(false);
+                }
+                void endDrawingZone(QCustomPlot &plot)
+                {
+                    if (m_DrawingZone) {
+                        auto drawingZoneRange = m_DrawingZone->range();
+                        if (qAbs(drawingZoneRange.m_TEnd - drawingZoneRange.m_TStart) > 0) {
+                            m_DrawingZone->setEditionEnabled(true);
+                            m_SelectionZones.append(m_DrawingZone);
+                        }
+                        else {
+                            plot.removeItem(m_DrawingZone); // the item is deleted by QCustomPlot
+                        }
+                        plot.replot(QCustomPlot::rpQueuedReplot);
+                        m_DrawingZone = nullptr;
+                    }
+                }
+                void setSelectionZonesEditionEnabled(bool value)
+                {
+                    for (auto s : m_SelectionZones) {
+                        s->setEditionEnabled(value);
+                    }
+                }
                 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 :
-                // - Drag (on x-axis) and zoom are enabled
+                // - zoom is enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                 ui->widget->setInteractions(QCP::iRangeZoom | QCP::iSelectItems);
                 // 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);
             }
             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");
             }
             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
             {
                 auto mimeData = new QMimeData;
                 mimeData->setData(MIME_TYPE_GRAPH, QByteArray{});
                 auto timeRangeData = TimeController::mimeDataForTimeRange(graphRange());
                 mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
                 return mimeData;
             }
             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() 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 (!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());
-                if (impl->m_DrawingRect) {
+                // Zoom box and zone drawing
-                    impl->m_DrawingRect->bottomRight->setCoords(axisPos);
+                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
+                VisualizationSelectionZoneItem *selectionZoneItemUnderCursor = nullptr;
+                auto minDistanceToZone = -1;
+                for (auto zone : impl->m_SelectionZones) {
+                    auto distanceToZone = zone->selectTest(event->pos(), true);
+                    if ((minDistanceToZone < 0 || distanceToZone <= minDistanceToZone) && distanceToZone >= 0
+                        && distanceToZone < plot().selectionTolerance()) {
+                        selectionZoneItemUnderCursor = zone;
+                    }
+                }
+                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);
+                }
                 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
             {
                 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::ZoomBox) {
+                    // Starts a zoom box
                     impl->startDrawingRect(event->pos(), plot());
                 }
+                else if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
+                         && impl->m_DrawingZone == nullptr) {
+                    // Starts a new selection zone
+                    auto itemAtPos = plot().itemAt(event->pos(), true);
+                    if (!itemAtPos) {
+                        impl->startDrawingZone(event->pos(), plot());
+                    }
+                }
+                // Allows mouse panning only in default mode
+                plot().setInteraction(QCP::iRangeDrag, sqpApp->plotsInteractionMode()
+                                                           == SqpApplication::PlotsInteractionMode::None);
+                // Allows zone edition only in selection zone mode
+                impl->setSelectionZonesEditionEnabled(sqpApp->plotsInteractionMode()
+                                                      == SqpApplication::PlotsInteractionMode::SelectionZones);
                 VisualizationDragWidget::mousePressEvent(event);
             }
             void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
             {
-                if (impl->m_DrawingRect) {
+                if (impl->m_DrawingZoomRect) {
                     auto axisX = plot().axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = plot().axisRect()->axis(QCPAxis::atLeft);
-                    auto newAxisXRange = QCPRange{impl->m_DrawingRect->topLeft->coords().x(),
+                    auto newAxisXRange = QCPRange{impl->m_DrawingZoomRect->topLeft->coords().x(),
-                                                  impl->m_DrawingRect->bottomRight->coords().x()};
+                                                  impl->m_DrawingZoomRect->bottomRight->coords().x()};
-                    auto newAxisYRange = QCPRange{impl->m_DrawingRect->topLeft->coords().y(),
+                    auto newAxisYRange = QCPRange{impl->m_DrawingZoomRect->topLeft->coords().y(),
-                                                  impl->m_DrawingRect->bottomRight->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)) {
                         axisX->setRange(newAxisXRange);
                         axisY->setRange(newAxisYRange);
                         plot().replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
+                impl->endDrawingZone(plot());
                 impl->m_IsCalibration = false;
             }
             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);
                 }
             }

General Comments 0

Write
Preview

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

No TODOs yet

	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