GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r185:fa2e26651269

Merge branch 'feature/VariableModel4' into develop

Alexandre Leroux -

r185:fa2e26651269

parent child

Context file:

r185:fa2e26651269

Collapse all files

gui/include/Visualization/GraphPlottablesFactory.h created 644 +30 0

@@ -0,0 +1,30
	1	#ifndef SCIQLOP_GRAPHPLOTTABLESFACTORY_H
	2	#define SCIQLOP_GRAPHPLOTTABLESFACTORY_H
	3
	4	#include <QLoggingCategory>
	5	#include <QVector>
	6
	7	Q_DECLARE_LOGGING_CATEGORY(LOG_GraphPlottablesFactory)
	8
	9	class QCPAbstractPlottable;
	10	class QCustomPlot;
	11	class Variable;
	12
	13	/**
	14	* @brief The GraphPlottablesFactory class aims to create the QCustomPlot components relative to a
	15	* variable, depending on the data series of this variable
	16	*/
	17	struct GraphPlottablesFactory {
	18	/**
	19	* Creates (if possible) the QCustomPlot components relative to the variable passed in
	20	* parameter, and adds these to the plot passed in parameter.
	21	* @param variable the variable for which to create the components
	22	* @param plot the plot in which to add the created components. It takes ownership of these
	23	* components.
	24	* @return the list of the components created
	25	*/
	26	static QVector<QCPAbstractPlottable > create(const Variable variable,
	27	QCustomPlot &plot) noexcept;
	28	};
	29
	30	#endif // SCIQLOP_GRAPHPLOTTABLESFACTORY_H

gui/src/Visualization/GraphPlottablesFactory.cpp created 644 +91 0

@@ -0,0 +1,91
	1	#include "Visualization/GraphPlottablesFactory.h"
	2	#include "Visualization/qcustomplot.h"
	3
	4	#include <Data/ScalarSeries.h>
	5
	6	#include <Variable/Variable.h>
	7
	8	Q_LOGGING_CATEGORY(LOG_GraphPlottablesFactory, "GraphPlottablesFactory")
	9
	10	namespace {
	11
	12	/// Format for datetimes on a axis
	13	const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
	14
	15	/// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
	16	/// non-time data
	17	QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
	18	{
	19	if (isTimeAxis) {
	20	auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
	21	dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
	22
	23	return dateTicker;
	24	}
	25	else {
	26	// default ticker
	27	return QSharedPointer<QCPAxisTicker>::create();
	28	}
	29	}
	30
	31	QCPAbstractPlottable *createScalarSeriesComponent(ScalarSeries &scalarSeries, QCustomPlot &plot)
	32	{
	33	auto component = plot.addGraph();
	34
	35	if (component) {
	36	// Graph data
	37	component->setData(scalarSeries.xAxisData()->data(), scalarSeries.valuesData()->data(),
	38	true);
	39
	40	// Axes properties
	41	/// @todo : for the moment, no control is performed on the axes: the units and the tickers
	42	/// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
	43
	44	auto setAxisProperties = [](auto axis, const auto &unit) {
	45	// label (unit name)
	46	axis->setLabel(unit.m_Name);
	47
	48	// ticker (depending on the type of unit)
	49	axis->setTicker(axisTicker(unit.m_TimeUnit));
	50	};
	51	setAxisProperties(plot.xAxis, scalarSeries.xAxisUnit());
	52	setAxisProperties(plot.yAxis, scalarSeries.valuesUnit());
	53
	54	// Display all data
	55	component->rescaleAxes();
	56
	57	plot.replot();
	58	}
	59	else {
	60	qCDebug(LOG_GraphPlottablesFactory())
	61	<< QObject::tr("Can't create graph for the scalar series");
	62	}
	63
	64	return component;
	65	}
	66
	67	} // namespace
	68
	69	QVector<QCPAbstractPlottable > GraphPlottablesFactory::create(const Variable variable,
	70	QCustomPlot &plot) noexcept
	71	{
	72	auto result = QVector<QCPAbstractPlottable *>{};
	73
	74	if (variable) {
	75	// Gets the data series of the variable to call the creation of the right components
	76	// according to its type
	77	if (auto scalarSeries = dynamic_cast<ScalarSeries *>(variable->dataSeries())) {
	78	result.append(createScalarSeriesComponent(*scalarSeries, plot));
	79	}
	80	else {
	81	qCDebug(LOG_GraphPlottablesFactory())
	82	<< QObject::tr("Can't create graph plottables : unmanaged data series type");
	83	}
	84	}
	85	else {
	86	qCDebug(LOG_GraphPlottablesFactory())
	87	<< QObject::tr("Can't create graph plottables : the variable is null");
	88	}
	89
	90	return result;
	91	}

