GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r311:c155354de1ae

Merge branch 'feature/VariableDeletion' into develop

Alexandre Leroux -

r311:c155354de1ae

parent child

Context file:

r311:c155354de1ae

Expand all files

gui/include/Visualization/operations/RemoveVariableOperation.h created 644 +41 0

@@ -0,0 +1,41
	1	#ifndef SCIQLOP_REMOVEVARIABLEOPERATION_H
	2	#define SCIQLOP_REMOVEVARIABLEOPERATION_H
	3
	4	#include "Visualization/IVisualizationWidgetVisitor.h"
	5
	6	#include <Common/spimpl.h>
	7
	8	#include <QLoggingCategory>
	9
	10	#include <memory>
	11
	12	class Variable;
	13
	14	Q_DECLARE_LOGGING_CATEGORY(LOG_RemoveVariableOperation)
	15
	16	/**
	17	* @brief The RemoveVariableOperation class defines an operation that traverses all of visualization
	18	* widgets to remove a variable if they contain it
	19	*/
	20	class RemoveVariableOperation : public IVisualizationWidgetVisitor {
	21	public:
	22	/**
	23	* Ctor
	24	* @param variable the variable to remove from widgets
	25	*/
	26	explicit RemoveVariableOperation(std::shared_ptr<Variable> variable);
	27
	28	void visitEnter(VisualizationWidget *widget) override final;
	29	void visitLeave(VisualizationWidget *widget) override final;
	30	void visitEnter(VisualizationTabWidget *tabWidget) override final;
	31	void visitLeave(VisualizationTabWidget *tabWidget) override final;
	32	void visitEnter(VisualizationZoneWidget *zoneWidget) override final;
	33	void visitLeave(VisualizationZoneWidget *zoneWidget) override final;
	34	void visit(VisualizationGraphWidget *graphWidget) override final;
	35
	36	private:
	37	class RemoveVariableOperationPrivate;
	38	spimpl::unique_impl_ptr<RemoveVariableOperationPrivate> impl;
	39	};
	40
	41	#endif // SCIQLOP_REMOVEVARIABLEOPERATION_H

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

NO CONTENT: new file 100644, binary diff hidden

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

NO CONTENT: new file 100644, binary diff hidden

gui/src/Visualization/operations/RemoveVariableOperation.cpp created 644 +70 0

@@ -0,0 +1,70
	1	#include "Visualization/operations/RemoveVariableOperation.h"
	2	#include "Visualization/VisualizationGraphWidget.h"
	3
	4	#include <Variable/Variable.h>
	5
	6	Q_LOGGING_CATEGORY(LOG_RemoveVariableOperation, "RemoveVariableOperation")
	7
	8	struct RemoveVariableOperation::RemoveVariableOperationPrivate {
	9	explicit RemoveVariableOperationPrivate(std::shared_ptr<Variable> variable)
	10	: m_Variable(variable)
	11	{
	12	}
	13
	14	std::shared_ptr<Variable> m_Variable;
	15	};
	16
	17	RemoveVariableOperation::RemoveVariableOperation(std::shared_ptr<Variable> variable)
	18	: impl{spimpl::make_unique_impl<RemoveVariableOperationPrivate>(variable)}
	19	{
	20	}
	21
	22	void RemoveVariableOperation::visitEnter(VisualizationWidget *widget)
	23	{
	24	// VisualizationWidget is not intended to contain a variable
	25	Q_UNUSED(widget)
	26	}
	27
	28	void RemoveVariableOperation::visitLeave(VisualizationWidget *widget)
	29	{
	30	// VisualizationWidget is not intended to contain a variable
	31	Q_UNUSED(widget)
	32	}
	33
	34	void RemoveVariableOperation::visitEnter(VisualizationTabWidget *tabWidget)
	35	{
	36	// VisualizationTabWidget is not intended to contain a variable
	37	Q_UNUSED(tabWidget)
	38	}
	39
	40	void RemoveVariableOperation::visitLeave(VisualizationTabWidget *tabWidget)
	41	{
	42	// VisualizationTabWidget is not intended to contain a variable
	43	Q_UNUSED(tabWidget)
	44	}
	45
	46	void RemoveVariableOperation::visitEnter(VisualizationZoneWidget *zoneWidget)
	47	{
	48	// VisualizationZoneWidget is not intended to contain a variable
	49	Q_UNUSED(zoneWidget)
	50	}
	51
	52	void RemoveVariableOperation::visitLeave(VisualizationZoneWidget *zoneWidget)
	53	{
	54	// VisualizationZoneWidget is not intended to contain a variable
	55	Q_UNUSED(zoneWidget)
	56	}
	57
	58	void RemoveVariableOperation::visit(VisualizationGraphWidget *graphWidget)
	59	{
	60	if (graphWidget) {
	61	// If the widget contains the variable, removes it
	62	if (impl->m_Variable && graphWidget->contains(*impl->m_Variable)) {
	63	graphWidget->removeVariable(impl->m_Variable);
	64	}
	65	}
	66	else {
	67	qCCritical(LOG_RemoveVariableOperation(),
	68	"Can't visit VisualizationGraphWidget : the widget is null");
	69	}
	70	}

app/src/MainWindow.cpp +8 -2

             /*------------------------------------------------------------------------------
             -- 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 <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 <QDateTime>
             #include <QDir>
             #include <QFileDialog>
             #include <QToolBar>
             #include <QToolButton>
             #include <memory.h>
             //#include <omp.h>
             //#include <network/filedownloader.h>
             //#include <qlopdatabase.h>
             //#include <qlopsettings.h>
             //#include <qlopgui.h>
             //#include <spacedata.h>
             //#include "qlopcore.h"
             //#include "qlopcodecmanager.h"
             //#include "cdfcodec.h"
             //#include "amdatxtcodec.h"
             //#include <qlopplotmanager.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:
                 QSize m_LastOpenLeftInspectorSize;
                 QSize m_LastOpenRightInspectorSize;
             };
             MainWindow::MainWindow(QWidget *parent)
                     : QMainWindow{parent},
                       m_Ui{new Ui::MainWindow},
                       impl{spimpl::make_unique_impl<MainWindowPrivate>()}
             {
                 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);
                         });
                 this->menuBar()->addAction(tr("File"));
                 auto mainToolBar = this->addToolBar(QStringLiteral("MainToolBar"));
                 auto timeWidget = new TimeWidget{};
                 mainToolBar->addWidget(timeWidget);
+                // Controllers / controllers connections
+                connect(&sqpApp->timeController(), SIGNAL(timeUpdated(SqpDateTime)),
+                        &sqpApp->variableController(), SLOT(onDateTimeOnSelection(SqpDateTime)));
                 // Widgets / controllers connections
                 // DataSource
                 connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem *)),
                         m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem *)));
                 // Time
                 connect(timeWidget, SIGNAL(timeUpdated(SqpDateTime)), &sqpApp->timeController(),
                         SLOT(onTimeToUpdate(SqpDateTime)));
-                connect(&sqpApp->timeController(), SIGNAL(timeUpdated(SqpDateTime)),
+                // Visualization
-                        &sqpApp->variableController(), SLOT(onDateTimeOnSelection(SqpDateTime)));
+                connect(&sqpApp->visualizationController(),
+                        SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), m_Ui->view,
+                        SLOT(onVariableAboutToBeDeleted(std::shared_ptr<Variable>)));
                 // 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);
                 /*    QLopGUI::registerMenuBar(menuBar());
                     this->setWindowIcon(QIcon(":/sciqlopLOGO.svg"));
                     this->m_progressWidget = new QWidget();
                     this->m_progressLayout = new QVBoxLayout(this->m_progressWidget);
                     this->m_progressWidget->setLayout(this->m_progressLayout);
                     this->m_progressWidget->setWindowModality(Qt::WindowModal);
                     m_progressThreadIds = (int*) malloc(OMP_THREADS*sizeof(int));
                     for(int i=0;i<OMP_THREADS;i++)
                     {
                         this->m_progress.append(new QProgressBar(this->m_progressWidget));
                         this->m_progress.last()->setMinimum(0);
                         this->m_progress.last()->setMaximum(100);
                         this->m_progressLayout->addWidget(this->m_progress.last());
                         this->m_progressWidget->hide();
                         this->m_progressThreadIds[i] = -1;
                     }
                     this->m_progressWidget->setWindowTitle("Loading File");
                     const QList<QLopService*>ServicesToLoad=QList<QLopService*>()
                             << QLopCore::self()
                             << QLopPlotManager::self()
                             << QLopCodecManager::self()
                             << FileDownloader::self()
                             << QLopDataBase::self()
                             << SpaceData::self();
                     CDFCodec::registerToManager();
                     AMDATXTCodec::registerToManager();
                     for(int i=0;i<ServicesToLoad.count();i++)
                     {
                         qDebug()<<ServicesToLoad.at(i)->serviceName();
                         ServicesToLoad.at(i)->initialize(); //must be called before getGUI
                         QDockWidget* wdgt=ServicesToLoad.at(i)->getGUI();
                         if(wdgt)
                         {
                             wdgt->setAllowedAreas(Qt::AllDockWidgetAreas);
                             this->addDockWidget(Qt::TopDockWidgetArea,wdgt);
                         }
                         PythonQt::self()->getMainModule().addObject(ServicesToLoad.at(i)->serviceName(),(QObject*)ServicesToLoad.at(i));
                     }*/
             }
             MainWindow::~MainWindow()
             {
             }
             void MainWindow::changeEvent(QEvent *e)
             {
                 QMainWindow::changeEvent(e);
                 switch (e->type()) {
                     case QEvent::LanguageChange:
                         m_Ui->retranslateUi(this);
                         break;
                     default:
                         break;
                 }
             }

