GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1010:cf3e9de4d0c6 · LPP's Code Repositories

LPP's Code Repositories

0

- This repo
- ?
- Use '/' key to quickly access this field. - Enter a name of repository, or repository group for quick search. - Prefix query to allow special search: user:admin, to search for usernames, always global user_group:devops, to search for user groups, always global pr:303, to search for pull request number, title, or description, always global commit:efced4, to search for commits, scoped to repositories or groups file:models.py, to search for file paths, scoped to repositories or groups For advanced full text search visit: repository search
Home
Public journal
Gists
Sign in

GIT_REPOSITORIES » LPP » Users » mperrinel » SciQLop-fork

RSS

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Merge branch 'feature/InteractionModesAndCursors' into develop

trabillard -

r1010:cf3e9de4d0c6

parent child

Show More

Context file:

r1010:cf3e9de4d0c6

Collapse all files

0

gui/include/Visualization/VisualizationCursorItem.h created 644 +26 0

	@@ -0,0 +1,26
				1	#ifndef SCIQLOP_VISUALIZATIONCURSORITEM_H
				2	#define SCIQLOP_VISUALIZATIONCURSORITEM_H
				3
				4	#include <Common/spimpl.h>
				5	#include <SqpApplication.h>
				6
				7	class QCustomPlot;
				8
				9	class VisualizationCursorItem {
				10	public:
				11	VisualizationCursorItem(QCustomPlot *plot);
				12
				13	void setVisible(bool value);
				14	bool isVisible() const;
				15
				16	void setPosition(double value);
				17	void setAbsolutePosition(double value);
				18	void setOrientation(Qt::Orientation orientation);
				19	void setLabelText(const QString &text);
				20
				21	private:
				22	class VisualizationCursorItemPrivate;
				23	spimpl::unique_impl_ptr<VisualizationCursorItemPrivate> impl;
				24	};
				25
				26	#endif // SCIQLOP_VISUALIZATIONCURSORITEM_H

0

gui/resources/icones/cursor.png created 644 binary 0 0

1

NO CONTENT: new file 100644, binary diff hidden

NO CONTENT: new file 100644, binary diff hidden

0

gui/resources/icones/drag.png created 644 binary 0 0

1

NO CONTENT: new file 100644, binary diff hidden

NO CONTENT: new file 100644, binary diff hidden

0

gui/resources/icones/pointer.png created 644 binary 0 0

1

NO CONTENT: new file 100644, binary diff hidden

NO CONTENT: new file 100644, binary diff hidden

0

gui/resources/icones/rectangle.png created 644 binary 0 0

1

NO CONTENT: new file 100644, binary diff hidden

NO CONTENT: new file 100644, binary diff hidden

0

gui/resources/icones/zoom.png created 644 binary 0 0

1

NO CONTENT: new file 100644, binary diff hidden

NO CONTENT: new file 100644, binary diff hidden

0

gui/src/Visualization/VisualizationCursorItem.cpp created 644 +163 0

	@@ -0,0 +1,163
				1	#include <Common/DateUtils.h>
				2	#include <Visualization/VisualizationCursorItem.h>
				3	#include <Visualization/qcustomplot.h>
				4
				5	/// Width of the cursor in pixel
				6	const auto CURSOR_WIDTH = 3;
				7
				8	/// Color of the cursor in the graph
				9	const auto CURSOR_COLOR = QColor{68, 114, 196};
				10
				11	/// Line style of the cursor in the graph
				12	auto CURSOR_PEN_STYLE = Qt::DotLine;
				13
				14	struct VisualizationCursorItem::VisualizationCursorItemPrivate {
				15
				16	QCustomPlot *m_Plot = nullptr;
				17
				18	QCPItemStraightLine *m_LineItem = nullptr;
				19	QCPItemText *m_LabelItem = nullptr;
				20
				21	Qt::Orientation m_Orientation;
				22	double m_Position = 0.0;
				23	bool m_IsAbsolutePosition = false;
				24	QString m_LabelText;
				25
				26	explicit VisualizationCursorItemPrivate(QCustomPlot *plot)
				27	: m_Plot(plot), m_Orientation(Qt::Vertical)
				28	{
				29	}
				30
				31	void updateOrientation()
				32	{
				33	if (m_LineItem) {
				34	switch (m_Orientation) {
				35	case Qt::Vertical:
				36	m_LineItem->point1->setTypeX(m_IsAbsolutePosition
				37	? QCPItemPosition::ptAbsolute
				38	: QCPItemPosition::ptPlotCoords);
				39	m_LineItem->point1->setTypeY(QCPItemPosition::ptAxisRectRatio);
				40	m_LineItem->point2->setTypeX(m_IsAbsolutePosition
				41	? QCPItemPosition::ptAbsolute
				42	: QCPItemPosition::ptPlotCoords);
				43	m_LineItem->point2->setTypeY(QCPItemPosition::ptAxisRectRatio);
				44	m_LabelItem->setPositionAlignment(Qt::AlignLeft \| Qt::AlignTop);
				45	break;
				46	case Qt::Horizontal:
				47	m_LineItem->point1->setTypeX(QCPItemPosition::ptAxisRectRatio);
				48	m_LineItem->point1->setTypeY(m_IsAbsolutePosition
				49	? QCPItemPosition::ptAbsolute
				50	: QCPItemPosition::ptPlotCoords);
				51	m_LineItem->point2->setTypeX(QCPItemPosition::ptAxisRectRatio);
				52	m_LineItem->point2->setTypeY(m_IsAbsolutePosition
				53	? QCPItemPosition::ptAbsolute
				54	: QCPItemPosition::ptPlotCoords);
				55	m_LabelItem->setPositionAlignment(Qt::AlignRight \| Qt::AlignBottom);
				56	}
				57	}
				58	}
				59
				60	void updateCursorPosition()
				61	{
				62	if (m_LineItem) {
				63	switch (m_Orientation) {
				64	case Qt::Vertical:
				65	m_LineItem->point1->setCoords(m_Position, 0);
				66	m_LineItem->point2->setCoords(m_Position, 1);
				67	m_LabelItem->position->setCoords(5, 5);
				68	break;
				69	case Qt::Horizontal:
				70	m_LineItem->point1->setCoords(1, m_Position);
				71	m_LineItem->point2->setCoords(0, m_Position);
				72	m_LabelItem->position->setCoords(-5, -5);
				73	}
				74	}
				75	}
				76
				77	void updateLabelText()
				78	{
				79	if (m_LabelItem) {
				80	m_LabelItem->setText(m_LabelText);
				81	}
				82	}
				83	};
				84
				85	VisualizationCursorItem::VisualizationCursorItem(QCustomPlot *plot)
				86	: impl{spimpl::make_unique_impl<VisualizationCursorItemPrivate>(plot)}
				87	{
				88	}
				89
				90	void VisualizationCursorItem::setVisible(bool value)
				91	{
				92	if (value != isVisible()) {
				93
				94	if (value) {
				95	Q_ASSERT(!impl->m_LineItem && !impl->m_Plot);
				96
				97	impl->m_LineItem = new QCPItemStraightLine{impl->m_Plot};
				98	auto pen = QPen{CURSOR_PEN_STYLE};
				99	pen.setColor(CURSOR_COLOR);
				100	pen.setWidth(CURSOR_WIDTH);
				101	impl->m_LineItem->setPen(pen);
				102	impl->m_LineItem->setSelectable(false);
				103
				104	impl->m_LabelItem = new QCPItemText{impl->m_Plot};
				105	impl->m_LabelItem->setColor(CURSOR_COLOR);
				106	impl->m_LabelItem->setSelectable(false);
				107	impl->m_LabelItem->position->setParentAnchor(impl->m_LineItem->point1);
				108	impl->m_LabelItem->position->setTypeX(QCPItemPosition::ptAbsolute);
				109	impl->m_LabelItem->position->setTypeY(QCPItemPosition::ptAbsolute);
				110
				111	auto font = impl->m_LabelItem->font();
				112	font.setPointSize(10);
				113	font.setBold(true);
				114	impl->m_LabelItem->setFont(font);
				115
				116	impl->updateOrientation();
				117	impl->updateLabelText();
				118	impl->updateCursorPosition();
				119	}
				120	else {
				121	Q_ASSERT(impl->m_LineItem && impl->m_Plot);
				122
				123	// Note: the items are destroyed by QCustomPlot in removeItem
				124	impl->m_Plot->removeItem(impl->m_LineItem);
				125	impl->m_LineItem = nullptr;
				126	impl->m_Plot->removeItem(impl->m_LabelItem);
				127	impl->m_LabelItem = nullptr;
				128	}
				129	}
				130	}
				131
				132	bool VisualizationCursorItem::isVisible() const
				133	{
				134	return impl->m_LineItem != nullptr;
				135	}
				136
				137	void VisualizationCursorItem::setPosition(double value)
				138	{
				139	impl->m_Position = value;
				140	impl->m_IsAbsolutePosition = false;
				141	impl->updateLabelText();
				142	impl->updateCursorPosition();
				143	}
				144
				145	void VisualizationCursorItem::setAbsolutePosition(double value)
				146	{
				147	setPosition(value);
				148	impl->m_IsAbsolutePosition = true;
				149	}
				150
				151	void VisualizationCursorItem::setOrientation(Qt::Orientation orientation)
				152	{
				153	impl->m_Orientation = orientation;
				154	impl->updateLabelText();
				155	impl->updateOrientation();
				156	impl->updateCursorPosition();
				157	}
				158
				159	void VisualizationCursorItem::setLabelText(const QString &text)
				160	{
				161	impl->m_LabelText = text;
				162	impl->updateLabelText();
				163	}

