HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r957:e2eaf1b200e7

Toolbar for interactions modes

trabillard -

r957:e2eaf1b200e7

parent child

Context file:

r957:e2eaf1b200e7

Collapse all files

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

NO CONTENT: new file 100644, binary diff hidden

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

NO CONTENT: new file 100644, binary diff hidden

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

NO CONTENT: new file 100644, binary diff hidden

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

NO CONTENT: new file 100644, binary diff hidden

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

NO CONTENT: new file 100644, binary diff hidden

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;
                 }
             }

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

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

NO CONTENT: modified file, binary diff hidden

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>

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_NetworkController{std::make_unique<NetworkController>()},
                           m_TimeController{std::make_unique<TimeController>()},
                           m_VariableController{std::make_unique<VariableController>()},
                           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;
+            }

General Comments 0

Write
Preview

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

No TODOs yet

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

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