core/include/Variable/VariableCacheController.h +6 0

             #ifndef SCIQLOP_VARIABLECACHECONTROLLER_H
             #define SCIQLOP_VARIABLECACHECONTROLLER_H
+            #include <QLoggingCategory>
             #include <QObject>
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <Common/spimpl.h>
+            Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheController)
             class Variable;
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheController)
             /// This class aims to store in the cache all of the dateTime already requested to the variable.
             class VariableCacheController : public QObject {
                 Q_OBJECT
             public:
                 explicit VariableCacheController(QObject *parent = 0);
                 void addDateTime(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
+                /// Clears cache concerning a variable
+                void clear(std::shared_ptr<Variable> variable) noexcept;
                 /// Return all of the SqpDataTime part of the dateTime whose are not in the cache
                 QVector<SqpDateTime> provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
                                                                    const SqpDateTime &dateTime);
                 QVector<SqpDateTime> dateCacheList(std::shared_ptr<Variable> variable) const noexcept;
                 void displayCache(std::shared_ptr<Variable> variable) const;
             private:
                 class VariableCacheControllerPrivate;
                 spimpl::unique_impl_ptr<VariableCacheControllerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLECACHECONTROLLER_H

core/include/Variable/VariableController.h +21 0

             #ifndef SCIQLOP_VARIABLECONTROLLER_H
             #define SCIQLOP_VARIABLECONTROLLER_H
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
             class IDataProvider;
             class QItemSelectionModel;
             class TimeController;
             class Variable;
             class VariableModel;
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
             /**
              * @brief The VariableController class aims to handle the variables in SciQlop.
              */
             class VariableController : public QObject {
                 Q_OBJECT
             public:
                 explicit VariableController(QObject *parent = 0);
                 virtual ~VariableController();
                 VariableModel *variableModel() noexcept;
                 QItemSelectionModel *variableSelectionModel() noexcept;
                 void setTimeController(TimeController *timeController) noexcept;
+                /**
+                 * Deletes from the controller the variable passed in parameter.
+                 *
+                 * Delete a variable includes:
+                 * - the deletion of the various references to the variable in SciQlop
+                 * - the deletion of the model variable
+                 * - the deletion of the provider associated with the variable
+                 * - removing the cache associated with the variable
+                 *
+                 * @param variable the variable to delete from the controller.
+                 */
+                void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
+                /**
+                 * Deletes from the controller the variables passed in parameter.
+                 * @param variables the variables to delete from the controller.
+                 * @sa deleteVariable()
+                 */
+                void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
             signals:
+                /// Signal emitted when a variable is about to be deleted from the controller
+                void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
                 /// Signal emitted when a variable has been created
                 void variableCreated(std::shared_ptr<Variable> variable);
             public slots:
                 /// Request the data loading of the variable whithin dateTime
                 void onRequestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
                 /**
                  * Creates a new variable and adds it to the model
                  * @param name the name of the new variable
                  * @param provider the data provider for the new variable
                  */
                 void createVariable(const QString &name, std::shared_ptr<IDataProvider> provider) noexcept;
                 /// Update the temporal parameters of every selected variable to dateTime
                 void onDateTimeOnSelection(const SqpDateTime &dateTime);
                 void initialize();
                 void finalize();
             private:
                 void waitForFinish();
                 class VariableControllerPrivate;
                 spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLECONTROLLER_H

core/include/Variable/VariableModel.h +6 0

             #ifndef SCIQLOP_VARIABLEMODEL_H
             #define SCIQLOP_VARIABLEMODEL_H
             #include <Data/SqpDateTime.h>
             #include <QAbstractTableModel>
             #include <QLoggingCategory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableModel)
             class IDataSeries;
             class Variable;
             /**
              * @brief The VariableModel class aims to hold the variables that have been created in SciQlop
              */
             class VariableModel : public QAbstractTableModel {
             public:
                 explicit VariableModel(QObject *parent = nullptr);
                 /**
                  * Creates a new variable in the model
                  * @param name the name of the new variable
                  * @param dateTime the dateTime of the new variable
                  * @return the pointer to the new variable
                  */
                 std::shared_ptr<Variable> createVariable(const QString &name,
                                                          const SqpDateTime &dateTime) noexcept;
+                /**
+                 * Deletes a variable from the model, if it exists
+                 * @param variable the variable to delete
+                 */
+                void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
                 std::shared_ptr<Variable> variable(int index) const;
                 // /////////////////////////// //
                 // QAbstractTableModel methods //
                 // /////////////////////////// //
                 virtual int columnCount(const QModelIndex &parent = QModelIndex{}) const override;
                 virtual int rowCount(const QModelIndex &parent = QModelIndex{}) const override;
                 virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
                 virtual QVariant headerData(int section, Qt::Orientation orientation,
                                             int role = Qt::DisplayRole) const override;
             private:
                 class VariableModelPrivate;
                 spimpl::unique_impl_ptr<VariableModelPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLEMODEL_H

core/include/Visualization/VisualizationController.h +2 0

             #ifndef SCIQLOP_VISUALIZATIONCONTROLLER_H
             #define SCIQLOP_VISUALIZATIONCONTROLLER_H
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationController)
             class DataSourceItem;
             class Variable;
             /**
              * @brief The VisualizationController 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 register 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 VisualizationController : public QObject {
                 Q_OBJECT
             public:
                 explicit VisualizationController(QObject *parent = 0);
                 virtual ~VisualizationController();
             signals:
+                /// Signal emitted when a variable is about to be deleted from SciQlop
+                void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
                 /// Signal emitted when a variable has been created in SciQlop
                 void variableCreated(std::shared_ptr<Variable> variable);
             public slots:
                 /// Manage init/end of the controller
                 void initialize();
                 void finalize();
             private:
                 void waitForFinish();
                 class VisualizationControllerPrivate;
                 spimpl::unique_impl_ptr<VisualizationControllerPrivate> impl;
             };
             #endif // SCIQLOP_VISUALIZATIONCONTROLLER_H

core/src/Variable/VariableCacheController.cpp +16 0

             #include "Variable/VariableCacheController.h"
             #include "Variable/Variable.h"
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableCacheController, "VariableCacheController")
             struct VariableCacheController::VariableCacheControllerPrivate {
                 std::unordered_map<std::shared_ptr<Variable>, QVector<SqpDateTime> >
                     m_VariableToSqpDateTimeListMap;
                 void addInCacheDataByEnd(const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                                          QVector<SqpDateTime> &notInCache, int cacheIndex,
                                          double currentTStart);
                 void addInCacheDataByStart(const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                                            QVector<SqpDateTime> &notInCache, int cacheIndex,
                                            double currentTStart);
                 void addDateTimeRecurse(const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                                         int cacheIndex);
             };
             VariableCacheController::VariableCacheController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableCacheControllerPrivate>()}
             {
             }
             void VariableCacheController::addDateTime(std::shared_ptr<Variable> variable,
                                                       const SqpDateTime &dateTime)
             {
                 if (variable) {
                     auto findVariableIte = impl->m_VariableToSqpDateTimeListMap.find(variable);
                     if (findVariableIte == impl->m_VariableToSqpDateTimeListMap.end()) {
                         impl->m_VariableToSqpDateTimeListMap[variable].push_back(dateTime);
                     }
                     else {
                         // addDateTime modify the list<SqpDateTime> of the variable in a way to ensure
                         // that the list is ordered : l(0) < l(1). We assume also a < b
                         // (with a & b of type SqpDateTime) means ts(b) > te(a)
                         // The algorithm will try the merge of two interval:
                         // - dateTime will be compare with the first interval of the list:
                         //   A: if it is inferior, it will be inserted and it's finished.
                         //   B: if it is in intersection, it will be merge then the merged one
                         //      will be compared to the next interval. The old one is remove from the list
                         //   C: if it is superior, we do the same with the next interval of the list
                         try {
                             impl->addDateTimeRecurse(dateTime,
                                                      impl->m_VariableToSqpDateTimeListMap.at(variable), 0);
                         }
                         catch (const std::out_of_range &e) {
                             qCWarning(LOG_VariableCacheController()) << "addDateTime" << e.what();
                         }
                     }
                 }
             }
+            void VariableCacheController::clear(std::shared_ptr<Variable> variable) noexcept
+            {
+                if (!variable) {
+                    qCCritical(LOG_VariableCacheController()) << "Can't clear variable cache: variable is null";
+                    return;
+                }
+                auto nbEntries = impl->m_VariableToSqpDateTimeListMap.erase(variable);
+                auto clearCacheMessage
+                    = (nbEntries != 0)
+                          ? tr("Variable cache cleared for variable %1").arg(variable->name())
+                          : tr("No deletion of variable cache: no cache was associated with the variable");
+                qCDebug(LOG_VariableCacheController()) << clearCacheMessage;
+            }
             QVector<SqpDateTime>
             VariableCacheController::provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
                                                                    const SqpDateTime &dateTime)
             {
                 auto notInCache = QVector<SqpDateTime>{};
                 // This algorithm is recursif. The idea is to localise the start time then the end time in the
                 // list of date time request associated to the variable
                 // We assume that the list is ordered in a way that l(0) < l(1). We assume also a < b
                 // (with a & b of type SqpDateTime) means ts(b) > te(a)
                 auto it = impl->m_VariableToSqpDateTimeListMap.find(variable);
                 if (it != impl->m_VariableToSqpDateTimeListMap.end()) {
                     impl->addInCacheDataByStart(dateTime, it->second, notInCache, 0, dateTime.m_TStart);
                 }
                 else {
                     notInCache << dateTime;
                 }
                 return notInCache;
             }
             QVector<SqpDateTime>
             VariableCacheController::dateCacheList(std::shared_ptr<Variable> variable) const noexcept
             {
                 try {
                     return impl->m_VariableToSqpDateTimeListMap.at(variable);
                 }
                 catch (const std::out_of_range &e) {
                     qCWarning(LOG_VariableCacheController()) << e.what();
                     return QVector<SqpDateTime>{};
                 }
             }
             void VariableCacheController::VariableCacheControllerPrivate::addDateTimeRecurse(
                 const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList, int cacheIndex)
             {
                 const auto dateTimeListSize = dateTimeList.count();
                 if (cacheIndex >= dateTimeListSize) {
                     dateTimeList.push_back(dateTime);
                     // there is no anymore interval to compore, we can just push_back it
                     return;
                 }
                 auto currentDateTime = dateTimeList[cacheIndex];
                 if (dateTime.m_TEnd < currentDateTime.m_TStart) {
                     // The compared one is < to current one compared, we can insert it
                     dateTimeList.insert(cacheIndex, dateTime);
                 }
                 else if (dateTime.m_TStart > currentDateTime.m_TEnd) {
                     // The compared one is > to current one compared  we can comparet if to the next one
                     addDateTimeRecurse(dateTime, dateTimeList, ++cacheIndex);
                 }
                 else {
                     // Merge cases: we need to merge the two interval, remove the old one from the list then
                     // rerun the algo from this index with the merged interval
                     auto mTStart = std::min(dateTime.m_TStart, currentDateTime.m_TStart);
                     auto mTEnd = std::max(dateTime.m_TEnd, currentDateTime.m_TEnd);
                     auto mergeDateTime = SqpDateTime{mTStart, mTEnd};
                     dateTimeList.remove(cacheIndex);
                     addDateTimeRecurse(mergeDateTime, dateTimeList, cacheIndex);
                 }
             }
             void VariableCacheController::VariableCacheControllerPrivate::addInCacheDataByEnd(
                 const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                 QVector<SqpDateTime> &notInCache, int cacheIndex, double currentTStart)
             {
                 const auto dateTimeListSize = dateTimeList.count();
                 if (cacheIndex >= dateTimeListSize) {
                     if (currentTStart < dateTime.m_TEnd) {
                         // te localised after all other interval: The last interval is [currentTsart, te]
                         notInCache.push_back(SqpDateTime{currentTStart, dateTime.m_TEnd});
                     }
                     return;
                 }
                 auto currentDateTimeJ = dateTimeList[cacheIndex];
                 if (dateTime.m_TEnd <= currentDateTimeJ.m_TStart) {
                     // te localised between to interval: The last interval is [currentTsart, te]
                     notInCache.push_back(SqpDateTime{currentTStart, dateTime.m_TEnd});
                 }
                 else {
                     notInCache.push_back(SqpDateTime{currentTStart, currentDateTimeJ.m_TStart});
                     if (dateTime.m_TEnd > currentDateTimeJ.m_TEnd) {
                         // te not localised before the current interval: we need to look at the next interval
                         addInCacheDataByEnd(dateTime, dateTimeList, notInCache, ++cacheIndex,
                                             currentDateTimeJ.m_TEnd);
                     }
                 }
             }
             void VariableCacheController::VariableCacheControllerPrivate::addInCacheDataByStart(
                 const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                 QVector<SqpDateTime> &notInCache, int cacheIndex, double currentTStart)
             {
                 const auto dateTimeListSize = dateTimeList.count();
                 if (cacheIndex >= dateTimeListSize) {
                     // ts localised after all other interval: The last interval is [ts, te]
                     notInCache.push_back(SqpDateTime{currentTStart, dateTime.m_TEnd});
                     return;
                 }
                 auto currentDateTimeI = dateTimeList[cacheIndex];
                 if (currentTStart < currentDateTimeI.m_TStart) {
                     // ts localised between to interval: let's localized te
                     addInCacheDataByEnd(dateTime, dateTimeList, notInCache, cacheIndex, currentTStart);
                 }
                 else if (currentTStart < currentDateTimeI.m_TEnd) {
                     if (dateTime.m_TEnd > currentDateTimeI.m_TEnd) {
                         // ts not localised before the current interval: we need to look at the next interval
                         // We can assume now current tstart is the last interval tend, because data between them
                         // are
                         // in the cache
                         addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex,
                                               currentDateTimeI.m_TEnd);
                     }
                 }
                 else {
                     // ts not localised before the current interval: we need to look at the next interval
                     addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex, currentTStart);
                 }
             }
             void VariableCacheController::displayCache(std::shared_ptr<Variable> variable) const
             {
                 auto variableDateTimeList = impl->m_VariableToSqpDateTimeListMap.find(variable);
                 if (variableDateTimeList != impl->m_VariableToSqpDateTimeListMap.end()) {
                     qCInfo(LOG_VariableCacheController()) << tr("VariableCacheController::displayCache")
                                                           << variableDateTimeList->second;
                 }
                 else {
                     qCWarning(LOG_VariableCacheController())
                         << tr("Cannot display a variable that is not in the cache");
                 }
             }

core/src/Variable/VariableController.cpp +32 0

             #include <Variable/Variable.h>
             #include <Variable/VariableCacheController.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
             #include <Time/TimeController.h>
             #include <QDateTime>
             #include <QMutex>
             #include <QThread>
             #include <QtCore/QItemSelectionModel>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             namespace {
             /// @todo Generates default dataseries, according to the provider passed in parameter. This method
             /// will be deleted when the timerange is recovered from SciQlop
             std::shared_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider,
                                                                    const SqpDateTime &dateTime) noexcept
             {
                 auto parameters = DataProviderParameters{dateTime};
                 return provider.retrieveData(parameters);
             }
             } // namespace
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate(VariableController *parent)
                         : m_WorkingMutex{},
                           m_VariableModel{new VariableModel{parent}},
                           m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
                           m_VariableCacheController{std::make_unique<VariableCacheController>()}
                 {
                 }
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 QItemSelectionModel *m_VariableSelectionModel;
                 TimeController *m_TimeController{nullptr};
                 std::unique_ptr<VariableCacheController> m_VariableCacheController;
                 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
                     m_VariableToProviderMap;
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                   << QThread::currentThread();
             }
             VariableController::~VariableController()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
                                                   << QThread::currentThread();
                 this->waitForFinish();
             }
             VariableModel *VariableController::variableModel() noexcept
             {
                 return impl->m_VariableModel;
             }
             QItemSelectionModel *VariableController::variableSelectionModel() noexcept
             {
                 return impl->m_VariableSelectionModel;
             }
             void VariableController::setTimeController(TimeController *timeController) noexcept
             {
                 impl->m_TimeController = timeController;
             }
+            void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
+            {
+                if (!variable) {
+                    qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
+                    return;
+                }
+                // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
+                // make some treatments before the deletion
+                emit variableAboutToBeDeleted(variable);
+                // Deletes provider
+                auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
+                qCDebug(LOG_VariableController())
+                    << tr("Number of providers deleted for variable %1: %2")
+                           .arg(variable->name(), QString::number(nbProvidersDeleted));
+                // Clears cache
+                impl->m_VariableCacheController->clear(variable);
+                // Deletes from model
+                impl->m_VariableModel->deleteVariable(variable);
+            }
+            void VariableController::deleteVariables(
+                const QVector<std::shared_ptr<Variable> > &variables) noexcept
+            {
+                for (auto variable : qAsConst(variables)) {
+                    deleteVariable(variable);
+                }
+            }
             void VariableController::createVariable(const QString &name,
                                                     std::shared_ptr<IDataProvider> provider) noexcept
             {
                 if (!impl->m_TimeController) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to create variable: The time controller is null");
                     return;
                 }
                 /// @todo : for the moment :
                 /// - the provider is only used to retrieve data from the variable for its initialization, but
                 /// it will be retained later
                 /// - default data are generated for the variable, without taking into account the timerange set
                 /// in sciqlop
                 auto dateTime = impl->m_TimeController->dateTime();
                 if (auto newVariable = impl->m_VariableModel->createVariable(name, dateTime)) {
                     // store the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
                     auto addDateTimeAcquired
                         = [this, newVariable](auto dataSeriesAcquired, auto dateTimeToPutInCache) {
                               impl->m_VariableCacheController->addDateTime(newVariable, dateTimeToPutInCache);
                               newVariable->setDataSeries(dataSeriesAcquired);
                           };
                     connect(provider.get(), &IDataProvider::dataProvided, addDateTimeAcquired);
                     this->onRequestDataLoading(newVariable, dateTime);
                     // notify the creation
                     emit variableCreated(newVariable);
                 }
             }
             void VariableController::onDateTimeOnSelection(const SqpDateTime &dateTime)
             {
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 for (const auto &selectedRow : qAsConst(selectedRows)) {
                     if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
                         selectedVariable->setDateTime(dateTime);
                         this->onRequestDataLoading(selectedVariable, dateTime);
                     }
                 }
             }
             void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
                                                           const SqpDateTime &dateTime)
             {
                 // we want to load data of the variable for the dateTime.
                 // First we check if the cache contains some of them.
                 // For the other, we ask the provider to give them.
                 if (variable) {
                     auto dateTimeListNotInCache
                         = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
                     if (!dateTimeListNotInCache.empty()) {
                         // Ask the provider for each data on the dateTimeListNotInCache
                         impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
                             std::move(dateTimeListNotInCache));
                     }
                     else {
                         emit variable->updated();
                     }
                 }
                 else {
                     qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null");
                 }
             }
             void VariableController::initialize()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableController()) << tr("VariableController init END");
             }
             void VariableController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

core/src/Variable/VariableModel.cpp +26 0

             #include <Variable/Variable.h>
             #include <Variable/VariableModel.h>
             #include <Data/IDataSeries.h>
             #include <QDateTime>
             #include <QSize>
             Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
             namespace {
             // Column indexes
             const auto NAME_COLUMN = 0;
             const auto TSTART_COLUMN = 1;
             const auto TEND_COLUMN = 2;
             const auto NB_COLUMNS = 3;
             // Column properties
             const auto DEFAULT_HEIGHT = 25;
             const auto DEFAULT_WIDTH = 100;
             struct ColumnProperties {
                 ColumnProperties(const QString &name = {}, int width = DEFAULT_WIDTH,
                                  int height = DEFAULT_HEIGHT)
                         : m_Name{name}, m_Width{width}, m_Height{height}
                 {
                 }
                 QString m_Name;
                 int m_Width;
                 int m_Height;
             };
             const auto COLUMN_PROPERTIES
                 = QHash<int, ColumnProperties>{{NAME_COLUMN, {QObject::tr("Name")}},
                                                {TSTART_COLUMN, {QObject::tr("tStart"), 180}},
                                                {TEND_COLUMN, {QObject::tr("tEnd"), 180}}};
             /// Format for datetimes
             const auto DATETIME_FORMAT = QStringLiteral("dd/MM/yyyy \nhh:mm:ss:zzz");
             } // namespace
             struct VariableModel::VariableModelPrivate {
                 /// Variables created in SciQlop
                 std::vector<std::shared_ptr<Variable> > m_Variables;
             };
             VariableModel::VariableModel(QObject *parent)
                     : QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
             {
             }
             std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
                                                                     const SqpDateTime &dateTime) noexcept
             {
                 auto insertIndex = rowCount();
                 beginInsertRows({}, insertIndex, insertIndex);
                 /// @todo For the moment, the other data of the variable is initialized with default values
                 auto variable = std::make_shared<Variable>(name, QStringLiteral("unit"),
                                                            QStringLiteral("mission"), dateTime);
                 impl->m_Variables.push_back(variable);
                 endInsertRows();
                 return variable;
             }
+            void VariableModel::deleteVariable(std::shared_ptr<Variable> variable) noexcept
+            {
+                if (!variable) {
+                    qCCritical(LOG_Variable()) << "Can't delete a null variable from the model";
+                    return;
+                }
+                // Finds variable in the model
+                auto begin = impl->m_Variables.cbegin();
+                auto end = impl->m_Variables.cend();
+                auto it = std::find(begin, end, variable);
+                if (it != end) {
+                    auto removeIndex = std::distance(begin, it);
+                    // Deletes variable
+                    beginRemoveRows({}, removeIndex, removeIndex);
+                    impl->m_Variables.erase(it);
+                    endRemoveRows();
+                }
+                else {
+                    qCritical(LOG_VariableModel())
+                        << tr("Can't delete variable %1 from the model: the variable is not in the model")
+                               .arg(variable->name());
+                }
+            }
             std::shared_ptr<Variable> VariableModel::variable(int index) const
             {
                 return (index >= 0 && index < impl->m_Variables.size()) ? impl->m_Variables[index] : nullptr;
             }
             int VariableModel::columnCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return NB_COLUMNS;
             }
             int VariableModel::rowCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return impl->m_Variables.size();
             }
             QVariant VariableModel::data(const QModelIndex &index, int role) const
             {
                 if (!index.isValid()) {
                     return QVariant{};
                 }
                 if (index.row() < 0 || index.row() >= rowCount()) {
                     return QVariant{};
                 }
                 if (role == Qt::DisplayRole) {
                     if (auto variable = impl->m_Variables.at(index.row()).get()) {
                         /// Lambda function that builds the variant to return for a time value
                         auto dateTimeVariant = [](double time) {
                             auto dateTime = QDateTime::fromMSecsSinceEpoch(time * 1000.);
                             return dateTime.toString(DATETIME_FORMAT);
                         };
                         switch (index.column()) {
                             case NAME_COLUMN:
                                 return variable->name();
                             case TSTART_COLUMN:
                                 return dateTimeVariant(variable->dateTime().m_TStart);
                             case TEND_COLUMN:
                                 return dateTimeVariant(variable->dateTime().m_TEnd);
                             default:
                                 // No action
                                 break;
                         }
                         qWarning(LOG_VariableModel())
                             << tr("Can't get data (unknown column %1)").arg(index.column());
                     }
                     else {
                         qWarning(LOG_VariableModel()) << tr("Can't get data (no variable)");
                     }
                 }
                 return QVariant{};
             }
             QVariant VariableModel::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (role != Qt::DisplayRole && role != Qt::SizeHintRole) {
                     return QVariant{};
                 }
                 if (orientation == Qt::Horizontal) {
                     auto propertiesIt = COLUMN_PROPERTIES.find(section);
                     if (propertiesIt != COLUMN_PROPERTIES.cend()) {
                         // Role is either DisplayRole or SizeHintRole
                         return (role == Qt::DisplayRole)
                                    ? QVariant{propertiesIt->m_Name}
                                    : QVariant{QSize{propertiesIt->m_Width, propertiesIt->m_Height}};
                     }
                     else {
                         qWarning(LOG_VariableModel())
                             << tr("Can't get header data (unknown column %1)").arg(section);
                     }
                 }
                 return QVariant{};
             }

gui/include/Visualization/IVariableContainer.h +3 0

             #ifndef SCIQLOP_IVARIABLECONTAINER_H
             #define SCIQLOP_IVARIABLECONTAINER_H
             class Variable;
             /**
              * @brief The IVariableContainer interface represents an UI object that can accommodate a variable
              */
             class IVariableContainer {
             public:
                 virtual ~IVariableContainer() = default;
                 /// Checks if the container can handle the variable passed in parameter
                 virtual bool canDrop(const Variable &variable) const = 0;
+                /// Checks if the container contains the variable passed in parameter
+                virtual bool contains(const Variable &variable) const = 0;
             };
             #endif // SCIQLOP_IVARIABLECONTAINER_H

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

             #ifndef SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
             #include <memory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphWidget)
             class QCPRange;
             class SqpDateTime;
             class Variable;
             namespace Ui {
             class VisualizationGraphWidget;
             } // namespace Ui
             class VisualizationGraphWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationGraphWidget();
                 void addVariable(std::shared_ptr<Variable> variable);
                 void addVariableUsingGraph(std::shared_ptr<Variable> variable);
                 /// Removes a variable from the graph
                 void removeVariable(std::shared_ptr<Variable> variable) noexcept;
                 // 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;
                 void updateDisplay(std::shared_ptr<Variable> variable);
             signals:
                 void requestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
             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;
                 void onRangeChanged(const QCPRange &t1);
                 /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
                 void onMouseWheel(QWheelEvent *event) noexcept;
                 void onDataCacheVariableUpdated();
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H

gui/include/Visualization/VisualizationTabWidget.h +1 0

             #ifndef SCIQLOP_VISUALIZATIONTABWIDGET_H
             #define SCIQLOP_VISUALIZATIONTABWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             #include <QWidget>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationTabWidget)
             class Variable;
             class VisualizationZoneWidget;
             namespace Ui {
             class VisualizationTabWidget;
             } // namespace Ui
             class VisualizationTabWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationTabWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationTabWidget();
                 /// Add a zone widget
                 void addZone(VisualizationZoneWidget *zoneWidget);
                 /**
                  * Creates a zone using a variable. The variable will be displayed in a new graph of the new
                  * zone.
                  * @param variable the variable for which to create the zone
                  * @return the pointer to the created zone
                  */
                 VisualizationZoneWidget *createZone(std::shared_ptr<Variable> variable);
                 // 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;
             private:
                 /// @return the layout of tab in which zones are added
                 QLayout &tabLayout() const noexcept;
                 Ui::VisualizationTabWidget *ui;
                 class VisualizationTabWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationTabWidgetPrivate> impl;
             };
             #endif // SCIQLOP_VISUALIZATIONTABWIDGET_H

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

             #ifndef SCIQLOP_VISUALIZATIONWIDGET_H
             #define SCIQLOP_VISUALIZATIONWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationWidget)
             class QMenu;
             class Variable;
             class VisualizationTabWidget;
             namespace Ui {
             class VisualizationWidget;
             } // namespace Ui
             class VisualizationWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationWidget(QWidget *parent = 0);
                 virtual ~VisualizationWidget();
                 // 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;
             public slots:
                 /**
                  * Attaches to a menu the menu relative to the visualization of variables
                  * @param menu the parent menu of the generated menu
                  * @param variables the variables for which to generate the menu
                  */
                 void attachVariableMenu(QMenu *menu,
                                         const QVector<std::shared_ptr<Variable> > &variables) noexcept;
+                /// Slot called when a variable is about to be deleted from SciQlop
+                void onVariableAboutToBeDeleted(std::shared_ptr<Variable> variable) noexcept;
             private:
                 Ui::VisualizationWidget *ui;
             };
             #endif // VISUALIZATIONWIDGET_H

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

             #ifndef SCIQLOP_VISUALIZATIONZONEWIDGET_H
             #define SCIQLOP_VISUALIZATIONZONEWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationZoneWidget)
             namespace Ui {
             class VisualizationZoneWidget;
             } // Ui
             class Variable;
             class VisualizationGraphWidget;
             class VisualizationZoneWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationZoneWidget();
                 /// Add a graph widget
                 void addGraph(VisualizationGraphWidget *graphWidget);
                 /**
                  * Creates a graph using a variable. The variable will be displayed in the new graph.
                  * @param variable the variable for which to create the graph
                  * @return the pointer to the created graph
                  */
                 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable);
                 // 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;
             private:
                 Ui::VisualizationZoneWidget *ui;
             };
             #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H