0

app/src/MainWindow.cpp +102 -3

             /*------------------------------------------------------------------------------
             -- This file is a part of the SciQLop Software
             -- Copyright (C) 2017, Plasma Physics Laboratory - CNRS
             --
             -- This program is free software; you can redistribute it and/or modify
             -- it under the terms of the GNU General Public License as published by
             -- the Free Software Foundation; either version 2 of the License, or
             -- (at your option) any later version.
             --
             -- This program is distributed in the hope that it will be useful,
             -- but WITHOUT ANY WARRANTY; without even the implied warranty of
             -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
             -- GNU General Public License for more details.
             --
             -- You should have received a copy of the GNU General Public License
             -- along with this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "MainWindow.h"
             #include "ui_MainWindow.h"
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceWidget.h>
             #include <Settings/SqpSettingsDialog.h>
             #include <Settings/SqpSettingsGeneralWidget.h>
             #include <SidePane/SqpSidePane.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <TimeWidget/TimeWidget.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/VisualizationController.h>
             #include <QAction>
             #include <QDate>
             #include <QDir>
             #include <QFileDialog>
             #include <QToolBar>
             #include <QToolButton>
             #include <memory.h>
             #include "iostream"
             Q_LOGGING_CATEGORY(LOG_MainWindow, "MainWindow")
             namespace {
             const auto LEFTMAININSPECTORWIDGETSPLITTERINDEX = 0;
             const auto LEFTINSPECTORSIDEPANESPLITTERINDEX = 1;
             const auto VIEWPLITTERINDEX = 2;
             const auto RIGHTINSPECTORSIDEPANESPLITTERINDEX = 3;
             const auto RIGHTMAININSPECTORWIDGETSPLITTERINDEX = 4;
             }
             class MainWindow::MainWindowPrivate {
             public:
                 explicit MainWindowPrivate(MainWindow *mainWindow)
                         : m_LastOpenLeftInspectorSize{},
                           m_LastOpenRightInspectorSize{},
                           m_GeneralSettingsWidget{new SqpSettingsGeneralWidget{mainWindow}},
                           m_SettingsDialog{new SqpSettingsDialog{mainWindow}}
                 {
                 }
                 QSize m_LastOpenLeftInspectorSize;
                 QSize m_LastOpenRightInspectorSize;
                 /// General settings widget. MainWindow has the ownership
                 SqpSettingsGeneralWidget *m_GeneralSettingsWidget;
                 /// Settings dialog. MainWindow has the ownership
                 SqpSettingsDialog *m_SettingsDialog;
             };
             MainWindow::MainWindow(QWidget *parent)
                     : QMainWindow{parent},
                       m_Ui{new Ui::MainWindow},
                       impl{spimpl::make_unique_impl<MainWindowPrivate>(this)}
             {
                 m_Ui->setupUi(this);
                 m_Ui->splitter->setCollapsible(LEFTINSPECTORSIDEPANESPLITTERINDEX, false);
                 m_Ui->splitter->setCollapsible(RIGHTINSPECTORSIDEPANESPLITTERINDEX, false);
                 auto leftSidePane = m_Ui->leftInspectorSidePane->sidePane();
                 auto openLeftInspectorAction = new QAction{QIcon{
                                                                ":/icones/previous.png",
                                                            },
                                                            tr("Show/hide the left inspector"), this};
                 auto spacerLeftTop = new QWidget{};
                 spacerLeftTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerLeftBottom = new QWidget{};
                 spacerLeftBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 leftSidePane->addWidget(spacerLeftTop);
                 leftSidePane->addAction(openLeftInspectorAction);
                 leftSidePane->addWidget(spacerLeftBottom);
                 auto rightSidePane = m_Ui->rightInspectorSidePane->sidePane();
                 auto openRightInspectorAction = new QAction{QIcon{
                                                                 ":/icones/next.png",
                                                             },
                                                             tr("Show/hide the right inspector"), this};
                 auto spacerRightTop = new QWidget{};
                 spacerRightTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerRightBottom = new QWidget{};
                 spacerRightBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 rightSidePane->addWidget(spacerRightTop);
                 rightSidePane->addAction(openRightInspectorAction);
                 rightSidePane->addWidget(spacerRightBottom);
                 openLeftInspectorAction->setCheckable(true);
                 openRightInspectorAction->setCheckable(true);
                 auto openInspector = [this](bool checked, bool right, auto action) {
                     action->setIcon(QIcon{(checked xor right) ? ":/icones/next.png" : ":/icones/previous.png"});
                     auto &lastInspectorSize
                         = right ? impl->m_LastOpenRightInspectorSize : impl->m_LastOpenLeftInspectorSize;
                     auto nextInspectorSize = right ? m_Ui->rightMainInspectorWidget->size()
                                                    : m_Ui->leftMainInspectorWidget->size();
                     // Update of the last opened geometry
                     if (checked) {
                         lastInspectorSize = nextInspectorSize;
                     }
                     auto startSize = lastInspectorSize;
                     auto endSize = startSize;
                     endSize.setWidth(0);
                     auto splitterInspectorIndex
                         = right ? RIGHTMAININSPECTORWIDGETSPLITTERINDEX : LEFTMAININSPECTORWIDGETSPLITTERINDEX;
                     auto currentSizes = m_Ui->splitter->sizes();
                     if (checked) {
                         // adjust sizes individually here, e.g.
                         currentSizes[splitterInspectorIndex] -= lastInspectorSize.width();
                         currentSizes[VIEWPLITTERINDEX] += lastInspectorSize.width();
                         m_Ui->splitter->setSizes(currentSizes);
                     }
                     else {
                         // adjust sizes individually here, e.g.
                         currentSizes[splitterInspectorIndex] += lastInspectorSize.width();
                         currentSizes[VIEWPLITTERINDEX] -= lastInspectorSize.width();
                         m_Ui->splitter->setSizes(currentSizes);
                     }
                 };
                 connect(openLeftInspectorAction, &QAction::triggered,
                         [openInspector, openLeftInspectorAction](bool checked) {
                             openInspector(checked, false, openLeftInspectorAction);
                         });
                 connect(openRightInspectorAction, &QAction::triggered,
                         [openInspector, openRightInspectorAction](bool checked) {
                             openInspector(checked, true, openRightInspectorAction);
                         });
-                // //// //
+                // //////////////// //
-                // Menu //
+                // Menu and Toolbar //
-                // //// //
+                // //////////////// //
                 this->menuBar()->addAction(tr("File"));
                 auto toolsMenu = this->menuBar()->addMenu(tr("Tools"));
                 toolsMenu->addAction(tr("Settings..."), [this]() {
                     // Loads settings
                     impl->m_SettingsDialog->loadSettings();
                     // Open settings dialog and save settings if the dialog is accepted
                     if (impl->m_SettingsDialog->exec() == QDialog::Accepted) {
                         impl->m_SettingsDialog->saveSettings();
                     }
                 });
                 auto mainToolBar = this->addToolBar(QStringLiteral("MainToolBar"));
                 auto timeWidget = new TimeWidget{};
                 mainToolBar->addWidget(timeWidget);
+                auto actionPointerMode = new QAction{QIcon(":/icones/pointer.png"), "Pointer", this};
+                actionPointerMode->setCheckable(true);
+                actionPointerMode->setChecked(sqpApp->plotsInteractionMode()
+                                              == SqpApplication::PlotsInteractionMode::None);
+                connect(actionPointerMode, &QAction::triggered,
+                        []() { sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::None); });
+                auto actionZoomMode = new QAction{QIcon(":/icones/zoom.png"), "Zoom", this};
+                actionZoomMode->setCheckable(true);
+                actionZoomMode->setChecked(sqpApp->plotsInteractionMode()
+                                           == SqpApplication::PlotsInteractionMode::ZoomBox);
+                connect(actionZoomMode, &QAction::triggered, []() {
+                    sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::ZoomBox);
+                });
+                auto actionOrganisationMode = new QAction{QIcon(":/icones/drag.png"), "Organize", this};
+                actionOrganisationMode->setCheckable(true);
+                actionOrganisationMode->setChecked(sqpApp->plotsInteractionMode()
+                                                   == SqpApplication::PlotsInteractionMode::DragAndDrop);
+                connect(actionOrganisationMode, &QAction::triggered, []() {
+                    sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::DragAndDrop);
+                });
+                auto actionZonesMode = new QAction{QIcon(":/icones/rectangle.png"), "Zones", this};
+                actionZonesMode->setCheckable(true);
+                actionZonesMode->setChecked(sqpApp->plotsInteractionMode()
+                                            == SqpApplication::PlotsInteractionMode::SelectionZones);
+                connect(actionZonesMode, &QAction::triggered, []() {
+                    sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::SelectionZones);
+                });
+                auto modeActionGroup = new QActionGroup{this};
+                modeActionGroup->addAction(actionZoomMode);
+                modeActionGroup->addAction(actionZonesMode);
+                modeActionGroup->addAction(actionOrganisationMode);
+                modeActionGroup->addAction(actionPointerMode);
+                modeActionGroup->setExclusive(true);
+                mainToolBar->addSeparator();
+                mainToolBar->addAction(actionPointerMode);
+                mainToolBar->addAction(actionZoomMode);
+                mainToolBar->addAction(actionOrganisationMode);
+                mainToolBar->addAction(actionZonesMode);
+                mainToolBar->addSeparator();
+                auto btnCursor = new QToolButton{this};
+                btnCursor->setIcon(QIcon(":/icones/cursor.png"));
+                btnCursor->setText("Cursor");
+                btnCursor->setToolTip("Cursor");
+                btnCursor->setPopupMode(QToolButton::InstantPopup);
+                auto cursorMenu = new QMenu("CursorMenu", this);
+                btnCursor->setMenu(cursorMenu);
+                auto noCursorAction = cursorMenu->addAction("No Cursor");
+                noCursorAction->setCheckable(true);
+                noCursorAction->setChecked(sqpApp->plotsCursorMode()
+                                           == SqpApplication::PlotsCursorMode::NoCursor);
+                connect(noCursorAction, &QAction::triggered,
+                        []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::NoCursor); });
+                cursorMenu->addSeparator();
+                auto verticalCursorAction = cursorMenu->addAction("Vertical Cursor");
+                verticalCursorAction->setCheckable(true);
+                verticalCursorAction->setChecked(sqpApp->plotsCursorMode()
+                                                 == SqpApplication::PlotsCursorMode::Vertical);
+                connect(verticalCursorAction, &QAction::triggered,
+                        []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Vertical); });
+                auto temporalCursorAction = cursorMenu->addAction("Temporal Cursor");
+                temporalCursorAction->setCheckable(true);
+                temporalCursorAction->setChecked(sqpApp->plotsCursorMode()
+                                                 == SqpApplication::PlotsCursorMode::Temporal);
+                connect(temporalCursorAction, &QAction::triggered,
+                        []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Temporal); });
+                auto horizontalCursorAction = cursorMenu->addAction("Horizontal Cursor");
+                horizontalCursorAction->setCheckable(true);
+                horizontalCursorAction->setChecked(sqpApp->plotsCursorMode()
+                                                   == SqpApplication::PlotsCursorMode::Horizontal);
+                connect(horizontalCursorAction, &QAction::triggered,
+                        []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Horizontal); });
+                auto crossCursorAction = cursorMenu->addAction("Cross Cursor");
+                crossCursorAction->setCheckable(true);
+                crossCursorAction->setChecked(sqpApp->plotsCursorMode()
+                                              == SqpApplication::PlotsCursorMode::Cross);
+                connect(crossCursorAction, &QAction::triggered,
+                        []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Cross); });
+                mainToolBar->addWidget(btnCursor);
+                auto cursorModeActionGroup = new QActionGroup{this};
+                cursorModeActionGroup->setExclusive(true);
+                cursorModeActionGroup->addAction(noCursorAction);
+                cursorModeActionGroup->addAction(verticalCursorAction);
+                cursorModeActionGroup->addAction(temporalCursorAction);
+                cursorModeActionGroup->addAction(horizontalCursorAction);
+                cursorModeActionGroup->addAction(crossCursorAction);
                 // //////// //
                 // Settings //
                 // //////// //
                 // Registers "general settings" widget to the settings dialog
                 impl->m_SettingsDialog->registerWidget(QStringLiteral("General"),
                                                        impl->m_GeneralSettingsWidget);
                 // /////////// //
                 // Connections //
                 // /////////// //
                 // Controllers / controllers connections
                 connect(&sqpApp->timeController(), SIGNAL(timeUpdated(SqpRange)), &sqpApp->variableController(),
                         SLOT(onDateTimeOnSelection(SqpRange)));
                 // Widgets / controllers connections
                 // DataSource
                 connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem *)),
                         m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem *)));
                 // Time
                 connect(timeWidget, SIGNAL(timeUpdated(SqpRange)), &sqpApp->timeController(),
                         SLOT(onTimeToUpdate(SqpRange)));
                 // Visualization
                 connect(&sqpApp->visualizationController(),
                         SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), m_Ui->view,
                         SLOT(onVariableAboutToBeDeleted(std::shared_ptr<Variable>)));
                 connect(&sqpApp->visualizationController(),
                         SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)), m_Ui->view,
                         SLOT(onRangeChanged(std::shared_ptr<Variable>, const SqpRange &)));
                 // Widgets / widgets connections
                 // For the following connections, we use DirectConnection to allow each widget that can
                 // potentially attach a menu to the variable's menu to do so before this menu is displayed.
                 // The order of connections is also important, since it determines the order in which each
                 // widget will attach its menu
                 connect(
                     m_Ui->variableInspectorWidget,
                     SIGNAL(tableMenuAboutToBeDisplayed(QMenu *, const QVector<std::shared_ptr<Variable> > &)),
                     m_Ui->view, SLOT(attachVariableMenu(QMenu *, const QVector<std::shared_ptr<Variable> > &)),
                     Qt::DirectConnection);
             }
             MainWindow::~MainWindow()
             {
             }
             void MainWindow::changeEvent(QEvent *e)
             {
                 QMainWindow::changeEvent(e);
                 switch (e->type()) {
                     case QEvent::LanguageChange:
                         m_Ui->retranslateUi(this);
                         break;
                     default:
                         break;
                 }
             }

0

gui/include/Common/VisualizationDef.h +1 0

             #ifndef SCIQLOP_VISUALIZATIONDEF_H
             #define SCIQLOP_VISUALIZATIONDEF_H
             /// Minimum height for graph added in zones (in pixels)
             extern const int GRAPH_MINIMUM_HEIGHT;
             #endif // SCIQLOP_VISUALIZATIONDEF_H

0

gui/include/SqpApplication.h +10 0

             #ifndef SCIQLOP_SQPAPPLICATION_H
             #define SCIQLOP_SQPAPPLICATION_H
             #include "SqpApplication.h"
             #include <QApplication>
             #include <QLoggingCategory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_SqpApplication)
             #if defined(sqpApp)
             #undef sqpApp
             #endif
             #define sqpApp (static_cast<SqpApplication *>(QCoreApplication::instance()))
             class DataSourceController;
             class NetworkController;
             class TimeController;
             class VariableController;
             class VisualizationController;
             class DragDropHelper;
             /**
              * @brief The SqpApplication class aims to make the link between SciQlop
              * and its plugins. This is the intermediate class that SciQlop has to use
              * in the way to connect a data source. Please first use load method to initialize
              * a plugin specified by its metadata name (JSON plugin source) then others specifics
              * method will be able to access it.
              * You can load a data source driver plugin then create a data source.
              */
             class SqpApplication : public QApplication {
                 Q_OBJECT
             public:
                 explicit SqpApplication(int &argc, char **argv);
                 virtual ~SqpApplication();
                 void initialize();
                 /// Accessors for the differents sciqlop controllers
                 DataSourceController &dataSourceController() noexcept;
                 NetworkController &networkController() noexcept;
                 TimeController &timeController() noexcept;
                 VariableController &variableController() noexcept;
                 VisualizationController &visualizationController() noexcept;
                 /// Accessors for the differents sciqlop helpers, these helpers classes are like controllers but
                 /// doesn't live in a thread and access gui
                 DragDropHelper &dragDropHelper() noexcept;
+                enum class PlotsInteractionMode { None, ZoomBox, DragAndDrop, SelectionZones };
+                enum class PlotsCursorMode { NoCursor, Vertical, Temporal, Horizontal, Cross };
+                PlotsInteractionMode plotsInteractionMode() const;
+                void setPlotsInteractionMode(PlotsInteractionMode mode);
+                PlotsCursorMode plotsCursorMode() const;
+                void setPlotsCursorMode(PlotsCursorMode mode);
             private:
                 class SqpApplicationPrivate;
                 spimpl::unique_impl_ptr<SqpApplicationPrivate> impl;
             };
             #endif // SCIQLOP_SQPAPPLICATION_H