app/src/MainWindow.cpp +6 0

             /*------------------------------------------------------------------------------
             -- 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 <TimeWidget/TimeWidget.h>
+            #include <Variable/Variable.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"));
                 mainToolBar->addWidget(new TimeWidget{});
                 // Widgets / controllers connections
                 connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem *)),
                         m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem *)));
+                qRegisterMetaType<std::shared_ptr<Variable> >();
+                connect(&sqpApp->visualizationController(), SIGNAL(variableCreated(std::shared_ptr<Variable>)),
+                        m_Ui->view, SLOT(displayVariable(std::shared_ptr<Variable>)));
                 /*    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/Data/DataSeries.h +8 -8

             #ifndef SCIQLOP_DATASERIES_H
             #define SCIQLOP_DATASERIES_H
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <memory>
             /**
              * @brief The DataSeries class is the base (abstract) implementation of IDataSeries.
              *
              * It proposes to set a dimension for the values data
              *
              * @tparam Dim The dimension of the values data
              *
              */
             template <int Dim>
             class DataSeries : public IDataSeries {
             public:
                 /// @sa IDataSeries::xAxisData()
                 std::shared_ptr<ArrayData<1> > xAxisData() override { return m_XAxisData; }
                 /// @sa IDataSeries::xAxisUnit()
-                QString xAxisUnit() const override { return m_XAxisUnit; }
+                Unit xAxisUnit() const override { return m_XAxisUnit; }
                 /// @return the values dataset
                 std::shared_ptr<ArrayData<Dim> > valuesData() const { return m_ValuesData; }
                 /// @sa IDataSeries::valuesUnit()
-                QString valuesUnit() const override { return m_ValuesUnit; }
+                Unit valuesUnit() const override { return m_ValuesUnit; }
             protected:
                 /// Protected ctor (DataSeries is abstract)
-                explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, const QString &xAxisUnit,
+                explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, Unit xAxisUnit,
-                                    std::shared_ptr<ArrayData<Dim> > valuesData, const QString &valuesUnit)
+                                    std::shared_ptr<ArrayData<Dim> > valuesData, Unit valuesUnit)
                         : m_XAxisData{xAxisData},
-                          m_XAxisUnit{xAxisUnit},
+                          m_XAxisUnit{std::move(xAxisUnit)},
                           m_ValuesData{valuesData},
-                          m_ValuesUnit{valuesUnit}
+                          m_ValuesUnit{std::move(valuesUnit)}
                 {
                 }
             private:
                 std::shared_ptr<ArrayData<1> > m_XAxisData;
-                QString m_XAxisUnit;
+                Unit m_XAxisUnit;
                 std::shared_ptr<ArrayData<Dim> > m_ValuesData;
-                QString m_ValuesUnit;
+                Unit m_ValuesUnit;
             };
             #endif // SCIQLOP_DATASERIES_H

core/include/Data/IDataSeries.h +12 -2

             #ifndef SCIQLOP_IDATASERIES_H
             #define SCIQLOP_IDATASERIES_H
             #include <QString>
             #include <memory>
             template <int Dim>
             class ArrayData;
+            struct Unit {
+                explicit Unit(const QString &name = {}, bool timeUnit = false)
+                        : m_Name{name}, m_TimeUnit{timeUnit}
+                {
+                }
+                QString m_Name;  ///< Unit name
+                bool m_TimeUnit; ///< The unit is a unit of time
+            };
             /**
              * @brief The IDataSeries aims to declare a data series.
              *
              * A data series is an entity that contains at least :
              * - one dataset representing the x-axis
              * - one dataset representing the values
              *
              * Each dataset is represented by an ArrayData, and is associated with a unit.
              *
              * An ArrayData can be unidimensional or two-dimensional, depending on the implementation of the
              * IDataSeries. The x-axis dataset is always unidimensional.
              *
              * @sa ArrayData
              */
             class IDataSeries {
             public:
                 virtual ~IDataSeries() noexcept = default;
                 /// Returns the x-axis dataset
                 virtual std::shared_ptr<ArrayData<1> > xAxisData() = 0;
-                virtual QString xAxisUnit() const = 0;
+                virtual Unit xAxisUnit() const = 0;
-                virtual QString valuesUnit() const = 0;
+                virtual Unit valuesUnit() const = 0;
             };
             #endif // SCIQLOP_IDATASERIES_H