gui/include/Visualization/operations/MenuBuilder.h +2 -1

             #ifndef SCIQLOP_MENUBUILDER_H
             #define SCIQLOP_MENUBUILDER_H
             #include <QLoggingCategory>
             #include <QMenu>
             #include <QStack>
             Q_DECLARE_LOGGING_CATEGORY(LOG_MenuBuilder)
             /// Helper assigned to build a hierarchical menu
             class MenuBuilder {
             public:
                 /**
                  * Ctor
                  * @param menu the parent menu
                  */
                 explicit MenuBuilder(QMenu *menu);
                 /**
                  * Adds action to the current menu
                  * @param actionName the name of the action
                  * @param actionFunction the function that will be executed when the action is triggered
                  */
                 template <typename ActionFun>
                 void addAction(const QString &actionName, ActionFun actionFunction);
                 /**
                  * Adds a new menu to the current menu
                  * @param name the name of the menu
+                 * @param icon the icon of the menu (can be null)
                  */
-                void addMenu(const QString &name);
+                void addMenu(const QString &name, const QIcon &icon = {});
                 /// Adds a separator to the current menu. The separator is added only if the menu already
                 /// contains entries
                 void addSeparator();
                 /// Closes the current menu
                 void closeMenu();
             private:
                 /// @return the current menu (i.e. the top menu of the stack), nullptr if there is no menu
                 QMenu *currentMenu() const;
                 /// Stack of all menus currently opened
                 QStack<QMenu *> m_Menus{};
             };
             template <typename ActionFun>
             void MenuBuilder::addAction(const QString &actionName, ActionFun actionFunction)
             {
                 if (auto currMenu = currentMenu()) {
                     currMenu->addAction(actionName, actionFunction);
                 }
                 else {
                     qCCritical(LOG_MenuBuilder()) << QObject::tr("No current menu to attach the action");
                 }
             }
             #endif // SCIQLOP_MENUBUILDER_H