0

gui/include/Visualization/VisualizationGraphWidget.h +12 0

             #ifndef SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
             #include <memory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphWidget)
             class QCPRange;
             class QCustomPlot;
             class SqpRange;
             class Variable;
             class VisualizationZoneWidget;
             namespace Ui {
             class VisualizationGraphWidget;
             } // namespace Ui
             class VisualizationGraphWidget : public VisualizationDragWidget, public IVisualizationWidget {
                 Q_OBJECT
                 friend class QCustomPlotSynchronizer;
                 friend class VisualizationGraphRenderingDelegate;
             public:
                 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationGraphWidget();
                 VisualizationZoneWidget *parentZoneWidget() const noexcept;
                 /// If acquisition isn't enable, requestDataLoading signal cannot be emit
                 void enableAcquisition(bool enable);
                 void addVariable(std::shared_ptr<Variable> variable, SqpRange range);
                 /// Removes a variable from the graph
                 void removeVariable(std::shared_ptr<Variable> variable) noexcept;
                 /// Returns the list of all variables used in the graph
                 QList<std::shared_ptr<Variable> > variables() const;
                 /// Sets the y-axis range based on the data of a variable
                 void setYRange(std::shared_ptr<Variable> variable);
                 SqpRange graphRange() const noexcept;
                 void setGraphRange(const SqpRange &range);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
                 bool contains(const Variable &variable) const override;
                 QString name() const override;
                 // VisualisationDragWidget
                 QMimeData *mimeData() const override;
                 bool isDragAllowed() const override;
                 void highlightForMerge(bool highlighted) override;
+                // Cursors
+                /// Adds or moves the vertical cursor at the specified value on the x-axis
+                void addVerticalCursor(double time);
+                /// Adds or moves the vertical cursor at the specified value on the x-axis
+                void addVerticalCursorAtViewportPosition(double position);
+                void removeVerticalCursor();
+                /// Adds or moves the vertical cursor at the specified value on the y-axis
+                void addHorizontalCursor(double value);
+                /// Adds or moves the vertical cursor at the specified value on the y-axis
+                void addHorizontalCursorAtViewportPosition(double position);
+                void removeHorizontalCursor();
             signals:
                 void synchronize(const SqpRange &range, const SqpRange &oldRange);
                 void requestDataLoading(QVector<std::shared_ptr<Variable> > variable, const SqpRange &range,
                                         bool synchronise);
                 /// Signal emitted when the variable is about to be removed from the graph
                 void variableAboutToBeRemoved(std::shared_ptr<Variable> var);
                 /// Signal emitted when the variable has been added to the graph
                 void variableAdded(std::shared_ptr<Variable> var);
             protected:
                 void closeEvent(QCloseEvent *event) override;
                 void enterEvent(QEvent *event) override;
                 void leaveEvent(QEvent *event) override;
                 QCustomPlot &plot() noexcept;
             private:
                 Ui::VisualizationGraphWidget *ui;
                 class VisualizationGraphWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
             private slots:
                 /// Slot called when right clicking on the graph (displays a menu)
                 void onGraphMenuRequested(const QPoint &pos) noexcept;
                 /// Rescale the X axe to range parameter
                 void onRangeChanged(const QCPRange &t1, const QCPRange &t2);
                 /// Slot called when a mouse move was made
                 void onMouseMove(QMouseEvent *event) noexcept;
                 /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
                 void onMouseWheel(QWheelEvent *event) noexcept;
                 /// Slot called when a mouse press was made, to activate the calibration of a graph
                 void onMousePress(QMouseEvent *event) noexcept;
                 /// Slot called when a mouse release was made, to deactivate the calibration of a graph
                 void onMouseRelease(QMouseEvent *event) noexcept;
                 void onDataCacheVariableUpdated();
                 void onUpdateVarDisplaying(std::shared_ptr<Variable> variable, const SqpRange &range);
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H

0

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

             #ifndef SCIQLOP_VISUALIZATIONZONEWIDGET_H
             #define SCIQLOP_VISUALIZATIONZONEWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
             #include <memory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationZoneWidget)
             namespace Ui {
             class VisualizationZoneWidget;
             } // namespace Ui
             class Variable;
             class VisualizationGraphWidget;
             class VisualizationZoneWidget : public VisualizationDragWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationZoneWidget();
                 /// Adds a graph widget
                 void addGraph(VisualizationGraphWidget *graphWidget);
                 /// Inserts a graph widget
                 void insertGraph(int index, VisualizationGraphWidget *graphWidget);
                 /**
                  * Creates a graph using a variable. The variable will be displayed in the new graph.
                  * The graph is added at the end.
                  * @param variable the variable for which to create the graph
                  * @return the pointer to the created graph
                  */
                 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable);
                 /**
                  * Creates a graph using a variable. The variable will be displayed in the new graph.
                  * The graph is inserted at the specified index.
                  * @param variable the variable for which to create the graph
                  * @param index The index where the graph should be inserted in the layout
                  * @return the pointer to the created graph
                  */
                 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable, int index);
                 /**
                  * Creates a graph using a list of variables. The variables will be displayed in the new graph.
                  * The graph is inserted at the specified index.
                  * @param variables List of variables to be added to the graph
                  * @param index The index where the graph should be inserted in the layout
                  * @return the pointer to the created graph
                  */
                 VisualizationGraphWidget *createGraph(const QList<std::shared_ptr<Variable> > variables,
                                                       int index);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
                 bool contains(const Variable &variable) const override;
                 QString name() const override;
                 // VisualisationDragWidget
                 QMimeData *mimeData() const override;
                 bool isDragAllowed() const override;