core/include/Data/ScalarSeries.h +1 -1

             #ifndef SCIQLOP_SCALARSERIES_H
             #define SCIQLOP_SCALARSERIES_H
             #include <Data/DataSeries.h>
             /**
              * @brief The ScalarSeries class is the implementation for a data series representing a scalar.
              */
             class ScalarSeries : public DataSeries<1> {
             public:
                 /**
                  * Ctor
                  * @param size the number of data the series will hold
                  * @param xAxisUnit x-axis unit
                  * @param valuesUnit values unit
                  */
-                explicit ScalarSeries(int size, const QString &xAxisUnit, const QString &valuesUnit);
+                explicit ScalarSeries(int size, Unit xAxisUnit, Unit valuesUnit);
                 /**
                  * Sets data for a specific index. The index has to be valid to be effective
                  * @param index the index to which the data will be set
                  * @param x the x-axis data
                  * @param value the value data
                  */
                 void setData(int index, double x, double value) noexcept;
             };
             #endif // SCIQLOP_SCALARSERIES_H

core/include/Variable/Variable.h +3 0

             #ifndef SCIQLOP_VARIABLE_H
             #define SCIQLOP_VARIABLE_H
             #include <Common/spimpl.h>
             #include <QObject>
             class IDataSeries;
             class QString;
             /**
              * @brief The Variable class represents a variable in SciQlop.
              */
             class Variable {
             public:
                 explicit Variable(const QString &name, const QString &unit, const QString &mission);
                 QString name() const noexcept;
                 QString mission() const noexcept;
                 QString unit() const noexcept;
                 void addDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept;
+                /// @return the data of the variable, nullptr if there is no data
+                IDataSeries *dataSeries() const noexcept;
             private:
                 class VariablePrivate;
                 spimpl::unique_impl_ptr<VariablePrivate> impl;
             };
             // Required for using shared_ptr in signals/slots
             Q_DECLARE_METATYPE(std::shared_ptr<Variable>)
             #endif // SCIQLOP_VARIABLE_H

core/include/Visualization/VisualizationController.h +4 -3

             #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();
-            public slots:
+            signals:
-                /// Slot called when a variable has been created in SciQlop
+                /// Signal emitted when a variable has been created in SciQlop
-                void onVariableCreated(std::shared_ptr<Variable> variable) noexcept;
+                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/Data/ScalarSeries.cpp +3 -3

             #include <Data/ScalarSeries.h>
-            ScalarSeries::ScalarSeries(int size, const QString &xAxisUnit, const QString &valuesUnit)
+            ScalarSeries::ScalarSeries(int size, Unit xAxisUnit, Unit valuesUnit)
-                    : DataSeries{std::make_shared<ArrayData<1> >(size), xAxisUnit,
+                    : DataSeries{std::make_shared<ArrayData<1> >(size), std::move(xAxisUnit),
-                                 std::make_shared<ArrayData<1> >(size), valuesUnit}
+                                 std::make_shared<ArrayData<1> >(size), std::move(valuesUnit)}
             {
             }
             void ScalarSeries::setData(int index, double x, double value) noexcept
             {
                 xAxisData()->setData(index, x);
                 valuesData()->setData(index, value);
             }