gui/resources/sqpguiresources.qrc +2 0

             <RCC>
                 <qresource prefix="/">
             		<file>icones/delete.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>
                 </qresource>
             </RCC>

gui/src/SqpApplication.cpp +4 0

             #include "SqpApplication.h"
             #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
             #include <QThread>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/VisualizationController.h>
             Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
             class SqpApplication::SqpApplicationPrivate {
             public:
                 SqpApplicationPrivate()
                         : m_DataSourceController{std::make_unique<DataSourceController>()},
                           m_TimeController{std::make_unique<TimeController>()},
                           m_VariableController{std::make_unique<VariableController>()},
                           m_VisualizationController{std::make_unique<VisualizationController>()}
                 {
                     // /////////////////////////////// //
                     // Connections between controllers //
                     // /////////////////////////////// //
                     // VariableController <-> DataSourceController
                     connect(m_DataSourceController.get(),
                             SIGNAL(variableCreationRequested(const QString &, std::shared_ptr<IDataProvider>)),
                             m_VariableController.get(),
                             SLOT(createVariable(const QString &, std::shared_ptr<IDataProvider>)));
                     // VariableController <-> VisualizationController
                     connect(m_VariableController.get(), SIGNAL(variableCreated(std::shared_ptr<Variable>)),
                             m_VisualizationController.get(),
                             SIGNAL(variableCreated(std::shared_ptr<Variable>)));
+                    connect(m_VariableController.get(),
+                            SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
+                            m_VisualizationController.get(),
+                            SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
                     m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
                     m_VariableController->moveToThread(&m_VariableControllerThread);
                     m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
                     // Additionnal init
                     m_VariableController->setTimeController(m_TimeController.get());
                 }
                 virtual ~SqpApplicationPrivate()
                 {
                     qCInfo(LOG_SqpApplication()) << tr("SqpApplicationPrivate destruction");
                     m_DataSourceControllerThread.quit();
                     m_DataSourceControllerThread.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<VisualizationController> m_VisualizationController;
                 QThread m_DataSourceControllerThread;
                 QThread m_VariableControllerThread;
                 QThread m_VisualizationControllerThread;
             };
             SqpApplication::SqpApplication(int &argc, char **argv)
                     : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
             {
                 qCInfo(LOG_SqpApplication()) << tr("SqpApplication construction");
                 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_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_VariableControllerThread.start();
                 impl->m_VisualizationControllerThread.start();
             }
             SqpApplication::~SqpApplication()
             {
             }
             void SqpApplication::initialize()
             {
             }
             DataSourceController &SqpApplication::dataSourceController() noexcept
             {
                 return *impl->m_DataSourceController;
             }
             TimeController &SqpApplication::timeController() noexcept
             {
                 return *impl->m_TimeController;
             }
             VariableController &SqpApplication::variableController() noexcept
             {
                 return *impl->m_VariableController;
             }
             VisualizationController &SqpApplication::visualizationController() noexcept
             {
                 return *impl->m_VisualizationController;
             }

gui/src/Variable/VariableInspectorWidget.cpp +2 -2

             #include <Variable/VariableController.h>
             #include <Variable/VariableInspectorWidget.h>
             #include <Variable/VariableMenuHeaderWidget.h>
             #include <Variable/VariableModel.h>
             #include <ui_VariableInspectorWidget.h>
             #include <QSortFilterProxyModel>
             #include <QWidgetAction>
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_VariableInspectorWidget, "VariableInspectorWidget")
             VariableInspectorWidget::VariableInspectorWidget(QWidget *parent)
                     : QWidget{parent}, ui{new Ui::VariableInspectorWidget}
             {
                 ui->setupUi(this);
                 // Sets model for table
                 //    auto sortFilterModel = new QSortFilterProxyModel{this};
                 //    sortFilterModel->setSourceModel(sqpApp->variableController().variableModel());
                 ui->tableView->setModel(sqpApp->variableController().variableModel());
                 ui->tableView->setSelectionModel(sqpApp->variableController().variableSelectionModel());
                 // Fixes column sizes
                 auto model = ui->tableView->model();
                 const auto count = model->columnCount();
                 for (auto i = 0; i < count; ++i) {
                     ui->tableView->setColumnWidth(
                         i, model->headerData(i, Qt::Horizontal, Qt::SizeHintRole).toSize().width());
                 }
                 // Sets selection options
                 ui->tableView->setSelectionBehavior(QTableView::SelectRows);
                 ui->tableView->setSelectionMode(QTableView::ExtendedSelection);
                 // Connection to show a menu when right clicking on the tree
                 ui->tableView->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->tableView, &QTableView::customContextMenuRequested, this,
                         &VariableInspectorWidget::onTableMenuRequested);
             }
             VariableInspectorWidget::~VariableInspectorWidget()
             {
                 delete ui;
             }
             void VariableInspectorWidget::onTableMenuRequested(const QPoint &pos) noexcept
             {
                 auto selectedRows = ui->tableView->selectionModel()->selectedRows();
                 // Gets the model to retrieve the underlying selected variables
                 auto model = sqpApp->variableController().variableModel();
                 auto selectedVariables = QVector<std::shared_ptr<Variable> >{};
                 for (const auto &selectedRow : qAsConst(selectedRows)) {
                     if (auto selectedVariable = model->variable(selectedRow.row())) {
                         selectedVariables.push_back(selectedVariable);
                     }
                 }
                 QMenu tableMenu{};
                 // Emits a signal so that potential receivers can populate the menu before displaying it
                 emit tableMenuAboutToBeDisplayed(&tableMenu, selectedVariables);
                 // Adds menu-specific actions
                 if (!selectedVariables.isEmpty()) {
                     // 'Delete' action
-                    auto deleteFun = []() {
+                    auto deleteFun = [&selectedVariables]() {
-                        /// @todo ALX : call variable deletion
+                        sqpApp->variableController().deleteVariables(selectedVariables);
                     };
                     tableMenu.addSeparator();
                     tableMenu.addAction(QIcon{":/icones/delete.png"}, tr("Delete"), deleteFun);
                 }
                 if (!tableMenu.isEmpty()) {
                     // Generates menu header (inserted before first action)
                     auto firstAction = tableMenu.actions().first();
                     auto headerAction = new QWidgetAction{&tableMenu};
                     headerAction->setDefaultWidget(new VariableMenuHeaderWidget{selectedVariables, &tableMenu});
                     tableMenu.insertAction(firstAction, headerAction);
                     // Displays menu
                     tableMenu.exec(mapToGlobal(pos));
                 }
             }

gui/src/Visualization/VisualizationGraphWidget.cpp +12 0

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <SqpApplication.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;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                 // 1 variable -> n qcpplot
                 std::multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMultiMap;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 ui->graphNameLabel->setText(name);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationGraphWidget::close);
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                 // 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);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
                 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
                 connect(ui->widget->xAxis,
                         static_cast<void (QCPAxis::*)(const QCPRange &)>(&QCPAxis::rangeChanged), this,
                         &VisualizationGraphWidget::onRangeChanged);
                 // 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);
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
                 for (auto createdPlottable : qAsConst(createdPlottables)) {
                     impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
                 }
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
             }
             void VisualizationGraphWidget::addVariableUsingGraph(std::shared_ptr<Variable> variable)
             {
                 // when adding a variable, we need to set its time range to the current graph range
                 auto grapheRange = ui->widget->xAxis->range();
                 auto dateTime = SqpDateTime{grapheRange.lower, grapheRange.upper};
                 variable->setDateTime(dateTime);
                 auto variableDateTimeWithTolerance = dateTime;
                 // add 10% tolerance for each side
                 auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
                 variableDateTimeWithTolerance.m_TStart -= tolerance;
                 variableDateTimeWithTolerance.m_TEnd += tolerance;
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
                 for (auto createdPlottable : qAsConst(createdPlottables)) {
                     impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
                 }
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
                 // CHangement detected, we need to ask controller to request data loading
                 emit requestDataLoading(variable, variableDateTimeWithTolerance);
             }
             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 componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
                 for (auto it = componentsIt.first; it != componentsIt.second;) {
                     ui->widget->removePlottable(it->second);
                     it = impl->m_VariableToPlotMultiMap.erase(it);
                 }
                 // Updates graph
                 ui->widget->replot();
             }
             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 ui->graphNameLabel->text();
             }
             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(mapToGlobal(pos));
                 }
             }
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::onRangeChanged");
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                      it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                     auto variable = it->first;
                     auto dateTime = SqpDateTime{t1.lower, t1.upper};
                     if (!variable->contains(dateTime)) {
                         auto variableDateTimeWithTolerance = dateTime;
                         if (!variable->isInside(dateTime)) {
                             auto variableDateTime = variable->dateTime();
                             if (variableDateTime.m_TStart < dateTime.m_TStart) {
                                 qCDebug(LOG_VisualizationGraphWidget()) << tr("TDetection pan to right:");
                                 auto diffEndToKeepDelta = dateTime.m_TEnd - variableDateTime.m_TEnd;
                                 dateTime.m_TStart = variableDateTime.m_TStart + diffEndToKeepDelta;
                                 // Tolerance have to be added to the right
                                 // add 10% tolerance for right (end) side
                                 auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
                                 variableDateTimeWithTolerance.m_TEnd += tolerance;
                             }
                             else if (variableDateTime.m_TEnd > dateTime.m_TEnd) {
                                 qCDebug(LOG_VisualizationGraphWidget()) << tr("Detection pan to left: ");
                                 auto diffStartToKeepDelta = variableDateTime.m_TStart - dateTime.m_TStart;
                                 dateTime.m_TEnd = variableDateTime.m_TEnd - diffStartToKeepDelta;
                                 // Tolerance have to be added to the left
                                 // add 10% tolerance for left (start) side
                                 auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
                                 variableDateTimeWithTolerance.m_TStart -= tolerance;
                             }
                             else {
                                 qCWarning(LOG_VisualizationGraphWidget())
                                     << tr("Detection anormal zoom detection: ");
                             }
                         }
                         else {
                             qCDebug(LOG_VisualizationGraphWidget()) << tr("Detection zoom out: ");
                             // add 10% tolerance for each side
                             auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
                             variableDateTimeWithTolerance.m_TStart -= tolerance;
                             variableDateTimeWithTolerance.m_TEnd += tolerance;
                         }
                         variable->setDateTime(dateTime);
                         // CHangement detected, we need to ask controller to request data loading
                         emit requestDataLoading(variable, variableDateTimeWithTolerance);
                     }
                     else {
                         qCDebug(LOG_VisualizationGraphWidget()) << tr("Detection zoom in: ");
                     }
                 }
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto zoomOrientations = QFlags<Qt::Orientation>{};
                 // Lambda that enables a zoom orientation if the key modifier related to this orientation
                 // has
                 // been pressed
                 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);
             }
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
                 // NOTE:
                 //    We don't want to call the method for each component of a variable unitarily, but for
                 //    all
                 //    its components at once (eg its three components in the case of a vector).
                 //    The unordered_multimap does not do this easily, so the question is whether to:
                 //    - use an ordered_multimap and the algos of std to group the values by key
                 //    - use a map (unique keys) and store as values directly the list of components
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                      it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                     auto variable = it->first;
                     VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
                                                          variable->dataSeries(), variable->dateTime());
                 }
             }
             void VisualizationGraphWidget::updateDisplay(std::shared_ptr<Variable> variable)
             {
                 auto abstractPlotableItPair = impl->m_VariableToPlotMultiMap.equal_range(variable);
                 auto abstractPlotableVect = QVector<QCPAbstractPlottable *>{};
                 for (auto it = abstractPlotableItPair.first; it != abstractPlotableItPair.second; ++it) {
                     abstractPlotableVect.push_back(it->second);
                 }
                 VisualizationGraphHelper::updateData(abstractPlotableVect, variable->dataSeries(),
                                                      variable->dateTime());
             }