+                void notifyMouseMoveInGraph(const QPointF &graphPosition, const QPointF &plotPosition,
+                                            VisualizationGraphWidget *graphWidget);
+                void notifyMouseLeaveGraph(VisualizationGraphWidget *graphWidget);
             protected:
                 void closeEvent(QCloseEvent *event) override;
             private:
                 Ui::VisualizationZoneWidget *ui;
                 class VisualizationZoneWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationZoneWidgetPrivate> impl;
             private slots:
                 void onVariableAdded(std::shared_ptr<Variable> variable);
                 /// Slot called when a variable is about to be removed from a graph contained in the zone
                 void onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable);
                 void dropMimeData(int index, const QMimeData *mimeData);
                 void dropMimeDataOnGraph(VisualizationDragWidget *dragWidget, const QMimeData *mimeData);
             };
             #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H

0

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'
             ]
             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'
             ]
             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/MacScrollBarStyle.cpp',
+              'src/Visualization/VisualizationCursorItem.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])

0

gui/resources/icones/time.png binary modified 0 0

1

NO CONTENT: modified file, binary diff hidden

NO CONTENT: modified file, binary diff hidden

0

gui/resources/sqpguiresources.qrc +5 0

             <RCC>
                 <qresource prefix="/">
             		<file>icones/dataSourceComponent.png</file>
             		<file>icones/dataSourceNode.png</file>
             		<file>icones/dataSourceProduct.png</file>
             		<file>icones/dataSourceRoot.png</file>
             		<file>icones/delete.png</file>
                     <file>icones/down.png</file>
                     <file>icones/openInspector.png</file>
                     <file>icones/next.png</file>
                     <file>icones/plot.png</file>
                     <file>icones/previous.png</file>
                     <file>icones/unplot.png</file>
                     <file>icones/up.png</file>
             		<file>icones/time.png</file>
+            		<file>icones/zoom.png</file>
+            		<file>icones/rectangle.png</file>
+            		<file>icones/drag.png</file>
+            		<file>icones/cursor.png</file>
+            		<file>icones/pointer.png</file>
                 </qresource>
             </RCC>

0

gui/src/SqpApplication.cpp +26 -1

             #include "SqpApplication.h"
             #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
             #include <DragAndDrop/DragDropHelper.h>
             #include <Network/NetworkController.h>
             #include <QThread>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Visualization/VisualizationController.h>
             Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
             class SqpApplication::SqpApplicationPrivate {
             public:
                 SqpApplicationPrivate()
                         : m_DataSourceController{std::make_unique<DataSourceController>()},
                           m_VariableController{std::make_unique<VariableController>()},
                           m_TimeController{std::make_unique<TimeController>()},
                           m_NetworkController{std::make_unique<NetworkController>()},
                           m_VisualizationController{std::make_unique<VisualizationController>()},
-                          m_DragDropHelper{std::make_unique<DragDropHelper>()}
+                          m_DragDropHelper{std::make_unique<DragDropHelper>()},
+                          m_PlotInterractionMode(SqpApplication::PlotsInteractionMode::None),
+                          m_PlotCursorMode(SqpApplication::PlotsCursorMode::NoCursor)
                 {
                     // /////////////////////////////// //
                     // Connections between controllers //
                     // /////////////////////////////// //
                     // VariableController <-> DataSourceController
                     connect(m_DataSourceController.get(),
                             SIGNAL(variableCreationRequested(const QString &, const QVariantHash &,
                                                              std::shared_ptr<IDataProvider>)),
                             m_VariableController.get(),
                             SLOT(createVariable(const QString &, const QVariantHash &,
                                                 std::shared_ptr<IDataProvider>)));
                     connect(m_VariableController->variableModel(), &VariableModel::requestVariable,
                             m_DataSourceController.get(), &DataSourceController::requestVariable);
                     // VariableController <-> VisualizationController
                     connect(m_VariableController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
                             m_VisualizationController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
                     connect(m_VariableController.get(),
                             SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)),
                             m_VisualizationController.get(),
                             SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)));
                     m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
                     m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
                     m_NetworkController->moveToThread(&m_NetworkControllerThread);
                     m_NetworkControllerThread.setObjectName("NetworkControllerThread");
                     m_VariableController->moveToThread(&m_VariableControllerThread);
                     m_VariableControllerThread.setObjectName("VariableControllerThread");
                     m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
                     m_VisualizationControllerThread.setObjectName("VsualizationControllerThread");
                     // Additionnal init
                     m_VariableController->setTimeController(m_TimeController.get());
                 }
                 virtual ~SqpApplicationPrivate()
                 {
                     m_DataSourceControllerThread.quit();
                     m_DataSourceControllerThread.wait();
                     m_NetworkControllerThread.quit();
                     m_NetworkControllerThread.wait();
                     m_VariableControllerThread.quit();
                     m_VariableControllerThread.wait();
                     m_VisualizationControllerThread.quit();
                     m_VisualizationControllerThread.wait();
                 }
                 std::unique_ptr<DataSourceController> m_DataSourceController;
                 std::unique_ptr<VariableController> m_VariableController;
                 std::unique_ptr<TimeController> m_TimeController;
                 std::unique_ptr<NetworkController> m_NetworkController;
                 std::unique_ptr<VisualizationController> m_VisualizationController;
                 QThread m_DataSourceControllerThread;
                 QThread m_NetworkControllerThread;
                 QThread m_VariableControllerThread;
                 QThread m_VisualizationControllerThread;
                 std::unique_ptr<DragDropHelper> m_DragDropHelper;