core/src/Variable/Variable.cpp +5 0

             #include "Variable/Variable.h"
             #include <Data/IDataSeries.h>
             struct Variable::VariablePrivate {
                 explicit VariablePrivate(const QString &name, const QString &unit, const QString &mission)
                         : m_Name{name}, m_Unit{unit}, m_Mission{mission}, m_DataSeries{nullptr}
                 {
                 }
                 QString m_Name;
                 QString m_Unit;
                 QString m_Mission;
                 std::unique_ptr<IDataSeries> m_DataSeries;
             };
             Variable::Variable(const QString &name, const QString &unit, const QString &mission)
                     : impl{spimpl::make_unique_impl<VariablePrivate>(name, unit, mission)}
             {
             }
             QString Variable::name() const noexcept
             {
                 return impl->m_Name;
             }
             QString Variable::mission() const noexcept
             {
                 return impl->m_Mission;
             }
             QString Variable::unit() const noexcept
             {
                 return impl->m_Unit;
             }
             void Variable::addDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept
             {
                 if (!impl->m_DataSeries) {
                     impl->m_DataSeries = std::move(dataSeries);
                 }
                 /// @todo : else, merge the two data series (if possible)
             }
+            IDataSeries *Variable::dataSeries() const noexcept
+            {
+                return impl->m_DataSeries.get();
+            }

core/src/Visualization/VisualizationController.cpp 0 -6

             #include <Visualization/VisualizationController.h>
             #include <Variable/Variable.h>
             #include <QMutex>
             #include <QThread>
             #include <QDir>
             #include <QStandardPaths>
             Q_LOGGING_CATEGORY(LOG_VisualizationController, "VisualizationController")
             class VisualizationController::VisualizationControllerPrivate {
             public:
                 QMutex m_WorkingMutex;
             };
             VisualizationController::VisualizationController(QObject *parent)
                     : impl{spimpl::make_unique_impl<VisualizationControllerPrivate>()}
             {
                 qCDebug(LOG_VisualizationController()) << tr("VisualizationController construction")
                                                        << QThread::currentThread();
             }
             VisualizationController::~VisualizationController()
             {
                 qCDebug(LOG_VisualizationController()) << tr("VisualizationController destruction")
                                                        << QThread::currentThread();
                 this->waitForFinish();
             }
-            void VisualizationController::onVariableCreated(std::shared_ptr<Variable> variable) noexcept
-                /// @todo ALX : make new graph for the variable
-                qCDebug(LOG_VisualizationController()) << "new variable to display";
             void VisualizationController::initialize()
             {
                 qCDebug(LOG_VisualizationController()) << tr("VisualizationController init")
                                                        << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VisualizationController()) << tr("VisualizationController init END");
             }
             void VisualizationController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VisualizationController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

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

             #ifndef SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include <QWidget>
             #include <memory>
             #include <Common/spimpl.h>
             class Variable;
             namespace Ui {
             class VisualizationGraphWidget;
             } // namespace Ui
             class VisualizationGraphWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationGraphWidget(QWidget *parent = 0);
                 virtual ~VisualizationGraphWidget();
                 void addVariable(std::shared_ptr<Variable> variable);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidget *visitor) override;
                 void close() override;
                 QString name() const;
             private:
                 Ui::VisualizationGraphWidget *ui;
                 class VisualizationGraphWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
+            private slots:
+                /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
+                void onMouseWheel(QWheelEvent *event) noexcept;
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H

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

             #ifndef SCIQLOP_VISUALIZATIONWIDGET_H
             #define SCIQLOP_VISUALIZATIONWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
+            class Variable;
             class VisualizationTabWidget;
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationWidget)
             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(IVisualizationWidget *visitor) override;
                 void close() override;
                 QString name() const;
+            public slots:
+                /**
+                 * Displays a variable in a new graph of a new zone of the current tab
+                 * @param variable the variable to display
+                 * @todo this is a temporary method that will be replaced by own actions for each type of
+                 * visualization widget
+                 */
+                void displayVariable(std::shared_ptr<Variable> variable) noexcept;
             private:
                 Ui::VisualizationWidget *ui;
             };
             #endif // VISUALIZATIONWIDGET_H