gui/src/Visualization/VisualizationTabWidget.cpp +6 0

             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "ui_VisualizationTabWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
             namespace {
             /// Generates a default name for a new zone, according to the number of zones already displayed in
             /// the tab
             QString defaultZoneName(const QLayout &layout)
             {
                 auto count = 0;
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (dynamic_cast<VisualizationZoneWidget *>(layout.itemAt(i)->widget())) {
                         count++;
                     }
                 }
                 return QObject::tr("Zone %1").arg(count + 1);
             }
             } // namespace
             struct VisualizationTabWidget::VisualizationTabWidgetPrivate {
                 explicit VisualizationTabWidgetPrivate(const QString &name) : m_Name{name} {}
                 QString m_Name;
             };
             VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationTabWidget},
                       impl{spimpl::make_unique_impl<VisualizationTabWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
                 // Widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
             }
             VisualizationTabWidget::~VisualizationTabWidget()
             {
                 delete ui;
             }
             void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
             {
                 tabLayout().addWidget(zoneWidget);
             }
             VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
             {
                 auto zoneWidget = new VisualizationZoneWidget{defaultZoneName(tabLayout()), this};
                 this->addZone(zoneWidget);
                 // Creates a new graph into the zone
                 zoneWidget->createGraph(variable);
                 return zoneWidget;
             }
             void VisualizationTabWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to zone children
                     auto &layout = tabLayout();
                     for (auto i = 0; i < layout.count(); ++i) {
                         if (auto item = layout.itemAt(i)) {
                             // Widgets different from zones are not visited (no action)
                             if (auto visualizationZoneWidget
                                 = dynamic_cast<VisualizationZoneWidget *>(item->widget())) {
                                 visualizationZoneWidget->accept(visitor);
                             }
                         }
                     }
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationTabWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationTabWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
+            bool VisualizationTabWidget::contains(const Variable &variable) const
+            {
+                Q_UNUSED(variable);
+                return false;
+            }
             QString VisualizationTabWidget::name() const
             {
                 return impl->m_Name;
             }
             QLayout &VisualizationTabWidget::tabLayout() const noexcept
             {
                 return *ui->scrollAreaWidgetContents->layout();
             }