+                SqpApplication::PlotsInteractionMode m_PlotInterractionMode;
+                SqpApplication::PlotsCursorMode m_PlotCursorMode;
             };
             SqpApplication::SqpApplication(int &argc, char **argv)
                     : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
             {
                 qCDebug(LOG_SqpApplication()) << tr("SqpApplication construction") << QThread::currentThread();
                 connect(&impl->m_DataSourceControllerThread, &QThread::started,
                         impl->m_DataSourceController.get(), &DataSourceController::initialize);
                 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
                         impl->m_DataSourceController.get(), &DataSourceController::finalize);
                 connect(&impl->m_NetworkControllerThread, &QThread::started, impl->m_NetworkController.get(),
                         &NetworkController::initialize);
                 connect(&impl->m_NetworkControllerThread, &QThread::finished, impl->m_NetworkController.get(),
                         &NetworkController::finalize);
                 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
                         &VariableController::initialize);
                 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
                         &VariableController::finalize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::started,
                         impl->m_VisualizationController.get(), &VisualizationController::initialize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
                         impl->m_VisualizationController.get(), &VisualizationController::finalize);
                 impl->m_DataSourceControllerThread.start();
                 impl->m_NetworkControllerThread.start();
                 impl->m_VariableControllerThread.start();
                 impl->m_VisualizationControllerThread.start();
             }
             SqpApplication::~SqpApplication()
             {
             }
             void SqpApplication::initialize()
             {
             }
             DataSourceController &SqpApplication::dataSourceController() noexcept
             {
                 return *impl->m_DataSourceController;
             }
             NetworkController &SqpApplication::networkController() noexcept
             {
                 return *impl->m_NetworkController;
             }
             TimeController &SqpApplication::timeController() noexcept
             {
                 return *impl->m_TimeController;
             }
             VariableController &SqpApplication::variableController() noexcept
             {
                 return *impl->m_VariableController;
             }
             VisualizationController &SqpApplication::visualizationController() noexcept
             {
                 return *impl->m_VisualizationController;
             }
             DragDropHelper &SqpApplication::dragDropHelper() noexcept
             {
                 return *impl->m_DragDropHelper;
             }
+            SqpApplication::PlotsInteractionMode SqpApplication::plotsInteractionMode() const
+            {
+                return impl->m_PlotInterractionMode;
+            }
+            void SqpApplication::setPlotsInteractionMode(SqpApplication::PlotsInteractionMode mode)
+            {
+                impl->m_PlotInterractionMode = mode;
+            }
+            SqpApplication::PlotsCursorMode SqpApplication::plotsCursorMode() const
+            {
+                return impl->m_PlotCursorMode;
+            }
+            void SqpApplication::setPlotsCursorMode(SqpApplication::PlotsCursorMode mode)
+            {
+                impl->m_PlotCursorMode = mode;
+            }

0

gui/src/Visualization/VisualizationDragDropContainer.cpp +2 -1

             #include "Visualization/VisualizationDragDropContainer.h"
             #include "DragAndDrop/DragDropHelper.h"
             #include "SqpApplication.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include "Common/VisualizationDef.h"
             #include <QDrag>
             #include <QDragEnterEvent>
             #include <QVBoxLayout>
             #include <cmath>
             #include <memory>
             Q_LOGGING_CATEGORY(LOG_VisualizationDragDropContainer, "VisualizationDragDropContainer")
             auto DRAGGED_MINIATURE_WIDTH = 200; // in pixels
             struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
                 QVBoxLayout *m_Layout;
                 QHash<QString, VisualizationDragDropContainer::DropBehavior> m_AcceptedMimeTypes;
                 QString m_PlaceHolderText;
-                DragDropHelper::PlaceHolderType m_PlaceHolderType = DragDropHelper::PlaceHolderType::Graph;
+                DragDropHelper::PlaceHolderType m_PlaceHolderType;
                 VisualizationDragDropContainer::AcceptMimeDataFunction m_AcceptMimeDataFun
                     = [](auto mimeData) { return true; };
                 int m_MinContainerHeight = 0;
                 explicit VisualizationDragDropContainerPrivate(QWidget *widget)
