HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r280:7690105e7a4e

Merge branch 'develop' of https://perrinel@hephaistos.lpp.polytechnique.fr/rhodecode/GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation into develop

perrinel -

r280:7690105e7a4e

parent child

Context file:

r280:7690105e7a4e

Collapse all files

app/src/Main.cpp +3 -1

             /*------------------------------------------------------------------------------
             -- This file is a part of the QLop Software
             -- Copyright (C) 2015, 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 <QProcessEnvironment>
             #include <QThread>
             #include <SqpApplication.h>
             #include <qglobal.h>
             #include <Plugin/PluginManager.h>
             #include <QDir>
             namespace {
             /// Name of the directory containing the plugins
             #if _WIN32 || _WIN64
             const auto PLUGIN_DIRECTORY_NAME = QStringLiteral("plugins");
             #endif
             } // namespace
             int main(int argc, char *argv[])
             {
                 SqpApplication a{argc, argv};
                 SqpApplication::setOrganizationName("LPP");
                 SqpApplication::setOrganizationDomain("lpp.fr");
                 SqpApplication::setApplicationName("SciQLop");
                 MainWindow w;
                 w.show();
                 // Loads plugins
                 auto pluginDir = QDir{sqpApp->applicationDirPath()};
             #if _WIN32 || _WIN64
                 pluginDir.mkdir(PLUGIN_DIRECTORY_NAME);
                 pluginDir.cd(PLUGIN_DIRECTORY_NAME);
             #endif
             #if __GNUC__
             #if __x86_64__ || __ppc64__
                 if (!pluginDir.cd("../lib64/SciQlop")) {
                     pluginDir.cd("../lib64/sciqlop");
                 }
             #else
-                __x86_64__ || __ppc64__ if (!pluginDir.cd("../lib/SciQlop")) { pluginDir.cd("../lib/sciqlop"); }
+                if (!pluginDir.cd("../lib/SciQlop")) {
+                    pluginDir.cd("../lib/sciqlop");
+                }
             #endif
             #endif
                 qCDebug(LOG_PluginManager())
                     << QObject::tr("Plugin directory: %1").arg(pluginDir.absolutePath());
                 PluginManager pluginManager{};
                 pluginManager.loadPlugins(pluginDir);
                 return a.exec();
             }

gui/include/Visualization/IVisualizationWidget.h 0 -1

             #ifndef SCIQLOP_IVISUALIZATIONWIDGET_H
             #define SCIQLOP_IVISUALIZATIONWIDGET_H
             #include "Visualization/IVariableContainer.h"
             #include <QString>
             #include <memory>
             class IVisualizationWidgetVisitor;
             /**
              * @brief The IVisualizationWidget handles the visualization widget.
              */
             class IVisualizationWidget : public IVariableContainer {
             public:
                 virtual ~IVisualizationWidget() = default;
                 /// Initializes the plugin
                 virtual void accept(IVisualizationWidgetVisitor *visitor) = 0;
-                virtual void close() = 0;
                 virtual QString name() const = 0;
             };
             #endif // SCIQLOP_IVISUALIZATIONWIDGET_H

gui/include/Visualization/VisualizationGraphWidget.h +4 -1

             #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 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);
+                /// 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;
-                void close() override;
                 QString name() const override;
                 void updateDisplay(std::shared_ptr<Variable> variable);
             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, const QCPRange &t2);
                 /// 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 0 -4

             #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);
-                /// Remove a zone
-                void removeZone(VisualizationZoneWidget *zone);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
-                void close() override;
                 QString name() const override;
             private:
                 Ui::VisualizationTabWidget *ui;
                 class VisualizationTabWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationTabWidgetPrivate> impl;
             };
             #endif // SCIQLOP_VISUALIZATIONTABWIDGET_H

gui/include/Visualization/VisualizationWidget.h 0 -10

             #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();
-                /// Add a zone widget
-                virtual void addTab(VisualizationTabWidget *tabWidget);
-                /// Create a tab using a Variable
-                VisualizationTabWidget *createTab();
-                /// Remove a tab
-                void removeTab(VisualizationTabWidget *tab);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
-                void close() override;
                 QString name() const override;
             public slots:
                 /**
                  * Attaches to a menu the menu relating to the visualization of a variable
                  * @param menu the parent menu of the generated menu
                  * @param variable the variable for which to generate the menu
                  */
                 void attachVariableMenu(QMenu *menu, std::shared_ptr<Variable> variable) noexcept;
             private:
                 Ui::VisualizationWidget *ui;
             };
             #endif // VISUALIZATIONWIDGET_H

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

             #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);
-                /// Remove a graph
-                void removeGraph(VisualizationGraphWidget *graph);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
-                void close() override;
                 QString name() const override;
             private:
                 Ui::VisualizationZoneWidget *ui;
             };
             #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H

gui/src/Visualization/VisualizationGraphWidget.cpp +42 -13

             #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::unordered_multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *>