gui/src/Visualization/VisualizationWidget.cpp +14 0

             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/operations/GenerateVariableMenuOperation.h"
+            #include "Visualization/operations/RemoveVariableOperation.h"
             #include "Visualization/qcustomplot.h"
             #include "ui_VisualizationWidget.h"
             #include <QToolButton>
             Q_LOGGING_CATEGORY(LOG_VisualizationWidget, "VisualizationWidget")
             VisualizationWidget::VisualizationWidget(QWidget *parent)
                     : QWidget{parent}, ui{new Ui::VisualizationWidget}
             {
                 ui->setupUi(this);
                 auto addTabViewButton = new QToolButton{ui->tabWidget};
                 addTabViewButton->setText(tr("Add View"));
                 addTabViewButton->setCursor(Qt::ArrowCursor);
                 ui->tabWidget->setCornerWidget(addTabViewButton, Qt::TopRightCorner);
                 auto enableMinimumCornerWidgetSize = [this](bool enable) {
                     auto tabViewCornerWidget = ui->tabWidget->cornerWidget();
                     auto width = enable ? tabViewCornerWidget->width() : 0;
                     auto height = enable ? tabViewCornerWidget->height() : 0;
                     tabViewCornerWidget->setMinimumHeight(height);
                     tabViewCornerWidget->setMinimumWidth(width);
                     ui->tabWidget->setMinimumHeight(height);
                     ui->tabWidget->setMinimumWidth(width);
                 };
                 auto addTabView = [this, enableMinimumCornerWidgetSize]() {
                     auto widget = new VisualizationTabWidget{QString{"View %1"}.arg(ui->tabWidget->count() + 1),
                                                              ui->tabWidget};
                     auto index = ui->tabWidget->addTab(widget, widget->name());
                     if (ui->tabWidget->count() > 0) {
                         enableMinimumCornerWidgetSize(false);
                     }
                     qCInfo(LOG_VisualizationWidget()) << tr("add the tab of index %1").arg(index);
                 };
                 auto removeTabView = [this, enableMinimumCornerWidgetSize](int index) {
                     if (ui->tabWidget->count() == 1) {
                         enableMinimumCornerWidgetSize(true);
                     }
                     // Removes widget from tab and closes it
                     auto widget = ui->tabWidget->widget(index);
                     ui->tabWidget->removeTab(index);
                     if (widget) {
                         widget->close();
                     }
                     qCInfo(LOG_VisualizationWidget()) << tr("remove the tab of index %1").arg(index);
                 };
                 ui->tabWidget->setTabsClosable(true);
                 connect(addTabViewButton, &QToolButton::clicked, addTabView);
                 connect(ui->tabWidget, &QTabWidget::tabCloseRequested, removeTabView);
                 // Adds default tab
                 addTabView();
             }
             VisualizationWidget::~VisualizationWidget()
             {
                 delete ui;
             }
             void VisualizationWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor for tab children
                     for (auto i = 0; i < ui->tabWidget->count(); ++i) {
                         // Widgets different from tabs are not visited (no action)
                         if (auto visualizationTabWidget
                             = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->widget(i))) {
                             visualizationTabWidget->accept(visitor);
                         }
                     }
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationWidget::canDrop(const Variable &variable) const
             {
                 // The main widget can never accomodate a variable
                 Q_UNUSED(variable);
                 return false;
             }