+                        : m_PlaceHolderType(DragDropHelper::PlaceHolderType::Graph)
                 {
                     m_Layout = new QVBoxLayout(widget);
                     m_Layout->setContentsMargins(0, 0, 0, 0);
                 }
                 bool acceptMimeData(const QMimeData *data) const
                 {
                     auto accepted = false;
                     for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
                          ++it) {
                         const auto &type = it.key();
                         const auto &behavior = it.value();
                         if (data->hasFormat(type)) {
                             if (behavior != DropBehavior::Forbidden) {
                                 accepted = true;
                             }
                             else {
                                 accepted = false;
                                 break;
                             }
                         }
                     }
                     if (accepted) {
                         accepted = m_AcceptMimeDataFun(data);
                     }
                     return accepted;
                 }
                 bool allowMergeForMimeData(const QMimeData *data) const
                 {
                     auto result = false;
                     for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
                          ++it) {
                         if (data->hasFormat(it.key())
                             && (it.value() == VisualizationDragDropContainer::DropBehavior::Merged
                                 || it.value()
                                        == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged)) {
                             result = true;
                         }
                         else if (data->hasFormat(it.key())
                                  && it.value() == VisualizationDragDropContainer::DropBehavior::Inserted) {
                             // Merge is forbidden if the mime data contain an acceptable type which cannot be
                             // merged
                             result = false;
                             break;
                         }
                     }
                     return result;
                 }
                 bool allowInsertForMimeData(const QMimeData *data) const
                 {
                     for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
                          ++it) {
                         if (data->hasFormat(it.key())
                             && (it.value() == VisualizationDragDropContainer::DropBehavior::Inserted
                                 || it.value()
                                        == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged)) {
                             return true;
                         }
                     }
                     return false;
                 }
                 bool hasPlaceHolder() const
                 {
                     return sqpApp->dragDropHelper().placeHolder().parentWidget() == m_Layout->parentWidget();
                 }
                 VisualizationDragWidget *getChildDragWidgetAt(const QWidget *parent, const QPoint &pos) const
                 {
                     VisualizationDragWidget *dragWidget = nullptr;
                     for (auto child : parent->children()) {
                         auto widget = qobject_cast<VisualizationDragWidget *>(child);
                         if (widget && widget->isVisible()) {
                             if (widget->frameGeometry().contains(pos)) {
                                 dragWidget = widget;
                                 break;
                             }
                         }
                     }
                     return dragWidget;
                 }
                 bool cursorIsInContainer(QWidget *container) const
                 {
                     auto widgetUnderMouse = sqpApp->widgetAt(QCursor::pos());
                     return container->isAncestorOf(widgetUnderMouse) && widgetUnderMouse != container
                            && sqpApp->dragDropHelper().placeHolder().isAncestorOf(widgetUnderMouse);
                 }
                 int countDragWidget(const QWidget *parent, bool onlyVisible = false) const
                 {
                     auto nbGraph = 0;
                     for (auto child : parent->children()) {
                         if (qobject_cast<VisualizationDragWidget *>(child)) {
                             if (!onlyVisible || qobject_cast<VisualizationDragWidget *>(child)->isVisible()) {
                                 nbGraph += 1;
                             }
                         }
                     }
                     return nbGraph;
                 }
                 void findPlaceHolderPosition(const QPoint &pos, bool canInsert, bool canMerge,
                                              const VisualizationDragDropContainer *container);
             };
             VisualizationDragDropContainer::VisualizationDragDropContainer(QWidget *parent)
                     : QFrame{parent},
                       impl{spimpl::make_unique_impl<VisualizationDragDropContainerPrivate>(this)}
             {
                 setAcceptDrops(true);
             }
             void VisualizationDragDropContainer::addDragWidget(VisualizationDragWidget *dragWidget)
             {
                 impl->m_Layout->addWidget(dragWidget);
                 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
                 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
                         &VisualizationDragDropContainer::startDrag);
             }
             void VisualizationDragDropContainer::insertDragWidget(int index,
                                                                   VisualizationDragWidget *dragWidget)
             {
                 impl->m_Layout->insertWidget(index, dragWidget);
                 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
                 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
                         &VisualizationDragDropContainer::startDrag);
             }
             void VisualizationDragDropContainer::setMimeType(
                 const QString &mimeType, VisualizationDragDropContainer::DropBehavior behavior)
             {
                 impl->m_AcceptedMimeTypes[mimeType] = behavior;
             }
             int VisualizationDragDropContainer::countDragWidget() const
             {
                 return impl->countDragWidget(this);
             }
             void VisualizationDragDropContainer::setAcceptMimeDataFunction(
                 VisualizationDragDropContainer::AcceptMimeDataFunction fun)
             {
                 impl->m_AcceptMimeDataFun = fun;
             }
             void VisualizationDragDropContainer::setPlaceHolderType(DragDropHelper::PlaceHolderType type,
                                                                     const QString &placeHolderText)
             {
                 impl->m_PlaceHolderType = type;
                 impl->m_PlaceHolderText = placeHolderText;
             }
             void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidget,
                                                            const QPoint &dragPosition)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 helper.resetDragAndDrop();
                 // Note: The management of the drag object is done by Qt
                 auto drag = new QDrag{dragWidget};
                 auto mimeData = dragWidget->mimeData();
                 drag->setMimeData(mimeData);
                 auto pixmap = QPixmap(dragWidget->size());
                 dragWidget->render(&pixmap);
                 drag->setPixmap(pixmap.scaled(DRAGGED_MINIATURE_WIDTH, DRAGGED_MINIATURE_WIDTH,
                                               Qt::KeepAspectRatio, Qt::SmoothTransformation));
                 auto image = pixmap.toImage();
                 mimeData->setImageData(image);
                 mimeData->setUrls({helper.imageTemporaryUrl(image)});
                 if (impl->m_Layout->indexOf(dragWidget) >= 0) {
                     helper.setCurrentDragWidget(dragWidget);
                     if (impl->cursorIsInContainer(this)) {
                         auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
                         helper.insertPlaceHolder(impl->m_Layout, dragWidgetIndex, impl->m_PlaceHolderType,
                                                  impl->m_PlaceHolderText);
                         dragWidget->setVisible(false);
                     }
                     else {
                         // The drag starts directly outside the drop zone
                         // do not add the placeHolder
                     }
                     drag->exec(Qt::MoveAction | Qt::CopyAction, Qt::MoveAction);
                     helper.doCloseWidgets();
                 }
                 else {
                     qCWarning(LOG_VisualizationDragDropContainer())
                         << tr("VisualizationDragDropContainer::startDrag, drag aborted, the specified "
                               "VisualizationDragWidget is not found in this container.");
                 }
             }
             void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
             {
                 if (impl->acceptMimeData(event->mimeData())) {
                     event->acceptProposedAction();
                     auto &helper = sqpApp->dragDropHelper();
                     if (!impl->hasPlaceHolder()) {
                         auto dragWidget = helper.getCurrentDragWidget();
                         if (dragWidget) {
                             // If the drag&drop is internal to the visualization, entering the container hide
                             // the dragWidget which was made visible by the dragLeaveEvent
                             auto parentWidget
                                 = qobject_cast<VisualizationDragDropContainer *>(dragWidget->parentWidget());
                             if (parentWidget) {
                                 dragWidget->setVisible(false);
                             }
                         }
                         auto canMerge = impl->allowMergeForMimeData(event->mimeData());
                         auto canInsert = impl->allowInsertForMimeData(event->mimeData());
                         impl->findPlaceHolderPosition(event->pos(), canInsert, canMerge, this);
                     }
                     else {
                         // do nothing
                     }
                 }
                 else {
                     event->ignore();
                 }
                 QWidget::dragEnterEvent(event);
             }
             void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
             {
                 Q_UNUSED(event);
                 auto &helper = sqpApp->dragDropHelper();
                 if (!impl->cursorIsInContainer(this)) {
                     helper.removePlaceHolder();
                     helper.setHightlightedDragWidget(nullptr);
                     impl->m_MinContainerHeight = 0;
                     auto dragWidget = helper.getCurrentDragWidget();
                     if (dragWidget) {
                         // dragWidget has a value only if the drag is started from the visualization
                         // In that case, shows the drag widget at its original place
                         // So the drag widget doesn't stay hidden if the drop occurs outside the visualization
                         // drop zone (It is not possible to catch a drop event outside of the application)
                         if (dragWidget) {
                             dragWidget->setVisible(true);
                         }
                     }
                 }
                 else {
                     // Leave event probably received for a child widget.
                     // Do nothing.
                     // Note: The DragLeave event, doesn't have any mean to determine who sent it.
                 }
                 QWidget::dragLeaveEvent(event);
             }
             void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
             {
                 if (impl->acceptMimeData(event->mimeData())) {
                     auto canMerge = impl->allowMergeForMimeData(event->mimeData());
                     auto canInsert = impl->allowInsertForMimeData(event->mimeData());
                     impl->findPlaceHolderPosition(event->pos(), canInsert, canMerge, this);
                 }
                 else {
                     event->ignore();
                 }
                 QWidget::dragMoveEvent(event);
             }
             void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 if (impl->acceptMimeData(event->mimeData())) {
                     auto dragWidget = helper.getCurrentDragWidget();
                     if (impl->hasPlaceHolder()) {
                         // drop where the placeHolder is located
                         auto canInsert = impl->allowInsertForMimeData(event->mimeData());
                         if (canInsert) {
                             auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
                             if (dragWidget) {
                                 auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
                                 if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
                                     // Correction of the index if the drop occurs in the same container
                                     // and if the drag is started from the visualization (in that case, the
                                     // dragWidget is hidden)
                                     droppedIndex -= 1;
                                 }
                                 dragWidget->setVisible(true);
                             }
                             event->acceptProposedAction();
                             helper.removePlaceHolder();
                             emit dropOccuredInContainer(droppedIndex, event->mimeData());
                         }
                         else {
                             qCWarning(LOG_VisualizationDragDropContainer()) << tr(
                                 "VisualizationDragDropContainer::dropEvent, dropping on the placeHolder, but "
                                 "the insertion is forbidden.");
                             Q_ASSERT(false);
                         }
                     }
                     else if (helper.getHightlightedDragWidget()) {
                         // drop on the highlighted widget
                         auto canMerge = impl->allowMergeForMimeData(event->mimeData());
                         if (canMerge) {
                             event->acceptProposedAction();
                             emit dropOccuredOnWidget(helper.getHightlightedDragWidget(), event->mimeData());
                         }
                         else {
                             qCWarning(LOG_VisualizationDragDropContainer())
                                 << tr("VisualizationDragDropContainer::dropEvent, dropping on a widget, but "
                                       "the merge is forbidden.");
                             Q_ASSERT(false);
                         }
                     }
                 }
                 else {
                     event->ignore();
                 }
                 sqpApp->dragDropHelper().setHightlightedDragWidget(nullptr);
                 impl->m_MinContainerHeight = 0;
                 QWidget::dropEvent(event);
             }
             void VisualizationDragDropContainer::VisualizationDragDropContainerPrivate::findPlaceHolderPosition(
                 const QPoint &pos, bool canInsert, bool canMerge,
                 const VisualizationDragDropContainer *container)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 auto absPos = container->mapToGlobal(pos);
                 auto isOnPlaceHolder = helper.placeHolder().isAncestorOf(sqpApp->widgetAt(absPos));
                 if (countDragWidget(container, true) == 0) {
                     // Drop on an empty container, just add the placeHolder at the top
                     helper.insertPlaceHolder(m_Layout, 0, m_PlaceHolderType, m_PlaceHolderText);
                 }
                 else if (!isOnPlaceHolder) {
                     auto nbDragWidget = countDragWidget(container);
                     if (nbDragWidget > 0) {
                         if (m_MinContainerHeight == 0) {
                             m_MinContainerHeight = container->size().height();
                         }
                         m_MinContainerHeight = qMin(m_MinContainerHeight, container->size().height());
                         auto graphHeight = qMax(m_MinContainerHeight / nbDragWidget, GRAPH_MINIMUM_HEIGHT);
                         auto posY = pos.y();
                         auto dropIndex = floor(posY / graphHeight);
                         auto zoneSize = qMin(graphHeight / 4.0, 75.0);
                         auto isOnTop = posY < dropIndex * graphHeight + zoneSize;
                         auto isOnBottom = posY > (dropIndex + 1) * graphHeight - zoneSize;
                         auto placeHolderIndex = m_Layout->indexOf(&(helper.placeHolder()));
                         auto dragWidgetHovered = getChildDragWidgetAt(container, pos);
                         if (canInsert && (isOnTop || isOnBottom || !canMerge)) {
                             if (isOnBottom) {
                                 dropIndex += 1;
                             }
                             if (helper.getCurrentDragWidget()) {
                                 auto dragWidgetIndex = m_Layout->indexOf(helper.getCurrentDragWidget());
                                 if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
                                     // Correction of the index if the drop occurs in the same container
                                     // and if the drag is started from the visualization (in that case, the
                                     // dragWidget is hidden)
                                     dropIndex += 1;
                                 }
                             }
                             if (dropIndex != placeHolderIndex) {
                                 helper.insertPlaceHolder(m_Layout, dropIndex, m_PlaceHolderType,
                                                          m_PlaceHolderText);
                             }
                             helper.setHightlightedDragWidget(nullptr);
                         }
                         else if (canMerge && dragWidgetHovered) {
                             // drop on the middle -> merge
                             if (hasPlaceHolder()) {
                                 helper.removePlaceHolder();
                             }
                             helper.setHightlightedDragWidget(dragWidgetHovered);
                         }
                         else {
                             qCWarning(LOG_VisualizationDragDropContainer())
                                 << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no valid drop "
                                       "action.");
                         }
                     }
                     else {
                         qCWarning(LOG_VisualizationDragDropContainer())
                             << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no widget "
                                   "found in the "
                                   "container");
                     }
                 }
                 else {
                     // the mouse is hover the placeHolder
                     // Do nothing
                 }
             }