+                std::multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMultiMap;
-                    m_VariableToPlotMultiMap;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
             {
                 ui->setupUi(this);
-                // qcpplot title
+                ui->graphNameLabel->setText(name);
-                ui->widget->plotLayout()->insertRow(0);
-                ui->widget->plotLayout()->addElement(0, 0, new QCPTextElement{ui->widget, 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 &, 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);
             }
             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(dataCacheUpdated()), this, SLOT(onDataCacheVariableUpdated()));
             }
+            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;
             }
-            void VisualizationGraphWidget::close()
+            QString VisualizationGraphWidget::name() const
             {
-                // The main view cannot be directly closed.
+                return ui->graphNameLabel->text();
-                return;
             }
-            QString VisualizationGraphWidget::name() const
+            void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
             {
-                if (auto title = dynamic_cast<QCPTextElement *>(ui->widget->plotLayout()->elementAt(0))) {
+                QMenu graphMenu{};
-                    return title->text();
+                // 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); });
                 }
-                else {
-                    return QString{};
+                if (!graphMenu.isEmpty()) {
+                    graphMenu.exec(mapToGlobal(pos));
                 }
             }
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::onRangeChanged");
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                      it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                     auto variable = it->first;
                     qCInfo(LOG_VisualizationGraphWidget())
                         << tr("TORM: VisualizationGraphWidget::onRangeChanged")
                         << variable->dataSeries()->xAxisData()->size();
                     auto dateTime = SqpDateTime{t2.lower, t2.upper};
                     if (!variable->contains(dateTime)) {
                         auto variableDateTimeWithTolerance = dateTime;
                         if (variable->intersect(dateTime)) {
                             auto variableDateTime = variable->dateTime();
                             if (variableDateTime.m_TStart < dateTime.m_TStart) {
                                 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;
                             }
                             if (variableDateTime.m_TEnd > dateTime.m_TEnd) {
                                 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 {
                             // 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
                         sqpApp->variableController().requestDataLoading(variable,
                                                                         variableDateTimeWithTolerance);
                     }
                 }
             }
             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 +3 -10

             #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)
             {
                 this->layout()->addWidget(zoneWidget);
             }
             VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
             {
                 auto zoneWidget = new VisualizationZoneWidget{defaultZoneName(*layout()), this};
                 this->addZone(zoneWidget);
                 // Creates a new graph into the zone
                 zoneWidget->createGraph(variable);
                 return zoneWidget;
             }
-            void VisualizationTabWidget::removeZone(VisualizationZoneWidget *zone)
             void VisualizationTabWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to zone children
                     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;
             }
-            void VisualizationTabWidget::close()
-                // The main view cannot be directly closed.
-                return;
             QString VisualizationTabWidget::name() const
             {
                 return impl->m_Name;
             }

gui/src/Visualization/VisualizationWidget.cpp +6 -22

             #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/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::addTab(VisualizationTabWidget *tabWidget)
-                // NOTE: check is this method has to be deleted because of its dupplicated version visible as
-                // lambda function (in the constructor)
-            VisualizationTabWidget *VisualizationWidget::createTab()
-            void VisualizationWidget::removeTab(VisualizationTabWidget *tab)
-                // NOTE: check is this method has to be deleted because of its dupplicated version visible as
-                // lambda function (in the constructor)
             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;
             }
-            void VisualizationWidget::close()
-                // The main view cannot be directly closed.
-                return;
             QString VisualizationWidget::name() const
             {
                 return QStringLiteral("MainView");
             }
             void VisualizationWidget::attachVariableMenu(QMenu *menu,
                                                          std::shared_ptr<Variable> variable) noexcept
             {
                 // Generates the actions that make it possible to visualize the variable
                 auto generateVariableMenuOperation = GenerateVariableMenuOperation{menu, variable};
                 accept(&generateVariableMenuOperation);
             }

gui/src/Visualization/VisualizationZoneWidget.cpp +7 -10

             #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 {
             /// 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};
                 this->addGraph(graphWidget);
                 graphWidget->addVariable(variable);
                 return graphWidget;
             }
-            void VisualizationZoneWidget::removeGraph(VisualizationGraphWidget *graph)
             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;
             }
-            void VisualizationZoneWidget::close()
-                // The main view cannot be directly closed.
-                return;
             QString VisualizationZoneWidget::name() const
             {
                 return ui->zoneNameLabel->text();
             }

gui/ui/Visualization/VisualizationGraphWidget.ui +52 -1