+            bool VisualizationWidget::contains(const Variable &variable) const
+            {
+                Q_UNUSED(variable);
+                return false;
+            }
             QString VisualizationWidget::name() const
             {
                 return QStringLiteral("MainView");
             }
             void VisualizationWidget::attachVariableMenu(
                 QMenu *menu, const QVector<std::shared_ptr<Variable> > &variables) noexcept
             {
                 // Menu is generated only if there is a single variable
                 if (variables.size() == 1) {
                     if (auto variable = variables.first()) {
                         // Generates the actions that make it possible to visualize the variable
                         auto generateVariableMenuOperation = GenerateVariableMenuOperation{menu, variable};
                         accept(&generateVariableMenuOperation);
                     }
                     else {
                         qCCritical(LOG_VisualizationWidget()) << tr(
                             "Can't generate the menu relative to the visualization: the variable is null");
                     }
                 }
                 else {
                     qCDebug(LOG_VisualizationWidget())
                         << tr("No generation of the menu related to the visualization: several variables are "
                               "selected");
                 }
             }
+            void VisualizationWidget::onVariableAboutToBeDeleted(std::shared_ptr<Variable> variable) noexcept
+            {
+                // Calls the operation of removing all references to the variable in the visualization
+                auto removeVariableOperation = RemoveVariableOperation{variable};
+                accept(&removeVariableOperation);
+            }