0

gui/src/Visualization/VisualizationDragWidget.cpp +10 -8

             #include "Visualization/VisualizationDragWidget.h"
             #include "Visualization/VisualizationDragDropContainer.h"
             #include <QApplication>
             #include <QMouseEvent>
+            #include <SqpApplication.h>
             struct VisualizationDragWidget::VisualizationDragWidgetPrivate {
                 QPoint m_DragStartPosition;
                 bool m_DragStartPositionValid = false;
                 explicit VisualizationDragWidgetPrivate() {}
             };
             VisualizationDragWidget::VisualizationDragWidget(QWidget *parent)
                     : QWidget{parent}, impl{spimpl::make_unique_impl<VisualizationDragWidgetPrivate>()}
             {
             }
             void VisualizationDragWidget::mousePressEvent(QMouseEvent *event)
             {
                 if (event->button() == Qt::LeftButton) {
                     impl->m_DragStartPosition = event->pos();
                 }
                 impl->m_DragStartPositionValid = isDragAllowed();
                 QWidget::mousePressEvent(event);
             }
             void VisualizationDragWidget::mouseMoveEvent(QMouseEvent *event)
             {
                 if (!impl->m_DragStartPositionValid || !isDragAllowed()) {
                     return;
                 }
                 if (!(event->buttons() & Qt::LeftButton)) {
                     return;
                 }
-                if (!event->modifiers().testFlag(Qt::AltModifier)) {
+                if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::DragAndDrop
-                    return;
+                    || event->modifiers().testFlag(Qt::AltModifier)) {
-                if ((event->pos() - impl->m_DragStartPosition).manhattanLength()
+                    if ((event->pos() - impl->m_DragStartPosition).manhattanLength()
-                    < QApplication::startDragDistance()) {
+                        < QApplication::startDragDistance()) {
-                    return;
+                        return;
+                    }
-                emit dragDetected(this, impl->m_DragStartPosition);
+                    emit dragDetected(this, impl->m_DragStartPosition);
+                }
                 QWidget::mouseMoveEvent(event);
             }

0

gui/src/Visualization/VisualizationGraphWidget.cpp +210 -19

             #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/VisualizationZoneWidget.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Common/MimeTypesDef.h>
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.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::NoModifier;
+            const auto HORIZONTAL_ZOOM_MODIFIER = Qt::ControlModifier;
             /// Key pressed to enable zoom on vertical axis
-            const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
+            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}
                 {
                 }
                 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;
+                std::unique_ptr<VisualizationCursorItem> m_HorizontalCursor = nullptr;
+                std::unique_ptr<VisualizationCursorItem> m_VerticalCursor = nullptr;
+                void configureDrawingRect()
+                {
+                    if (m_DrawingRect) {
+                        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};
+                    configureDrawingRect();
+                    m_DrawingRect->topLeft->setCoords(axisPos);
+                    m_DrawingRect->bottomRight->setCoords(axisPos);
+                }
+                void removeDrawingRect(QCustomPlot &plot)
+                {
+                    if (m_DrawingRect) {
+                        plot.removeItem(m_DrawingRect); // the item is deleted by QCustomPlot
+                        m_DrawingRect = nullptr;
+                        plot.replot(QCustomPlot::rpQueuedReplot);
+                    }
+                }
+                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
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
-                ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectItems);
+                ui->widget->setInteractions(QCP::iRangeZoom | QCP::iSelectItems);
-                ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
                 // 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->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
             {
                 /// @todo : for the moment, a graph can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             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";
+                }
             }
             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::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) {
+                    impl->m_DrawingRect->bottomRight->setCoords(axisPos);
+                }
+                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";
+                }
                 VisualizationDragWidget::mouseMoveEvent(event);
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
-                auto zoomOrientations = QFlags<Qt::Orientation>{};
+                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);
-                // Lambda that enables a zoom orientation if the key modifier related to this orientation
+                    if (!isZoomX && !isZoomY) {
-                // has
+                        auto axis = plot().axisRect()->axis(QCPAxis::atBottom);
-                // been pressed
+                        auto diff = direction * (axis->range().size() * (PAN_SPEED / 100.0));
-                auto enableOrientation
-                    = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
-                          auto orientationEnabled = event->modifiers().testFlag(modifier);
-                          zoomOrientations.setFlag(orientation, orientationEnabled);
-                      };
-                enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
-                enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
-                ui->widget->axisRect()->setRangeZoom(zoomOrientations);
+                        axis->setRange(axis->range() + diff);
+                        if (plot().noAntialiasingOnDrag()) {
+                            plot().setNotAntialiasedElements(QCP::aeAll);
+                        }
+                        plot().replot(QCustomPlot::rpQueuedReplot);
+                    }
+                }
             }
             void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
             {
-                impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
+                if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::ZoomBox) {
+                    impl->startDrawingRect(event->pos(), plot());
-                plot().setInteraction(QCP::iRangeDrag, !event->modifiers().testFlag(Qt::AltModifier));
                 VisualizationDragWidget::mousePressEvent(event);
             }
             void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
             {
+                if (impl->m_DrawingRect) {
+                    auto axisX = plot().axisRect()->axis(QCPAxis::atBottom);
+                    auto axisY = plot().axisRect()->axis(QCPAxis::atLeft);
+                    auto newAxisXRange = QCPRange{impl->m_DrawingRect->topLeft->coords().x(),
+                                                  impl->m_DrawingRect->bottomRight->coords().x()};
+                    auto newAxisYRange = QCPRange{impl->m_DrawingRect->topLeft->coords().y(),
+                                                  impl->m_DrawingRect->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->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())) {
                         VisualizationGraphHelper::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()) {
                     VisualizationGraphHelper::updateData(it->second, variable->dataSeries(), range);
                 }
             }

0

