HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r187:60a84e67b911

Pass Variable as shared_ptr

Alexandre Leroux -

r187:60a84e67b911

parent child

Context file:

r187:60a84e67b911

Collapse all files

gui/include/Visualization/GraphPlottablesFactory.h +3 -1

             #ifndef SCIQLOP_GRAPHPLOTTABLESFACTORY_H
             #define SCIQLOP_GRAPHPLOTTABLESFACTORY_H
             #include <QLoggingCategory>
             #include <QVector>
+            #include <memory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_GraphPlottablesFactory)
             class QCPAbstractPlottable;
             class QCustomPlot;
             class Variable;
             /**
              * @brief The GraphPlottablesFactory class aims to create the QCustomPlot components relative to a
              * variable, depending on the data series of this variable
              */
             struct GraphPlottablesFactory {
                 /**
                  * Creates (if possible) the QCustomPlot components relative to the variable passed in
                  * parameter, and adds these to the plot passed in parameter.
                  * @param variable the variable for which to create the components
                  * @param plot the plot in which to add the created components. It takes ownership of these
                  * components.
                  * @return the list of the components created
                  */
-                static QVector<QCPAbstractPlottable *> create(const Variable *variable,
+                static QVector<QCPAbstractPlottable *> create(std::shared_ptr<Variable> variable,
                                                               QCustomPlot &plot) noexcept;
             };
             #endif // SCIQLOP_GRAPHPLOTTABLESFACTORY_H

gui/src/Visualization/GraphPlottablesFactory.cpp +1 -1

             #include "Visualization/GraphPlottablesFactory.h"
             #include "Visualization/qcustomplot.h"
             #include <Data/ScalarSeries.h>
             #include <Variable/Variable.h>
             Q_LOGGING_CATEGORY(LOG_GraphPlottablesFactory, "GraphPlottablesFactory")
             namespace {
             /// Format for datetimes on a axis
             const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
             /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
             /// non-time data
             QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
             {
                 if (isTimeAxis) {
                     auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
                     dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
                     return dateTicker;
                 }
                 else {
                     // default ticker
                     return QSharedPointer<QCPAxisTicker>::create();
                 }
             }
             QCPAbstractPlottable *createScalarSeriesComponent(ScalarSeries &scalarSeries, QCustomPlot &plot)
             {
                 auto component = plot.addGraph();
                 if (component) {
                     // Graph data
                     component->setData(scalarSeries.xAxisData()->data(), scalarSeries.valuesData()->data(),
                                        true);
                     // Axes properties
                     /// @todo : for the moment, no control is performed on the axes: the units and the tickers
                     /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
                     auto setAxisProperties = [](auto axis, const auto &unit) {
                         // label (unit name)
                         axis->setLabel(unit.m_Name);
                         // ticker (depending on the type of unit)
                         axis->setTicker(axisTicker(unit.m_TimeUnit));
                     };
                     setAxisProperties(plot.xAxis, scalarSeries.xAxisUnit());
                     setAxisProperties(plot.yAxis, scalarSeries.valuesUnit());
                     // Display all data
                     component->rescaleAxes();
                     plot.replot();
                 }
                 else {
                     qCDebug(LOG_GraphPlottablesFactory())
                         << QObject::tr("Can't create graph for the scalar series");
                 }
                 return component;
             }
             } // namespace
-            QVector<QCPAbstractPlottable *> GraphPlottablesFactory::create(const Variable *variable,
+            QVector<QCPAbstractPlottable *> GraphPlottablesFactory::create(std::shared_ptr<Variable> variable,
                                                                            QCustomPlot &plot) noexcept
             {
                 auto result = QVector<QCPAbstractPlottable *>{};
                 if (variable) {
                     // Gets the data series of the variable to call the creation of the right components
                     // according to its type
                     if (auto scalarSeries = dynamic_cast<ScalarSeries *>(variable->dataSeries())) {
                         result.append(createScalarSeriesComponent(*scalarSeries, plot));
                     }
                     else {
                         qCDebug(LOG_GraphPlottablesFactory())
                             << QObject::tr("Can't create graph plottables : unmanaged data series type");
                     }
                 }
                 else {
                     qCDebug(LOG_GraphPlottablesFactory())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                 }
                 return result;
             }

gui/src/Visualization/VisualizationGraphWidget.cpp +1 -1

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/GraphPlottablesFactory.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Variable/Variable.h>
             #include <unordered_map>
             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_map<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMap;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 // 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);
             }
             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 = GraphPlottablesFactory::create(variable.get(), *ui->widget);
+                auto createdPlottables = GraphPlottablesFactory::create(variable, *ui->widget);
                 for (auto createdPlottable : qAsConst(createdPlottables)) {
                     impl->m_VariableToPlotMap.insert({variable, createdPlottable});
                 }
             }
             void VisualizationGraphWidget::accept(IVisualizationWidget *visitor)
             {
                 // TODO: manage the visitor
             }
             void VisualizationGraphWidget::close()
             {
                 // The main view cannot be directly closed.
                 return;
             }
             QString VisualizationGraphWidget::name() const
             {
                 return QStringLiteral("MainView");
             }
             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);
             }

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