gui/src/Visualization/VisualizationZoneWidget.cpp +6 0

             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "ui_VisualizationZoneWidget.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
             namespace {
             /// Minimum height for graph added in zones (in pixels)
             const auto GRAPH_MINIMUM_HEIGHT = 300;
             /// 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);
             }
             } // namespace
             VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
                     : QWidget{parent}, ui{new Ui::VisualizationZoneWidget}
             {
                 ui->setupUi(this);
                 ui->zoneNameLabel->setText(name);
                 // '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));
             }
             VisualizationZoneWidget::~VisualizationZoneWidget()
             {
                 delete ui;
             }
             void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
             {
                 ui->visualizationZoneFrame->layout()->addWidget(graphWidget);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
             {
                 auto graphWidget = new VisualizationGraphWidget{
                     defaultGraphName(*ui->visualizationZoneFrame->layout()), this};
                 // Set graph properties
                 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
                 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
                 this->addGraph(graphWidget);
                 graphWidget->addVariable(variable);
                 return graphWidget;
             }
             void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to graph children
                     auto layout = ui->visualizationZoneFrame->layout();
                     for (auto i = 0; i < layout->count(); ++i) {
                         if (auto item = layout->itemAt(i)) {
                             // Widgets different from graphs are not visited (no action)
                             if (auto visualizationGraphWidget
                                 = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
                                 visualizationGraphWidget->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();
             }

gui/src/Visualization/operations/GenerateVariableMenuOperation.cpp +53 -16

             #include "Visualization/operations/GenerateVariableMenuOperation.h"
             #include "Visualization/operations/MenuBuilder.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include <Variable/Variable.h>
             #include <QMenu>
             #include <QStack>
             Q_LOGGING_CATEGORY(LOG_GenerateVariableMenuOperation, "GenerateVariableMenuOperation")
             struct GenerateVariableMenuOperation::GenerateVariableMenuOperationPrivate {
                 explicit GenerateVariableMenuOperationPrivate(QMenu *menu, std::shared_ptr<Variable> variable)
-                        : m_Variable{variable}, m_MenuBuilder{menu}
+                        : m_Variable{variable}, m_PlotMenuBuilder{menu}, m_UnplotMenuBuilder{menu}
                 {
                 }
                 void visitRootEnter()
                 {
                     // Creates the root menu
-                    m_MenuBuilder.addMenu(QObject::tr("Plot"));
+                    m_PlotMenuBuilder.addMenu(QObject::tr("Plot"), QIcon{":/icones/plot.png"});
+                    m_UnplotMenuBuilder.addMenu(QObject::tr("Unplot"), QIcon{":/icones/unplot.png"});
                 }
                 void visitRootLeave()
                 {
                     // Closes the root menu
-                    m_MenuBuilder.closeMenu();
+                    m_PlotMenuBuilder.closeMenu();
+                    m_UnplotMenuBuilder.closeMenu();
                 }
                 void visitNodeEnter(const IVisualizationWidget &container)
                 {
                     // Opens a new menu associated to the node
-                    m_MenuBuilder.addMenu(container.name());
+                    m_PlotMenuBuilder.addMenu(container.name());
+                    m_UnplotMenuBuilder.addMenu(container.name());
                 }
                 template <typename ActionFun>
-                void visitNodeLeave(const IVisualizationWidget &container, const QString &actionName,
+                void visitNodeLeavePlot(const IVisualizationWidget &container, const QString &actionName,
-                                    ActionFun actionFunction)
+                                        ActionFun actionFunction)
                 {
                     if (m_Variable && container.canDrop(*m_Variable)) {
-                        m_MenuBuilder.addSeparator();
+                        m_PlotMenuBuilder.addSeparator();
-                        m_MenuBuilder.addAction(actionName, actionFunction);
+                        m_PlotMenuBuilder.addAction(actionName, actionFunction);
                     }
                     // Closes the menu associated to the node
-                    m_MenuBuilder.closeMenu();
+                    m_PlotMenuBuilder.closeMenu();
+                }
+                void visitNodeLeaveUnplot()
+                {
+                    // Closes the menu associated to the node
+                    m_UnplotMenuBuilder.closeMenu();
                 }
                 template <typename ActionFun>
-                void visitLeaf(const IVisualizationWidget &container, const QString &actionName,
+                void visitLeafPlot(const IVisualizationWidget &container, const QString &actionName,
-                               ActionFun actionFunction)
+                                   ActionFun actionFunction)
                 {
                     if (m_Variable && container.canDrop(*m_Variable)) {
-                        m_MenuBuilder.addAction(actionName, actionFunction);
+                        m_PlotMenuBuilder.addAction(actionName, actionFunction);
+                    }
+                }
+                template <typename ActionFun>
+                void visitLeafUnplot(const IVisualizationWidget &container, const QString &actionName,
+                                     ActionFun actionFunction)
+                {
+                    if (m_Variable && container.contains(*m_Variable)) {
+                        m_UnplotMenuBuilder.addAction(actionName, actionFunction);
                     }
                 }
                 std::shared_ptr<Variable> m_Variable;
-                MenuBuilder m_MenuBuilder;
+                MenuBuilder m_PlotMenuBuilder;   ///< Builder for the 'Plot' menu
+                MenuBuilder m_UnplotMenuBuilder; ///< Builder for the 'Unplot' menu
             };
             GenerateVariableMenuOperation::GenerateVariableMenuOperation(QMenu *menu,
                                                                          std::shared_ptr<Variable> variable)
                     : impl{spimpl::make_unique_impl<GenerateVariableMenuOperationPrivate>(menu, variable)}
             {
             }
             void GenerateVariableMenuOperation::visitEnter(VisualizationWidget *widget)
             {
                 // VisualizationWidget is not intended to accommodate a variable
                 Q_UNUSED(widget)
+                // 'Plot' and 'Unplot' menus
                 impl->visitRootEnter();
             }
             void GenerateVariableMenuOperation::visitLeave(VisualizationWidget *widget)
             {
                 // VisualizationWidget is not intended to accommodate a variable
                 Q_UNUSED(widget)
+                // 'Plot' and 'Unplot' menus
                 impl->visitRootLeave();
             }
             void GenerateVariableMenuOperation::visitEnter(VisualizationTabWidget *tabWidget)
             {
                 if (tabWidget) {
+                    // 'Plot' and 'Unplot' menus
                     impl->visitNodeEnter(*tabWidget);
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit enter VisualizationTabWidget : the widget is null");
                 }
             }
             void GenerateVariableMenuOperation::visitLeave(VisualizationTabWidget *tabWidget)
             {
                 if (tabWidget) {
-                    impl->visitNodeLeave(
+                    // 'Plot' menu
+                    impl->visitNodeLeavePlot(
                         *tabWidget, QObject::tr("Open in a new zone"),
                         [ var = impl->m_Variable, tabWidget ]() { tabWidget->createZone(var); });
+                    // 'Unplot' menu
+                    impl->visitNodeLeaveUnplot();
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit leave VisualizationTabWidget : the widget is null");
                 }
             }
             void GenerateVariableMenuOperation::visitEnter(VisualizationZoneWidget *zoneWidget)
             {
                 if (zoneWidget) {
+                    // 'Plot' and 'Unplot' menus
                     impl->visitNodeEnter(*zoneWidget);
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit enter VisualizationZoneWidget : the widget is null");
                 }
             }
             void GenerateVariableMenuOperation::visitLeave(VisualizationZoneWidget *zoneWidget)
             {
                 if (zoneWidget) {
-                    impl->visitNodeLeave(
+                    // 'Plot' menu
+                    impl->visitNodeLeavePlot(
                         *zoneWidget, QObject::tr("Open in a new graph"),
                         [ var = impl->m_Variable, zoneWidget ]() { zoneWidget->createGraph(var); });
+                    // 'Unplot' menu
+                    impl->visitNodeLeaveUnplot();
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit leave VisualizationZoneWidget : the widget is null");
                 }
             }
             void GenerateVariableMenuOperation::visit(VisualizationGraphWidget *graphWidget)
             {
                 if (graphWidget) {
-                    impl->visitLeaf(
+                    // 'Plot' menu
+                    impl->visitLeafPlot(
                         *graphWidget, QObject::tr("Open in %1").arg(graphWidget->name()),
                         [ var = impl->m_Variable, graphWidget ]() { graphWidget->addVariableUsingGraph(var); });
+                    // 'Unplot' menu
+                    impl->visitLeafUnplot(
+                        *graphWidget, QObject::tr("Remove from %1").arg(graphWidget->name()),
+                        [ var = impl->m_Variable, graphWidget ]() { graphWidget->removeVariable(var); });
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),
                                "Can't visit VisualizationGraphWidget : the widget is null");
                 }
             }

gui/src/Visualization/operations/MenuBuilder.cpp +2 -2

             #include "Visualization/operations/MenuBuilder.h"
             Q_LOGGING_CATEGORY(LOG_MenuBuilder, "MenuBuilder")
             MenuBuilder::MenuBuilder(QMenu *menu)
             {
                 if (menu) {
                     m_Menus.push(menu);
                 }
                 else {
                     qCCritical(LOG_MenuBuilder()) << QObject::tr("No parent menu has been defined");
                 }
             }
-            void MenuBuilder::addMenu(const QString &name)
+            void MenuBuilder::addMenu(const QString &name, const QIcon &icon)
             {
                 if (auto currMenu = currentMenu()) {
-                    m_Menus.push(currMenu->addMenu(name));
+                    m_Menus.push(currMenu->addMenu(icon, name));
                 }
                 else {
                     qCCritical(LOG_MenuBuilder()) << QObject::tr("No current menu to attach the new menu");
                 }
             }
             void MenuBuilder::addSeparator()
             {
                 if (auto currMenu = currentMenu()) {
                     if (!currMenu->isEmpty()) {
                         currMenu->addSeparator();
                     }
                 }
                 else {
                     qCCritical(LOG_MenuBuilder()) << QObject::tr("No current menu to attach the separator");
                 }
             }
             void MenuBuilder::closeMenu()
             {
                 if (!m_Menus.isEmpty()) {
                     if (auto closedMenu = m_Menus.pop()) {
                         // Purge menu : if the closed menu has no entries, we remove it from its parent (the
                         // current menu)
                         if (auto currMenu = currentMenu()) {
                             if (closedMenu->isEmpty()) {
                                 currMenu->removeAction(closedMenu->menuAction());
                             }
                         }
                     }
                 }
             }
             QMenu *MenuBuilder::currentMenu() const
             {
                 return !m_Menus.isEmpty() ? m_Menus.top() : nullptr;
             }

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