gui/src/Visualization/VisualizationZoneWidget.cpp +54 -1

             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/QCustomPlotSynchronizer.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationWidget.h"
             #include "ui_VisualizationZoneWidget.h"
             #include "Common/MimeTypesDef.h"
             #include "Common/VisualizationDef.h"
             #include <Data/SqpRange.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/operations/FindVariableOperation.h>
             #include <DragAndDrop/DragDropHelper.h>
             #include <QUuid>
             #include <SqpApplication.h>
             #include <cmath>
             #include <QLayout>
             Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
             namespace {
             /// Generates a default name for a new graph, according to the number of graphs already displayed in
             /// the zone
             QString defaultGraphName(const QLayout &layout)
             {
                 auto count = 0;
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
                         count++;
                     }
                 }
                 return QObject::tr("Graph %1").arg(count + 1);
             }
             /**
              * Applies a function to all graphs of the zone represented by its layout
              * @param layout the layout that contains graphs
              * @param fun the function to apply to each graph
              */
             template <typename Fun>
             void processGraphs(QLayout &layout, Fun fun)
             {
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (auto item = layout.itemAt(i)) {
                         if (auto visualizationGraphWidget
-                            = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
+                            = qobject_cast<VisualizationGraphWidget *>(item->widget())) {
                             fun(*visualizationGraphWidget);
                         }
                     }
                 }
             }
             } // namespace
             struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
                 explicit VisualizationZoneWidgetPrivate()
                         : m_SynchronisationGroupId{QUuid::createUuid()},
                           m_Synchronizer{std::make_unique<QCustomPlotSynchronizer>()}
                 {
                 }
                 QUuid m_SynchronisationGroupId;
                 std::unique_ptr<IGraphSynchronizer> m_Synchronizer;
                 // Returns the first graph in the zone or nullptr if there is no graph inside
                 VisualizationGraphWidget *firstGraph(const VisualizationZoneWidget *zoneWidget) const
                 {
                     VisualizationGraphWidget *firstGraph = nullptr;
                     auto layout = zoneWidget->ui->dragDropContainer->layout();
                     if (layout->count() > 0) {
                         if (auto visualizationGraphWidget
                             = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                             firstGraph = visualizationGraphWidget;
                         }
                     }
                     return firstGraph;
                 }
                 void dropGraph(int index, VisualizationZoneWidget *zoneWidget);
                 void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
                                    VisualizationZoneWidget *zoneWidget);
             };
             VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
                     : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationZoneWidget},
                       impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 ui->zoneNameLabel->setText(name);
                 ui->dragDropContainer->setPlaceHolderType(DragDropHelper::PlaceHolderType::Graph);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_GRAPH,
                                                    VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setMimeType(
                     MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_TIME_RANGE,
                                                    VisualizationDragDropContainer::DropBehavior::Merged);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_ZONE,
                                                    VisualizationDragDropContainer::DropBehavior::Forbidden);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
                                                                                   ui->dragDropContainer);
                 });
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
                         &VisualizationZoneWidget::dropMimeData);
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredOnWidget, this,
                         &VisualizationZoneWidget::dropMimeDataOnGraph);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                 // Synchronisation id
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             VisualizationZoneWidget::~VisualizationZoneWidget()
             {
                 delete ui;
             }
             void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
             {
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->addDragWidget(graphWidget);
             }
             void VisualizationZoneWidget::insertGraph(int index, VisualizationGraphWidget *graphWidget)
             {
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->insertDragWidget(index, graphWidget);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
             {
                 return createGraph(variable, -1);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable,
                                                                            int index)
             {
                 auto graphWidget
                     = new VisualizationGraphWidget{defaultGraphName(*ui->dragDropContainer->layout()), this};
                 // Set graph properties
                 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
                 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
                 // Lambda to synchronize zone widget
                 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &graphRange,
                                                                  const SqpRange &oldGraphRange) {
                     auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
                     auto frameLayout = ui->dragDropContainer->layout();
                     for (auto i = 0; i < frameLayout->count(); ++i) {
                         auto graphChild
                             = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
                         if (graphChild && (graphChild != graphWidget)) {
                             auto graphChildRange = graphChild->graphRange();
                             switch (zoomType) {
                                 case AcquisitionZoomType::ZoomIn: {
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                            << deltaLeft;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                            << deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::ZoomOut: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                            << deltaLeft;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                            << deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanRight: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanLeft: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     break;
                                 }
                                 case AcquisitionZoomType::Unknown: {
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type unknown");
                                     break;
                                 }
                                 default:
                                     qCCritical(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type not take into account");
                                     // No action
                                     break;
                             }
                             graphChild->enableAcquisition(false);
                             qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
                                                                    << graphChild->graphRange();
                             qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
                                                                    << graphChildRange;
                             qCDebug(LOG_VisualizationZoneWidget())
                                 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                             graphChild->setGraphRange(graphChildRange);
                             graphChild->enableAcquisition(true);
                         }
                     }
                 };
                 // connection for synchronization
                 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
                 connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
                         &VisualizationZoneWidget::onVariableAdded);
                 connect(graphWidget, &VisualizationGraphWidget::variableAboutToBeRemoved, this,
                         &VisualizationZoneWidget::onVariableAboutToBeRemoved);
                 auto range = SqpRange{};
                 if (auto firstGraph = impl->firstGraph(this)) {
                     // Case of a new graph in a existant zone
                     range = firstGraph->graphRange();
                 }
                 else {
                     // Case of a new graph as the first of the zone
                     range = variable->range();
                 }
                 this->insertGraph(index, graphWidget);
                 graphWidget->addVariable(variable, range);
                 graphWidget->setYRange(variable);
                 return graphWidget;
             }
             VisualizationGraphWidget *
             VisualizationZoneWidget::createGraph(const QList<std::shared_ptr<Variable> > variables, int index)
             {
                 if (variables.isEmpty()) {
                     return nullptr;
                 }
                 auto graphWidget = createGraph(variables.first(), index);
                 for (auto variableIt = variables.cbegin() + 1; variableIt != variables.cend(); ++variableIt) {
                     graphWidget->addVariable(*variableIt, graphWidget->graphRange());
                 }
                 return graphWidget;
             }
             void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to graph children: widgets different from graphs are not visited (no
                     // action)
                     processGraphs(
                         *ui->dragDropContainer->layout(),
                         [visitor](VisualizationGraphWidget &graphWidget) { graphWidget.accept(visitor); });
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationZoneWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationZoneWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationZoneWidget::name() const
             {
                 return ui->zoneNameLabel->text();
             }
             QMimeData *VisualizationZoneWidget::mimeData() const
             {
                 auto mimeData = new QMimeData;
                 mimeData->setData(MIME_TYPE_ZONE, QByteArray{});
                 if (auto firstGraph = impl->firstGraph(this)) {
                     auto timeRangeData = TimeController::mimeDataForTimeRange(firstGraph->graphRange());
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
                 }
                 return mimeData;
             }
             bool VisualizationZoneWidget::isDragAllowed() const
             {
                 return true;
             }
+            void VisualizationZoneWidget::notifyMouseMoveInGraph(const QPointF &graphPosition,
+                                                                 const QPointF &plotPosition,
+                                                                 VisualizationGraphWidget *graphWidget)
+            {
+                processGraphs(*ui->dragDropContainer->layout(), [&graphPosition, &plotPosition, &graphWidget](
+                                                                    VisualizationGraphWidget &processedGraph) {
+                    switch (sqpApp->plotsCursorMode()) {
+                        case SqpApplication::PlotsCursorMode::Vertical:
+                            processedGraph.removeHorizontalCursor();
+                            processedGraph.addVerticalCursorAtViewportPosition(graphPosition.x());
+                            break;
+                        case SqpApplication::PlotsCursorMode::Temporal:
+                            processedGraph.addVerticalCursor(plotPosition.x());
+                            processedGraph.removeHorizontalCursor();
+                            break;
+                        case SqpApplication::PlotsCursorMode::Horizontal:
+                            processedGraph.removeVerticalCursor();
+                            if (&processedGraph == graphWidget) {
+                                processedGraph.addHorizontalCursorAtViewportPosition(graphPosition.y());
+                            }
+                            else {
+                                processedGraph.removeHorizontalCursor();
+                            }
+                            break;
+                        case SqpApplication::PlotsCursorMode::Cross:
+                            if (&processedGraph == graphWidget) {
+                                processedGraph.addVerticalCursorAtViewportPosition(graphPosition.x());
+                                processedGraph.addHorizontalCursorAtViewportPosition(graphPosition.y());
+                            }
+                            else {
+                                processedGraph.removeHorizontalCursor();
+                                processedGraph.removeVerticalCursor();
+                            }
+                            break;
+                        case SqpApplication::PlotsCursorMode::NoCursor:
+                            processedGraph.removeHorizontalCursor();
+                            processedGraph.removeVerticalCursor();
+                            break;
+                    }
+                });
+            }
+            void VisualizationZoneWidget::notifyMouseLeaveGraph(VisualizationGraphWidget *graphWidget)
+            {
+                processGraphs(*ui->dragDropContainer->layout(), [](VisualizationGraphWidget &processedGraph) {
+                    processedGraph.removeHorizontalCursor();
+                    processedGraph.removeVerticalCursor();
+                });
+            }
             void VisualizationZoneWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes graphs in the zone
                 processGraphs(*ui->dragDropContainer->layout(),
                               [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
                 // Delete synchronization group from variable controller
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onRemoveSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
                 QWidget::closeEvent(event);
             }
             void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
                                           Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "desynchronize", Qt::QueuedConnection,
                                           Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::dropMimeData(int index, const QMimeData *mimeData)
             {
                 if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
                     impl->dropGraph(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     impl->dropVariables(variables, index, this);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeData, unknown MIME data received.");
                 }
             }
             void VisualizationZoneWidget::dropMimeDataOnGraph(VisualizationDragWidget *dragWidget,
                                                               const QMimeData *mimeData)
             {
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(dragWidget);
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeDataOnGraph, dropping in an unknown widget, "
                               "drop aborted");
                     Q_ASSERT(false);
                     return;
                 }
                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     for (const auto &var : variables) {
                         graphWidget->addVariable(var, graphWidget->graphRange());
                     }
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_TIME_RANGE)) {
                     auto range = TimeController::timeRangeForMimeData(mimeData->data(MIME_TYPE_TIME_RANGE));
                     graphWidget->setGraphRange(range);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeDataOnGraph, unknown MIME data received.");
                 }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropGraph(
                 int index, VisualizationZoneWidget *zoneWidget)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the dropped graph is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the parent container of "
                               "the dropped graph is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 const auto &variables = graphWidget->variables();
                 if (parentDragDropContainer != zoneWidget->ui->dragDropContainer && !variables.isEmpty()) {
                     // The drop didn't occur in the same zone
                     // Abort the requests for the variables (if any)
                     // Commented, because it's not sure if it's needed or not
                     // for (const auto& var : variables)
                     //{
                     //    sqpApp->variableController().onAbortProgressRequested(var);
                     //}
                     auto previousParentZoneWidget = graphWidget->parentZoneWidget();
                     auto nbGraph = parentDragDropContainer->countDragWidget();
                     if (nbGraph == 1) {
                         // This is the only graph in the previous zone, close the zone
                         helper.delayedCloseWidget(previousParentZoneWidget);
                     }
                     else {
                         // Close the graph
                         helper.delayedCloseWidget(graphWidget);
                     }
                     // Creates the new graph in the zone
                     zoneWidget->createGraph(variables, index);
                 }
                 else {
                     // The drop occurred in the same zone or the graph is empty
                     // Simple move of the graph, no variable operation associated
                     parentDragDropContainer->layout()->removeWidget(graphWidget);
                     if (variables.isEmpty() && parentDragDropContainer != zoneWidget->ui->dragDropContainer) {
                         // The graph is empty and dropped in a different zone.
                         // Take the range of the first graph in the zone (if existing).
                         auto layout = zoneWidget->ui->dragDropContainer->layout();
                         if (layout->count() > 0) {
                             if (auto visualizationGraphWidget
                                 = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                                 graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
                             }
                         }
                     }
                     zoneWidget->ui->dragDropContainer->insertDragWidget(index, graphWidget);
                 }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropVariables(
                 const QList<std::shared_ptr<Variable> > &variables, int index,
                 VisualizationZoneWidget *zoneWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
                 if (variables.count() > 1) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropVariables, dropping multiple variables, operation "
                               "aborted.");
                     return;
                 }
                 zoneWidget->createGraph(variables, index);
             }

General Comments 1

trabillard

|

Auto status change to "Under Review"

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