@@ -1,32 +1,83
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<ui version="4.0">	2	<ui version="4.0">
3	<class>VisualizationGraphWidget</class>	3	<class>VisualizationGraphWidget</class>
4	<widget class="QWidget" name="VisualizationGraphWidget">	4	<widget class="QWidget" name="VisualizationGraphWidget">
5	<property name="geometry">	5	<property name="geometry">
6	<rect>	6	<rect>
7	<x>0</x>	7	<x>0</x>
8	<y>0</y>	8	<y>0</y>
9	<width>400</width>	9	<width>400</width>
10	<height>300</height>	10	<height>300</height>
11	</rect>	11	</rect>
12	</property>	12	</property>
13	<property name="windowTitle">	13	<property name="windowTitle">
14	<string>Form</string>	14	<string>Form</string>
15	</property>	15	</property>
16	<layout class="QVBoxLayout" name="verticalLayout">	16	<layout class="QVBoxLayout" name="verticalLayout">
17	<item>	17	<item>
18	<widget class="Q~~CustomPlot" name="widget~~" native="true"/>	18	<widget class="QWidget" name="infobar" native="true">
		19	<layout class="QHBoxLayout" name="horizontalLayout_2">
		20	<property name="leftMargin">
		21	<number>0</number>
		22	</property>
		23	<property name="topMargin">
		24	<number>0</number>
		25	</property>
		26	<property name="rightMargin">
		27	<number>0</number>
		28	</property>
		29	<property name="bottomMargin">
		30	<number>0</number>
		31	</property>
		32	<item>
		33	<widget class="QLabel" name="graphNameLabel">
		34	<property name="styleSheet">
		35	<string notr="true">font: 75 9pt "MS Shell Dlg 2";</string>
		36	</property>
		37	<property name="text">
		38	<string>TextLabel</string>
		39	</property>
		40	<property name="textFormat">
		41	<enum>Qt::AutoText</enum>
		42	</property>
		43	<property name="alignment">
		44	<set>Qt::AlignCenter</set>
		45	</property>
		46	</widget>
		47	</item>
		48	<item>
		49	<widget class="QToolButton" name="closeButton">
		50	<property name="styleSheet">
		51	<string notr="true">background-color: transparent;</string>
		52	</property>
		53	<property name="text">
		54	<string>Close</string>
		55	</property>
		56	</widget>
		57	</item>
		58	</layout>
		59	</widget>
		60	</item>
		61	<item>
		62	<widget class="QCustomPlot" name="widget" native="true">
		63	<property name="sizePolicy">
		64	<sizepolicy hsizetype="Preferred" vsizetype="Expanding">
		65	<horstretch>0</horstretch>
		66	<verstretch>0</verstretch>
		67	</sizepolicy>
		68	</property>
		69	</widget>
19	</item>	70	</item>
20	</layout>	71	</layout>
21	</widget>	72	</widget>
22	<customwidgets>	73	<customwidgets>
23	<customwidget>	74	<customwidget>
24	<class>QCustomPlot</class>	75	<class>QCustomPlot</class>
25	<extends>QWidget</extends>	76	<extends>QWidget</extends>
26	<header>Visualization/qcustomplot.h</header>	77	<header>Visualization/qcustomplot.h</header>
27	<container>1</container>	78	<container>1</container>
28	</customwidget>	79	</customwidget>
29	</customwidgets>	80	</customwidgets>
30	<resources/>	81	<resources/>
31	<connections/>	82	<connections/>
32	</ui>	83	</ui>

gui/ui/Visualization/VisualizationZoneWidget.ui +10 0

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>VisualizationZoneWidget</class>
              <widget class="QWidget" name="VisualizationZoneWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>400</width>
                 <height>300</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QVBoxLayout" name="verticalLayout_2">
                <item>
                 <widget class="QWidget" name="infobar" native="true">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                  <layout class="QHBoxLayout" name="horizontalLayout">
                   <property name="leftMargin">
                    <number>0</number>
                   </property>
                   <property name="topMargin">
                    <number>0</number>
                   </property>
                   <property name="rightMargin">
                    <number>0</number>
                   </property>
                   <property name="bottomMargin">
                    <number>0</number>
                   </property>
                   <item>
                    <widget class="QLabel" name="zoneNameLabel">
                     <property name="styleSheet">
                      <string notr="true">color: rgb(127, 127, 127);
             </string>
                     </property>
                     <property name="text">
                      <string>TextLabel</string>
                     </property>
                    </widget>
                   </item>
+                  <item>
+                   <widget class="QToolButton" name="closeButton">
+                    <property name="styleSheet">
+                     <string notr="true">background-color: transparent;</string>
+                    </property>
+                    <property name="text">
+                     <string>Close</string>
+                    </property>
+                   </widget>
+                  </item>
                  </layout>
                 </widget>
                </item>
                <item>
                 <widget class="QFrame" name="visualizationZoneFrame">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                  <property name="frameShape">
                   <enum>QFrame::Box</enum>
                  </property>
                  <property name="frameShadow">
                   <enum>QFrame::Raised</enum>
                  </property>
                  <property name="lineWidth">
                   <number>1</number>
                  </property>
                  <layout class="QVBoxLayout" name="verticalLayout"/>
                 </widget>
                </item>
               </layout>
              </widget>
              <resources/>
              <connections/>
             </ui>

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