gui/src/SqpApplication.cpp +1 -1

             #include "SqpApplication.h"
             #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
             #include <QThread>
             #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_VariableController{std::make_unique<VariableController>()},
                           m_VisualizationController{std::make_unique<VisualizationController>()}
                 {
                     // /////////////////////////////// //
                     // Connections between controllers //
                     // /////////////////////////////// //
                     // VariableController <-> DataSourceController
                     qRegisterMetaType<std::shared_ptr<IDataProvider> >();
                     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
                     qRegisterMetaType<std::shared_ptr<Variable> >();
                     connect(m_VariableController.get(), SIGNAL(variableCreated(std::shared_ptr<Variable>)),
                             m_VisualizationController.get(),
-                            SLOT(onVariableCreated(std::shared_ptr<Variable>)));
+                            SIGNAL(variableCreated(std::shared_ptr<Variable>)));
                     m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
                     m_VariableController->moveToThread(&m_VariableControllerThread);
                     m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
                 }
                 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<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;
             }
             VariableController &SqpApplication::variableController() noexcept
             {
                 return *impl->m_VariableController;
             }
             VisualizationController &SqpApplication::visualizationController() noexcept
             {
                 return *impl->m_VisualizationController;
             }

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

             #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>, std::unique_ptr<QCPAbstractPlottable> >
+                std::unordered_map<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMap;
-                    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)
             {
-                // todo: first check is variable contains data then check how many plot have to be created
+                // Uses delegate to create the qcpplot components according to the variable
+                auto createdPlottables = GraphPlottablesFactory::create(variable.get(), *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);
+            }

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

             #include "Visualization/VisualizationWidget.h"
+            #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationTabWidget.h"
+            #include "Visualization/VisualizationZoneWidget.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);
                 addTabViewButton->setAutoRaise(true);
                 ui->tabWidget->setCornerWidget(addTabViewButton, Qt::TopRightCorner);
                 auto width = ui->tabWidget->cornerWidget()->width();
                 auto height = ui->tabWidget->cornerWidget()->height();
                 addTabViewButton->setMinimumHeight(height);
                 addTabViewButton->setMinimumWidth(width);
                 ui->tabWidget->setMinimumHeight(height);
                 ui->tabWidget->setMinimumWidth(width);
                 auto addTabView = [&]() {
                     auto index = ui->tabWidget->addTab(new VisualizationTabWidget(ui->tabWidget),
                                                        QString("View %1").arg(ui->tabWidget->count() + 1));
                     qCInfo(LOG_VisualizationWidget()) << tr("add the tab of index %1").arg(index);
                 };
                 auto removeTabView = [&](int index) {
                     ui->tabWidget->removeTab(index);
                     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);
             }
             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(IVisualizationWidget *visitor)
             {
                 // TODO: manage the visitor
             }
             void VisualizationWidget::close()
             {
                 // The main view cannot be directly closed.
                 return;
             }
             QString VisualizationWidget::name() const
             {
                 return QStringLiteral("MainView");
             }
+            void VisualizationWidget::displayVariable(std::shared_ptr<Variable> variable) noexcept
+            {
+                if (auto currentTab = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->currentWidget())) {
+                    if (auto newZone = currentTab->createZone()) {
+                        if (auto newGraph = newZone->createGraph()) {
+                            newGraph->addVariable(variable);
+                        }
+                        else {
+                            qCDebug(LOG_VisualizationWidget())
+                                << tr("Can't display the variable : can't create the graph");
+                        }
+                    }
+                    else {
+                        qCDebug(LOG_VisualizationWidget())
+                            << tr("Can't display the variable : can't create a new zone in the current tab");
+                    }
+                }
+                else {
+                    qCDebug(LOG_VisualizationWidget())
+                        << tr("Can't display the variable : there is no current tab");
+                }
+            }

plugins/mockplugin/src/CosinusProvider.cpp +1 -1

             #include "CosinusProvider.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <cmath>
             std::unique_ptr<IDataSeries>
             CosinusProvider::retrieveData(const DataProviderParameters &parameters) const
             {
                 // Gets the timerange from the parameters
                 auto start = parameters.m_TStart;
                 auto end = parameters.m_TEnd;
                 // We assure that timerange is valid
                 if (end < start) {
                     std::swap(start, end);
                 }
                 // Generates scalar series containing cosinus values (one value per second)
                 auto scalarSeries
-                    = std::make_unique<ScalarSeries>(end - start, QStringLiteral("t"), QStringLiteral(""));
+                    = std::make_unique<ScalarSeries>(end - start, Unit{QStringLiteral("t"), true}, Unit{});
                 auto dataIndex = 0;
                 for (auto time = start; time < end; ++time, ++dataIndex) {
                     scalarSeries->setData(dataIndex, time, std::cos(time));
                 }
                 return scalarSeries;
             }

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