GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r162:723bff6bece1

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

perrinel -

r162:723bff6bece1

parent child

Context file:

r162:723bff6bece1

Expand all files

core/include/Data/ArrayData.h created 644 +56 0

			@@ -0,0 +1,56
		1	#ifndef SCIQLOP_ARRAYDATA_H
		2	#define SCIQLOP_ARRAYDATA_H
		3
		4	#include <QVector>
		5
		6	/**
		7	* @brief The ArrayData class represents a dataset for a data series.
		8	*
		9	* A dataset can be unidimensional or two-dimensional. This property is determined by the Dim
		10	* template-parameter.
		11	*
		12	* @tparam Dim the dimension of the ArrayData (one or two)
		13	* @sa IDataSeries
		14	*/
		15	template <int Dim>
		16	class ArrayData {
		17	public:
		18	/**
		19	* Ctor for a unidimensional ArrayData
		20	* @param nbColumns the number of values the ArrayData will hold
		21	*/
		22	template <int D = Dim, typename = std::enable_if_t<D == 1> >
		23	explicit ArrayData(int nbColumns) : m_Data{1, QVector<double>{}}
		24	{
		25	m_Data[0].resize(nbColumns);
		26	}
		27
		28	/**
		29	* Sets a data at a specified index. The index has to be valid to be effective
		30	* @param index the index to which the data will be set
		31	* @param data the data to set
		32	* @remarks this method is only available for a unidimensional ArrayData
		33	*/
		34	template <int D = Dim, typename = std::enable_if_t<D == 1> >
		35	void setData(int index, double data) noexcept
		36	{
		37	if (index >= 0 && index < m_Data.at(0).size()) {
		38	m_Data[0].replace(index, data);
		39	}
		40	}
		41
		42	/**
		43	* @return the data as a vector
		44	* @remarks this method is only available for a unidimensional ArrayData
		45	*/
		46	template <int D = Dim, typename = std::enable_if_t<D == 1> >
		47	QVector<double> data() const noexcept
		48	{
		49	return m_Data.at(0);
		50	}
		51
		52	private:
		53	QVector<QVector<double> > m_Data;
		54	};
		55
		56	#endif // SCIQLOP_ARRAYDATA_H

core/include/Data/DataProviderParameters.h created 644 +16 0

			@@ -0,0 +1,16
		1	#ifndef SCIQLOP_DATAPROVIDERPARAMETERS_H
		2	#define SCIQLOP_DATAPROVIDERPARAMETERS_H
		3
		4	/**
		5	* @brief The DataProviderParameters struct holds the information needed to retrieve data from a
		6	* data provider
		7	* @sa IDataProvider
		8	*/
		9	struct DataProviderParameters {
		10	/// Start time
		11	double m_TStart;
		12	/// End time
		13	double m_TEnd;
		14	};
		15
		16	#endif // SCIQLOP_DATAPROVIDERPARAMETERS_H

core/include/Data/DataSeries.h created 644 +50 0

			@@ -0,0 +1,50
		1	#ifndef SCIQLOP_DATASERIES_H
		2	#define SCIQLOP_DATASERIES_H
		3
		4	#include <Data/ArrayData.h>
		5	#include <Data/IDataSeries.h>
		6
		7	#include <memory>
		8
		9	/**
		10	* @brief The DataSeries class is the base (abstract) implementation of IDataSeries.
		11	*
		12	* It proposes to set a dimension for the values data
		13	*
		14	* @tparam Dim The dimension of the values data
		15	*
		16	*/
		17	template <int Dim>
		18	class DataSeries : public IDataSeries {
		19	public:
		20	/// @sa IDataSeries::xAxisData()
		21	std::shared_ptr<ArrayData<1> > xAxisData() override { return m_XAxisData; }
		22
		23	/// @sa IDataSeries::xAxisUnit()
		24	QString xAxisUnit() const override { return m_XAxisUnit; }
		25
		26	/// @return the values dataset
		27	std::shared_ptr<ArrayData<Dim> > valuesData() const { return m_ValuesData; }
		28
		29	/// @sa IDataSeries::valuesUnit()
		30	QString valuesUnit() const override { return m_ValuesUnit; }
		31
		32	protected:
		33	/// Protected ctor (DataSeries is abstract)
		34	explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, const QString &xAxisUnit,
		35	std::shared_ptr<ArrayData<Dim> > valuesData, const QString &valuesUnit)
		36	: m_XAxisData{xAxisData},
		37	m_XAxisUnit{xAxisUnit},
		38	m_ValuesData{valuesData},
		39	m_ValuesUnit{valuesUnit}
		40	{
		41	}
		42
		43	private:
		44	std::shared_ptr<ArrayData<1> > m_XAxisData;
		45	QString m_XAxisUnit;
		46	std::shared_ptr<ArrayData<Dim> > m_ValuesData;
		47	QString m_ValuesUnit;
		48	};
		49
		50	#endif // SCIQLOP_DATASERIES_H

core/include/Data/IDataProvider.h created 644 +25 0

			@@ -0,0 +1,25
		1	#ifndef SCIQLOP_IDATAPROVIDER_H
		2	#define SCIQLOP_IDATAPROVIDER_H
		3
		4	#include <memory>
		5
		6	class DataProviderParameters;
		7	class IDataSeries;
		8
		9	/**
		10	* @brief The IDataProvider interface aims to declare a data provider.
		11	*
		12	* A data provider is an entity that generates data and returns it according to various parameters
		13	* (time interval, product to retrieve the data, etc.)
		14	*
		15	* @sa IDataSeries
		16	*/
		17	class IDataProvider {
		18	public:
		19	virtual ~IDataProvider() noexcept = default;
		20
		21	virtual std::unique_ptr<IDataSeries>
		22	retrieveData(const DataProviderParameters &parameters) const = 0;
		23	};
		24
		25	#endif // SCIQLOP_IDATAPROVIDER_H

core/include/Data/IDataSeries.h created 644 +37 0

			@@ -0,0 +1,37
		1	#ifndef SCIQLOP_IDATASERIES_H
		2	#define SCIQLOP_IDATASERIES_H
		3
		4	#include <QString>
		5
		6	#include <memory>
		7
		8	template <int Dim>
		9	class ArrayData;
		10
		11	/**
		12	* @brief The IDataSeries aims to declare a data series.
		13	*
		14	* A data series is an entity that contains at least :
		15	* - one dataset representing the x-axis
		16	* - one dataset representing the values
		17	*
		18	* Each dataset is represented by an ArrayData, and is associated with a unit.
		19	*
		20	* An ArrayData can be unidimensional or two-dimensional, depending on the implementation of the
		21	* IDataSeries. The x-axis dataset is always unidimensional.
		22	*
		23	* @sa ArrayData
		24	*/
		25	class IDataSeries {
		26	public:
		27	virtual ~IDataSeries() noexcept = default;
		28
		29	/// Returns the x-axis dataset
		30	virtual std::shared_ptr<ArrayData<1> > xAxisData() = 0;
		31
		32	virtual QString xAxisUnit() const = 0;
		33
		34	virtual QString valuesUnit() const = 0;
		35	};
		36
		37	#endif // SCIQLOP_IDATASERIES_H

core/include/Data/ScalarSeries.h created 644 +28 0

			@@ -0,0 +1,28
		1	#ifndef SCIQLOP_SCALARSERIES_H
		2	#define SCIQLOP_SCALARSERIES_H
		3
		4	#include <Data/DataSeries.h>
		5
		6	/**
		7	* @brief The ScalarSeries class is the implementation for a data series representing a scalar.
		8	*/
		9	class ScalarSeries : public DataSeries<1> {
		10	public:
		11	/**
		12	* Ctor
		13	* @param size the number of data the series will hold
		14	* @param xAxisUnit x-axis unit
		15	* @param valuesUnit values unit
		16	*/
		17	explicit ScalarSeries(int size, const QString &xAxisUnit, const QString &valuesUnit);
		18
		19	/**
		20	* Sets data for a specific index. The index has to be valid to be effective
		21	* @param index the index to which the data will be set
		22	* @param x the x-axis data
		23	* @param value the value data
		24	*/
		25	void setData(int index, double x, double value) noexcept;
		26	};
		27
		28	#endif // SCIQLOP_SCALARSERIES_H

core/include/DataSource/DataSourceItemAction.h created 644 +48 0

			@@ -0,0 +1,48
		1	#ifndef SCIQLOP_DATASOURCEITEMACTION_H
		2	#define SCIQLOP_DATASOURCEITEMACTION_H
		3
		4	#include <Common/spimpl.h>
		5
		6	#include <QLoggingCategory>
		7	#include <QObject>
		8
		9	Q_DECLARE_LOGGING_CATEGORY(LOG_DataSourceItemAction)
		10
		11	class DataSourceItem;
		12
		13	/**
		14	* @brief The DataSourceItemAction class represents an action on a data source item.
		15	*
		16	* An action is a function that will be executed when the slot execute() is called.
		17	*/
		18	class DataSourceItemAction : public QObject {
		19
		20	Q_OBJECT
		21
		22	public:
		23	/// Signature of the function associated to the action
		24	using ExecuteFunction = std::function<void(DataSourceItem &dataSourceItem)>;
		25
		26	/**
		27	* Ctor
		28	* @param name the name of the action
		29	* @param fun the function that will be called when the action is executed
		30	* @sa execute()
		31	*/
		32	explicit DataSourceItemAction(const QString &name, ExecuteFunction fun);
		33
		34	QString name() const noexcept;
		35
		36	/// Sets the data source item concerned by the action
		37	void setDataSourceItem(DataSourceItem *dataSourceItem) noexcept;
		38
		39	public slots:
		40	/// Executes the action
		41	void execute();
		42
		43	private:
		44	class DataSourceItemActionPrivate;
		45	spimpl::unique_impl_ptr<DataSourceItemActionPrivate> impl;
		46	};
		47
		48	#endif // SCIQLOP_DATASOURCEITEMACTION_H

core/include/Variable/Variable.h created 644 +20 0

			@@ -0,0 +1,20
		1	#ifndef SCIQLOP_VARIABLE_H
		2	#define SCIQLOP_VARIABLE_H
		3
		4	#include <QString>
		5
		6	/**
		7	* @brief The Variable struct represents a variable in SciQlop.
		8	*/
		9	struct Variable {
		10	explicit Variable(const QString &name, const QString &unit, const QString &mission)
		11	: m_Name{name}, m_Unit{unit}, m_Mission{mission}
		12	{
		13	}
		14
		15	QString m_Name;
		16	QString m_Unit;
		17	QString m_Mission;
		18	};
		19
		20	#endif // SCIQLOP_VARIABLE_H

core/include/Variable/VariableController.h created 644 +43 0

			@@ -0,0 +1,43
		1	#ifndef SCIQLOP_VARIABLECONTROLLER_H
		2	#define SCIQLOP_VARIABLECONTROLLER_H
		3
		4	#include <QLoggingCategory>
		5	#include <QObject>
		6
		7	#include <Common/spimpl.h>
		8
		9	class Variable;
		10	class VariableModel;
		11
		12	Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
		13
		14	/**
		15	* @brief The VariableController class aims to handle the variables in SciQlop.
		16	*/
		17	class VariableController : public QObject {
		18	Q_OBJECT
		19	public:
		20	explicit VariableController(QObject *parent = 0);
		21	virtual ~VariableController();
		22
		23	/**
		24	* Creates a new variable
		25	* @param name the name of the new variable
		26	* @return the variable if it was created successfully, nullptr otherwise
		27	*/
		28	Variable *createVariable(const QString &name) noexcept;
		29
		30	VariableModel *variableModel() noexcept;
		31
		32	public slots:
		33	void initialize();
		34	void finalize();
		35
		36	private:
		37	void waitForFinish();
		38
		39	class VariableControllerPrivate;
		40	spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
		41	};
		42
		43	#endif // SCIQLOP_VARIABLECONTROLLER_H

core/include/Variable/VariableModel.h created 644 +41 0

			@@ -0,0 +1,41
		1	#ifndef SCIQLOP_VARIABLEMODEL_H
		2	#define SCIQLOP_VARIABLEMODEL_H
		3
		4	#include <Common/spimpl.h>
		5
		6	#include <QAbstractTableModel>
		7	#include <QLoggingCategory>
		8
		9	Q_DECLARE_LOGGING_CATEGORY(LOG_VariableModel)
		10
		11	class Variable;
		12
		13	/**
		14	* @brief The VariableModel class aims to hold the variables that have been created in SciQlop
		15	*/
		16	class VariableModel : public QAbstractTableModel {
		17	public:
		18	explicit VariableModel(QObject *parent = nullptr);
		19
		20	/**
		21	* Creates a new variable in the model
		22	* @param name the name of the new variable
		23	* @return the variable if it was created successfully, nullptr otherwise
		24	*/
		25	Variable *createVariable(const QString &name) noexcept;
		26
		27	// /////////////////////////// //
		28	// QAbstractTableModel methods //
		29	// /////////////////////////// //
		30	virtual int columnCount(const QModelIndex &parent = QModelIndex{}) const override;
		31	virtual int rowCount(const QModelIndex &parent = QModelIndex{}) const override;
		32	virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
		33	virtual QVariant headerData(int section, Qt::Orientation orientation,
		34	int role = Qt::DisplayRole) const override;
		35
		36	private:
		37	class VariableModelPrivate;
		38	spimpl::unique_impl_ptr<VariableModelPrivate> impl;
		39	};
		40
		41	#endif // SCIQLOP_VARIABLEMODEL_H

core/src/Data/ScalarSeries.cpp created 644 +13 0

			@@ -0,0 +1,13
		1	#include <Data/ScalarSeries.h>
		2
		3	ScalarSeries::ScalarSeries(int size, const QString &xAxisUnit, const QString &valuesUnit)
		4	: DataSeries{std::make_shared<ArrayData<1> >(size), xAxisUnit,
		5	std::make_shared<ArrayData<1> >(size), valuesUnit}
		6	{
		7	}
		8
		9	void ScalarSeries::setData(int index, double x, double value) noexcept
		10	{
		11	xAxisData()->setData(index, x);
		12	valuesData()->setData(index, value);
		13	}

core/src/DataSource/DataSourceItemAction.cpp created 644 +42 0

			@@ -0,0 +1,42
		1	#include <DataSource/DataSourceItemAction.h>
		2
		3	Q_LOGGING_CATEGORY(LOG_DataSourceItemAction, "DataSourceItemAction")
		4
		5	struct DataSourceItemAction::DataSourceItemActionPrivate {
		6	explicit DataSourceItemActionPrivate(const QString &name,
		7	DataSourceItemAction::ExecuteFunction fun)
		8	: m_Name{name}, m_Fun{std::move(fun)}, m_DataSourceItem{nullptr}
		9	{
		10	}
		11
		12	QString m_Name;
		13	DataSourceItemAction::ExecuteFunction m_Fun;
		14	/// Item associated to the action (can be null, in which case the action will not be executed)
		15	DataSourceItem *m_DataSourceItem;
		16	};
		17
		18	DataSourceItemAction::DataSourceItemAction(const QString &name, ExecuteFunction fun)
		19	: impl{spimpl::make_unique_impl<DataSourceItemActionPrivate>(name, std::move(fun))}
		20	{
		21	}
		22
		23	QString DataSourceItemAction::name() const noexcept
		24	{
		25	return impl->m_Name;
		26	}
		27
		28	void DataSourceItemAction::setDataSourceItem(DataSourceItem *dataSourceItem) noexcept
		29	{
		30	impl->m_DataSourceItem = dataSourceItem;
		31	}
		32
		33	void DataSourceItemAction::execute()
		34	{
		35	if (impl->m_DataSourceItem) {
		36	impl->m_Fun(*impl->m_DataSourceItem);
		37	}
		38	else {
		39	qCDebug(LOG_DataSourceItemAction())
		40	<< tr("Can't execute action : no item has been associated");
		41	}
		42	}

core/src/Variable/VariableController.cpp created 644 +59 0

			@@ -0,0 +1,59
		1	#include <Variable/VariableController.h>
		2	#include <Variable/VariableModel.h>
		3
		4	#include <QMutex>
		5	#include <QThread>
		6
		7	Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
		8
		9	struct VariableController::VariableControllerPrivate {
		10	explicit VariableControllerPrivate(VariableController *parent)
		11	: m_WorkingMutex{}, m_VariableModel{new VariableModel{parent}}
		12	{
		13	}
		14
		15	QMutex m_WorkingMutex;
		16	/// Variable model. The VariableController has the ownership
		17	VariableModel *m_VariableModel;
		18	};
		19
		20	VariableController::VariableController(QObject *parent)
		21	: QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
		22	{
		23	qCDebug(LOG_VariableController()) << tr("VariableController construction")
		24	<< QThread::currentThread();
		25	}
		26
		27	VariableController::~VariableController()
		28	{
		29	qCDebug(LOG_VariableController()) << tr("VariableController destruction")
		30	<< QThread::currentThread();
		31	this->waitForFinish();
		32	}
		33
		34	Variable *VariableController::createVariable(const QString &name) noexcept
		35	{
		36	return impl->m_VariableModel->createVariable(name);
		37	}
		38
		39	VariableModel *VariableController::variableModel() noexcept
		40	{
		41	return impl->m_VariableModel;
		42	}
		43
		44	void VariableController::initialize()
		45	{
		46	qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
		47	impl->m_WorkingMutex.lock();
		48	qCDebug(LOG_VariableController()) << tr("VariableController init END");
		49	}
		50
		51	void VariableController::finalize()
		52	{
		53	impl->m_WorkingMutex.unlock();
		54	}
		55
		56	void VariableController::waitForFinish()
		57	{
		58	QMutexLocker locker{&impl->m_WorkingMutex};
		59	}

core/src/Variable/VariableModel.cpp created 644 +115 0

			@@ -0,0 +1,115
		1	#include <Variable/VariableModel.h>
		2
		3	#include <Variable/Variable.h>
		4
		5	Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
		6
		7	namespace {
		8
		9	// Column indexes
		10	const auto NAME_COLUMN = 0;
		11	const auto UNIT_COLUMN = 1;
		12	const auto MISSION_COLUMN = 2;
		13	const auto NB_COLUMNS = 3;
		14
		15	} // namespace
		16
		17	struct VariableModel::VariableModelPrivate {
		18	/// Variables created in SciQlop
		19	std::vector<std::unique_ptr<Variable> > m_Variables;
		20	};
		21
		22	VariableModel::VariableModel(QObject *parent)
		23	: QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
		24	{
		25	}
		26
		27	Variable *VariableModel::createVariable(const QString &name) noexcept
		28	{
		29	auto insertIndex = rowCount();
		30	beginInsertRows({}, insertIndex, insertIndex);
		31
		32	/// @todo For the moment, the other data of the variable is initialized with default values
		33	auto variable
		34	= std::make_unique<Variable>(name, QStringLiteral("unit"), QStringLiteral("mission"));
		35	impl->m_Variables.push_back(std::move(variable));
		36
		37	endInsertRows();
		38
		39	return impl->m_Variables.at(insertIndex).get();
		40	}
		41
		42	int VariableModel::columnCount(const QModelIndex &parent) const
		43	{
		44	Q_UNUSED(parent);
		45
		46	return NB_COLUMNS;
		47	}
		48
		49	int VariableModel::rowCount(const QModelIndex &parent) const
		50	{
		51	Q_UNUSED(parent);
		52
		53	return impl->m_Variables.size();
		54	}
		55
		56	QVariant VariableModel::data(const QModelIndex &index, int role) const
		57	{
		58	if (!index.isValid()) {
		59	return QVariant{};
		60	}
		61
		62	if (index.row() < 0 \|\| index.row() >= rowCount()) {
		63	return QVariant{};
		64	}
		65
		66	if (role == Qt::DisplayRole) {
		67	if (auto variable = impl->m_Variables.at(index.row()).get()) {
		68	switch (index.column()) {
		69	case NAME_COLUMN:
		70	return variable->m_Name;
		71	case UNIT_COLUMN:
		72	return variable->m_Unit;
		73	case MISSION_COLUMN:
		74	return variable->m_Mission;
		75	default:
		76	// No action
		77	break;
		78	}
		79
		80	qWarning(LOG_VariableModel())
		81	<< tr("Can't get data (unknown column %1)").arg(index.column());
		82	}
		83	else {
		84	qWarning(LOG_VariableModel()) << tr("Can't get data (no variable)");
		85	}
		86	}
		87
		88	return QVariant{};
		89	}
		90
		91	QVariant VariableModel::headerData(int section, Qt::Orientation orientation, int role) const
		92	{
		93	if (role != Qt::DisplayRole) {
		94	return QVariant{};
		95	}
		96
		97	if (orientation == Qt::Horizontal) {
		98	switch (section) {
		99	case NAME_COLUMN:
		100	return tr("Name");
		101	case UNIT_COLUMN:
		102	return tr("Unit");
		103	case MISSION_COLUMN:
		104	return tr("Mission");
		105	default:
		106	// No action
		107	break;
		108	}
		109
		110	qWarning(LOG_VariableModel())
		111	<< tr("Can't get header data (unknown column %1)").arg(section);
		112	}
		113
		114	return QVariant{};
		115	}

gui/include/TimeWidget/TimeWidget.h created 644 +21 0

			@@ -0,0 +1,21
		1	#ifndef SCIQLOP_TIMEWIDGET_H
		2	#define SCIQLOP_TIMEWIDGET_H
		3
		4	#include <QWidget>
		5
		6	namespace Ui {
		7	class TimeWidget;
		8	} // Ui
		9
		10	class TimeWidget : public QWidget {
		11	Q_OBJECT
		12
		13	public:
		14	explicit TimeWidget(QWidget *parent = 0);
		15	virtual ~TimeWidget();
		16
		17	private:
		18	Ui::TimeWidget *ui;
		19	};
		20
		21	#endif // SCIQLOP_ SQPSIDEPANE_H

gui/include/Variable/VariableInspectorWidget.h created 644 +26 0

			@@ -0,0 +1,26
		1	#ifndef SCIQLOP_VARIABLEINSPECTORWIDGET_H
		2	#define SCIQLOP_VARIABLEINSPECTORWIDGET_H
		3
		4	#include <QWidget>
		5
		6	namespace Ui {
		7	class VariableInspectorWidget;
		8	} // Ui
		9
		10	/**
		11	* @brief The VariableInspectorWidget class representes represents the variable inspector, from
		12	* which it is possible to view the loaded variables, handle them or trigger their display in
		13	* visualization
		14	*/
		15	class VariableInspectorWidget : public QWidget {
		16	Q_OBJECT
		17
		18	public:
		19	explicit VariableInspectorWidget(QWidget *parent = 0);
		20	virtual ~VariableInspectorWidget();
		21
		22	private:
		23	Ui::VariableInspectorWidget *ui;
		24	};
		25
		26	#endif // SCIQLOP_VARIABLEINSPECTORWIDGET_H

gui/include/Visualization/IVisualizationWidget.h created 644 +24 0

			@@ -0,0 +1,24
		1	#ifndef SCIQLOP_IVISUALIZATIONWIDGET_H
		2	#define SCIQLOP_IVISUALIZATIONWIDGET_H
		3
		4	#include "Visualization/IVisualizationWidgetVisitor.h"
		5
		6	#include <QString>
		7	#include <memory>
		8
		9	/**
		10	* @brief The IVisualizationWidget handles the visualization widget.
		11	*/
		12	class IVisualizationWidget {
		13
		14	public:
		15	virtual ~IVisualizationWidget() = default;
		16
		17	/// Initializes the plugin
		18	virtual void accept(IVisualizationWidget *visitor) = 0;
		19	virtual void close() = 0;
		20	virtual QString name() const = 0;
		21	};
		22
		23
		24	#endif // SCIQLOP_IVISUALIZATIONWIDGET_H

gui/include/Visualization/IVisualizationWidgetVisitor.h created 644 +25 0

			@@ -0,0 +1,25
		1	#ifndef SCIQLOP_IVISUALIZATIONWIDGETVISITOR_H
		2	#define SCIQLOP_IVISUALIZATIONWIDGETVISITOR_H
		3
		4
		5	class VisualizationWidget;
		6	class VisualizationTabWidget;
		7	class VisualizationZoneWidget;
		8	class VisualizationGraphWidget;
		9
		10	/**
		11	* @brief The IVisualizationWidgetVisitor handles the visualization widget vistor pattern.
		12	*/
		13	class IVisualizationWidgetVisitor {
		14
		15	public:
		16	virtual ~IVisualizationWidgetVisitor() = default;
		17
		18	virtual void visit(VisualizationWidget *widget) = 0;
		19	virtual void visit(VisualizationTabWidget *tabWidget) = 0;
		20	virtual void visit(VisualizationZoneWidget *zoneWidget) = 0;
		21	virtual void visit(VisualizationGraphWidget *graphWidget) = 0;
		22	};
		23
		24
		25	#endif // SCIQLOP_IVISUALIZATIONWIDGETVISITOR_H

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

NO CONTENT: new file 100644, binary diff hidden

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

NO CONTENT: new file 100644, binary diff hidden

gui/src/TimeWidget/TimeWidget.cpp created 644 +12 0

			@@ -0,0 +1,12
		1	#include "TimeWidget/TimeWidget.h"
		2	#include "ui_TimeWidget.h"
		3
		4	TimeWidget::TimeWidget(QWidget *parent) : QWidget{parent}, ui{new Ui::TimeWidget}
		5	{
		6	ui->setupUi(this);
		7	}
		8
		9	TimeWidget::~TimeWidget()
		10	{
		11	delete ui;
		12	}

gui/src/Variable/VariableInspectorWidget.cpp created 644 +26 0

			@@ -0,0 +1,26
		1	#include <Variable/VariableController.h>
		2	#include <Variable/VariableInspectorWidget.h>
		3	#include <Variable/VariableModel.h>
		4
		5	#include <ui_VariableInspectorWidget.h>
		6
		7	#include <QSortFilterProxyModel>
		8
		9	#include <SqpApplication.h>
		10
		11	VariableInspectorWidget::VariableInspectorWidget(QWidget *parent)
		12	: QWidget{parent}, ui{new Ui::VariableInspectorWidget}
		13	{
		14	ui->setupUi(this);
		15
		16	// Sets model for table
		17	auto sortFilterModel = new QSortFilterProxyModel{this};
		18	sortFilterModel->setSourceModel(sqpApp->variableController().variableModel());
		19
		20	ui->tableView->setModel(sortFilterModel);
		21	}
		22
		23	VariableInspectorWidget::~VariableInspectorWidget()
		24	{
		25	delete ui;
		26	}

gui/ui/TimeWidget/TimeWidget.ui created 644 +85 0

			@@ -0,0 +1,85
		1	<?xml version="1.0" encoding="UTF-8"?>
		2	<ui version="4.0">
		3	<class>TimeWidget</class>
		4	<widget class="QWidget" name="TimeWidget">
		5	<property name="geometry">
		6	<rect>
		7	<x>0</x>
		8	<y>0</y>
		9	<width>716</width>
		10	<height>48</height>
		11	</rect>
		12	</property>
		13	<property name="sizePolicy">
		14	<sizepolicy hsizetype="Fixed" vsizetype="Preferred">
		15	<horstretch>0</horstretch>
		16	<verstretch>0</verstretch>
		17	</sizepolicy>
		18	</property>
		19	<property name="windowTitle">
		20	<string>Form</string>
		21	</property>
		22	<layout class="QHBoxLayout" name="horizontalLayout_2">
		23	<item>
		24	<widget class="QLabel" name="label">
		25	<property name="sizePolicy">
		26	<sizepolicy hsizetype="Minimum" vsizetype="Preferred">
		27	<horstretch>0</horstretch>
		28	<verstretch>0</verstretch>
		29	</sizepolicy>
		30	</property>
		31	<property name="text">
		32	<string>TStart :</string>
		33	</property>
		34	</widget>
		35	</item>
		36	<item>
		37	<widget class="QDateTimeEdit" name="startDateTimeEdit">
		38	<property name="sizePolicy">
		39	<sizepolicy hsizetype="Preferred" vsizetype="Fixed">
		40	<horstretch>0</horstretch>
		41	<verstretch>0</verstretch>
		42	</sizepolicy>
		43	</property>
		44	<property name="displayFormat">
		45	<string>dd/MM/yyyy HH:mm:ss:zzz</string>
		46	</property>
		47	<property name="calendarPopup">
		48	<bool>true</bool>
		49	</property>
		50	</widget>
		51	</item>
		52	<item>
		53	<widget class="QLabel" name="label_2">
		54	<property name="sizePolicy">
		55	<sizepolicy hsizetype="Minimum" vsizetype="Preferred">
		56	<horstretch>0</horstretch>
		57	<verstretch>0</verstretch>
		58	</sizepolicy>
		59	</property>
		60	<property name="text">
		61	<string>TEnd :</string>
		62	</property>
		63	</widget>
		64	</item>
		65	<item>
		66	<widget class="QDateTimeEdit" name="endDateTimeEdit">
		67	<property name="sizePolicy">
		68	<sizepolicy hsizetype="Preferred" vsizetype="Fixed">
		69	<horstretch>0</horstretch>
		70	<verstretch>0</verstretch>
		71	</sizepolicy>
		72	</property>
		73	<property name="displayFormat">
		74	<string>dd/MM/yyyy HH:mm:ss:zzz</string>
		75	</property>
		76	<property name="calendarPopup">
		77	<bool>true</bool>
		78	</property>
		79	</widget>
		80	</item>
		81	</layout>
		82	</widget>
		83	<resources/>
		84	<connections/>
		85	</ui>

gui/ui/Variable/VariableInspectorWidget.ui created 644 +31 0

			@@ -0,0 +1,31
		1	<?xml version="1.0" encoding="UTF-8"?>
		2	<ui version="4.0">
		3	<class>VariableInspectorWidget</class>
		4	<widget class="QWidget" name="VariableInspectorWidget">
		5	<property name="geometry">
		6	<rect>
		7	<x>0</x>
		8	<y>0</y>
		9	<width>400</width>
		10	<height>300</height>
		11	</rect>
		12	</property>
		13	<property name="windowTitle">
		14	<string>Variables</string>
		15	</property>
		16	<layout class="QGridLayout" name="gridLayout">
		17	<item row="0" column="0">
		18	<widget class="QTableView" name="tableView">
		19	<property name="sortingEnabled">
		20	<bool>true</bool>
		21	</property>
		22	<attribute name="horizontalHeaderStretchLastSection">
		23	<bool>true</bool>
		24	</attribute>
		25	</widget>
		26	</item>
		27	</layout>
		28	</widget>
		29	<resources/>
		30	<connections/>
		31	</ui>

plugins/mockplugin/include/CosinusProvider.h created 644 +16 0

			@@ -0,0 +1,16
		1	#ifndef SCIQLOP_COSINUSPROVIDER_H
		2	#define SCIQLOP_COSINUSPROVIDER_H
		3
		4	#include <Data/IDataProvider.h>
		5
		6	/**
		7	* @brief The CosinusProvider class is an example of how a data provider can generate data
		8	*/
		9	class CosinusProvider : public IDataProvider {
		10	public:
		11	/// @sa IDataProvider::retrieveData()
		12	std::unique_ptr<IDataSeries>
		13	retrieveData(const DataProviderParameters &parameters) const override;
		14	};
		15
		16	#endif // SCIQLOP_COSINUSPROVIDER_H

plugins/mockplugin/src/CosinusProvider.cpp created 644 +30 0

			@@ -0,0 +1,30
		1	#include "CosinusProvider.h"
		2
		3	#include <Data/DataProviderParameters.h>
		4	#include <Data/ScalarSeries.h>
		5
		6	#include <cmath>
		7
		8	std::unique_ptr<IDataSeries>
		9	CosinusProvider::retrieveData(const DataProviderParameters &parameters) const
		10	{
		11	// Gets the timerange from the parameters
		12	auto start = parameters.m_TStart;
		13	auto end = parameters.m_TEnd;
		14
		15	// We assure that timerange is valid
		16	if (end < start) {
		17	std::swap(start, end);
		18	}
		19
		20	// Generates scalar series containing cosinus values (one value per second)
		21	auto scalarSeries
		22	= std::make_unique<ScalarSeries>(end - start, QStringLiteral("t"), QStringLiteral(""));
		23
		24	auto dataIndex = 0;
		25	for (auto time = start; time < end; ++time, ++dataIndex) {
		26	scalarSeries->setData(dataIndex, time, std::cos(time));
		27	}
		28
		29	return scalarSeries;
		30	}

app/src/MainWindow.cpp +63 -54

              #include <DataSource/DataSourceWidget.h>
              #include <SidePane/SqpSidePane.h>
              #include <SqpApplication.h>
+             #include <TimeWidget/TimeWidget.h>
              #include <QAction>
              #include <QDate>
              #include <QDir>
              #include <QFileDialog>
              #include <QToolBar>
+             #include <QToolButton>
              #include <memory.h>
              //#include <omp.h>
                  m_Ui->splitter->setCollapsible(LEFTINSPECTORSIDEPANESPLITTERINDEX, false);
                  m_Ui->splitter->setCollapsible(RIGHTINSPECTORSIDEPANESPLITTERINDEX, false);
-                 // NOTE: These lambda could be factorized. Be careful of theirs parameters
-                 // Lambda that defines what's happened when clicking on the leftSidePaneInspector open button
-                 auto openLeftInspector = [this](bool checked) {
-                     // Update of the last opened geometry
-                     if (checked) {
-                         impl->m_LastOpenLeftInspectorSize = m_Ui->leftMainInspectorWidget->size();
+                     }
+                 auto leftSidePane = m_Ui->leftInspectorSidePane->sidePane();
+                 auto openLeftInspectorAction = new QAction{QIcon{
+                                                                ":/icones/previous.png",
+                                                            },
+                                                            tr("Show/hide the left inspector"), this};
-                     auto startSize = impl->m_LastOpenLeftInspectorSize;
-                     auto endSize = startSize;
-                     endSize.setWidth(0);
-                     auto currentSizes = m_Ui->splitter->sizes();
-                     if (checked) {
-                         // adjust sizes individually here, e.g.
-                         currentSizes[LEFTMAININSPECTORWIDGETSPLITTERINDEX]
-                             -= impl->m_LastOpenLeftInspectorSize.width();
-                         currentSizes[VIEWPLITTERINDEX] += impl->m_LastOpenLeftInspectorSize.width();
-                         m_Ui->splitter->setSizes(currentSizes);
+                     }
-                     else {
-                         // adjust sizes individually here, e.g.
-                         currentSizes[LEFTMAININSPECTORWIDGETSPLITTERINDEX]
-                             += impl->m_LastOpenLeftInspectorSize.width();
-                         currentSizes[VIEWPLITTERINDEX] -= impl->m_LastOpenLeftInspectorSize.width();
-                         m_Ui->splitter->setSizes(currentSizes);
+                     }
+                 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"});
-                 // Lambda that defines what's happened when clicking on the SidePaneInspector open button
-                 auto openRightInspector = [this](bool checked) {
+                     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) {
-                         impl->m_LastOpenRightInspectorSize = m_Ui->rightMainInspectorWidget->size();
+                         lastInspectorSize = nextInspectorSize;
                      }
-                     auto startSize = impl->m_LastOpenRightInspectorSize;
+                     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[RIGHTMAININSPECTORWIDGETSPLITTERINDEX]
-                             -= impl->m_LastOpenRightInspectorSize.width();
-                         currentSizes[VIEWPLITTERINDEX] += impl->m_LastOpenRightInspectorSize.width();
+                         currentSizes[splitterInspectorIndex] -= lastInspectorSize.width();
+                         currentSizes[VIEWPLITTERINDEX] += lastInspectorSize.width();
                          m_Ui->splitter->setSizes(currentSizes);
                      }
                      else {
                          // adjust sizes individually here, e.g.
-                         currentSizes[RIGHTMAININSPECTORWIDGETSPLITTERINDEX]
-                             += impl->m_LastOpenRightInspectorSize.width();
-                         currentSizes[VIEWPLITTERINDEX] -= impl->m_LastOpenRightInspectorSize.width();
+                         currentSizes[splitterInspectorIndex] += lastInspectorSize.width();
+                         currentSizes[VIEWPLITTERINDEX] -= lastInspectorSize.width();
                          m_Ui->splitter->setSizes(currentSizes);
                      }
                  };
-                 QToolBar *leftSidePane = m_Ui->leftInspectorSidePane->sidePane();
-                 auto openLeftInspectorAction = leftSidePane->addAction(
-                     QIcon{
-                         ":/icones/openInspector.png",
-                     },
-                     tr("Show/hide the left inspector"), openLeftInspector);
-                 openLeftInspectorAction->setCheckable(true);
-                 auto rightSidePane = m_Ui->rightInspectorSidePane->sidePane();
-                 auto openRightInspectorAction = rightSidePane->addAction(
-                     QIcon{
-                         ":/icones/openInspector.png",
-                     },
-                     tr("Show/hide the right inspector"), openRightInspector);
-                 openRightInspectorAction->setCheckable(true);
+                 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->addAction(QStringLiteral("A1"));
+                 mainToolBar->addWidget(new TimeWidget{});
                  // Widgets / controllers connections
                  connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem *)),

app/ui/MainWindow.ui +8 -2

                       <widget class="QWidget" name="dateTimeWidget" native="true"/>
                      </item>
                      <item>
-                      <widget class="QWidget" name="variableInspectorWidget" native="true"/>
+                      <widget class="VariableInspectorWidget" name="variableInspectorWidget" native="true"/>
                      </item>
                     </layout>
                    </widget>
                   <x>0</x>
                   <y>0</y>
                   <width>800</width>
-                  <height>28</height>
+                  <height>26</height>
                  </rect>
                 </property>
                </widget>
                 <header location="global">DataSource/DataSourceWidget.h</header>
                 <container>1</container>
                </customwidget>
+               <customwidget>
+                <class>VariableInspectorWidget</class>
+                <extends>QWidget</extends>
+                <header location="global">Variable/VariableInspectorWidget.h</header>
+                <container>1</container>
+               </customwidget>
               </customwidgets>
               <resources/>
               <connections/>

core/include/DataSource/DataSourceController.h +18 0

              Q_DECLARE_LOGGING_CATEGORY(LOG_DataSourceController)
              class DataSourceItem;
+             class IDataProvider;
              /**
               * @brief The DataSourceController class aims to make the link between SciQlop and its plugins. This
                  void setDataSourceItem(const QUuid &dataSourceUid,
                                         std::unique_ptr<DataSourceItem> dataSourceItem) noexcept;
+                 /**
+                  * Sets the data provider used to retrieve data from of a data source. The controller takes
+                  * ownership of the provider.
+                  * @param dataSourceUid the unique id with which the data source has been registered into the
+                  * controller. If it is invalid, the method has no effect.
+                  * @param dataProvider the provider of the data source
+                  * @sa registerDataSource()
+                  */
+                 void setDataProvider(const QUuid &dataSourceUid,
+                                      std::unique_ptr<IDataProvider> dataProvider) noexcept;
+                 /**
+                  * Loads an item (product) as a variable in SciQlop
+                  * @param productItem the item to load
+                  */
+                 void loadProductItem(const DataSourceItem &productItem) noexcept;
              public slots:
                  /// Manage init/end of the controller
                  void initialize();

core/include/DataSource/DataSourceItem.h +14 0

              #include <QVariant>
              #include <QVector>
+             class DataSourceItemAction;
              /**
               * Possible types of an item
               */
              public:
                  explicit DataSourceItem(DataSourceItemType type, QVector<QVariant> data = {});
+                 /// @return the actions of the item as a vector
+                 QVector<DataSourceItemAction *> actions() const noexcept;
+                 /**
+                  * Adds an action to the item. The item takes ownership of the action, and the action is
+                  * automatically associated to the item
+                  * @param action the action to add
+                  */
+                 void addAction(std::unique_ptr<DataSourceItemAction> action) noexcept;
                  /**
                   * Adds a child to the item. The item takes ownership of the child.
                   * @param child the child to add
                   */
                  QVariant data(int dataIndex) const noexcept;
+                 QString name() const noexcept;
                  /**
                   * Get the item's parent
                   * @return a pointer to the parent if it exists, nullptr if the item is a root

core/src/DataSource/DataSourceController.cpp +22 0

              #include <DataSource/DataSourceController.h>
              #include <DataSource/DataSourceItem.h>
+             #include <Data/IDataProvider.h>
              #include <QMutex>
              #include <QThread>
                  QHash<QUuid, QString> m_DataSources;
                  /// Data sources structures
                  std::map<QUuid, std::unique_ptr<DataSourceItem> > m_DataSourceItems;
+                 /// Data providers registered
+                 std::map<QUuid, std::unique_ptr<IDataProvider> > m_DataProviders;
              };
              DataSourceController::DataSourceController(QObject *parent)
                  }
              }
+             void DataSourceController::setDataProvider(const QUuid &dataSourceUid,
+                                                        std::unique_ptr<IDataProvider> dataProvider) noexcept
+             {
+                 if (impl->m_DataSources.contains(dataSourceUid)) {
+                     impl->m_DataProviders.insert(std::make_pair(dataSourceUid, std::move(dataProvider)));
+                 }
+                 else {
+                     qCWarning(LOG_DataSourceController()) << tr("Can't set data provider for uid %1 : no data "
+                                                                 "source has been registered with the uid")
+                                                                  .arg(dataSourceUid.toString());
+                 }
+             }
+             void DataSourceController::loadProductItem(const DataSourceItem &productItem) noexcept
+             {
+                 /// @todo ALX
+             }
              void DataSourceController::initialize()
              {
                  qCDebug(LOG_DataSourceController()) << tr("DataSourceController init")

core/src/DataSource/DataSourceItem.cpp +31 -1

              #include <DataSource/DataSourceItem.h>
+             #include <DataSource/DataSourceItemAction.h>
              #include <QVector>
+             namespace {
+             /// Index of the 'name' value in the item
+             const auto NAME_INDEX = 0;
+             } // namespace
              struct DataSourceItem::DataSourceItemPrivate {
                  explicit DataSourceItemPrivate(DataSourceItemType type, QVector<QVariant> data)
-                         : m_Parent{nullptr}, m_Children{}, m_Type{type}, m_Data{std::move(data)}
+                         : m_Parent{nullptr}, m_Children{}, m_Type{type}, m_Data{std::move(data)}, m_Actions{}
                  {
                  }
                  std::vector<std::unique_ptr<DataSourceItem> > m_Children;
                  DataSourceItemType m_Type;
                  QVector<QVariant> m_Data;
+                 std::vector<std::unique_ptr<DataSourceItemAction> > m_Actions;
              };
              DataSourceItem::DataSourceItem(DataSourceItemType type, QVector<QVariant> data)
              {
              }
+             QVector<DataSourceItemAction *> DataSourceItem::actions() const noexcept
+             {
+                 QVector<DataSourceItemAction *> result{};
+                 std::transform(std::cbegin(impl->m_Actions), std::cend(impl->m_Actions),
+                                std::back_inserter(result), [](const auto &action) { return action.get(); });
+                 return result;
+             }
+             void DataSourceItem::addAction(std::unique_ptr<DataSourceItemAction> action) noexcept
+             {
+                 action->setDataSourceItem(this);
+                 impl->m_Actions.push_back(std::move(action));
+             }
              void DataSourceItem::appendChild(std::unique_ptr<DataSourceItem> child) noexcept
              {
                  child->impl->m_Parent = this;
                  return impl->m_Data.value(dataIndex);
              }
+             QString DataSourceItem::name() const noexcept
+             {
+                 return data(NAME_INDEX).toString();
+             }
              DataSourceItem *DataSourceItem::parentItem() const noexcept
              {
                  return impl->m_Parent;

core/vera-exclusions/exclusions.txt +7 0

              # Ignore false positive relative to two class definitions in a same file
              DataSourceItem\.h:\d+:.*IPSIS_S01.*
+             # Ignore false positive relative to a template class
+             ArrayData\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (D)
+             ArrayData\.h:\d+:.*IPSIS_S06.*found: (D)
+             ArrayData\.h:\d+:.*IPSIS_S06.*found: (Dim)
+             # Ignore false positive relative to an alias
+             DataSourceItemAction\.h:\d+:.*IPSIS_S06.*found: (ExecuteFunction)

gui/include/DataSource/DataSourceTreeWidgetItem.h +3 0

                  virtual QVariant data(int column, int role) const override;
                  virtual void setData(int column, int role, const QVariant &value) override;
+                 /// @return the actions associated to the item
+                 QList<QAction *> actions() const noexcept;
              private:
                  class DataSourceTreeWidgetItemPrivate;
                  spimpl::unique_impl_ptr<DataSourceTreeWidgetItemPrivate> impl;

gui/include/DataSource/DataSourceWidget.h +9 -4

              #ifndef SCIQLOP_DATASOURCEWIDGET_H
              #define SCIQLOP_DATASOURCEWIDGET_H
-             #include <Common/spimpl.h>
              #include <QWidget>
+             namespace Ui {
+             class DataSourceWidget;
+             } // Ui
              class DataSourceItem;
              /**
                  void addDataSource(DataSourceItem *dataSource) noexcept;
              private:
-                 class DataSourceWidgetPrivate;
-                 spimpl::unique_impl_ptr<DataSourceWidgetPrivate> impl;
+                 Ui::DataSourceWidget *ui;
+             private slots:
+                 /// Slot called when right clicking on an item in the tree (displays a menu)
+                 void onTreeMenuRequested(const QPoint &pos) noexcept;
              };
              #endif // SCIQLOP_DATASOURCEWIDGET_H

gui/include/SqpApplication.h +4 -2

              #define sqpApp (static_cast<SqpApplication *>(QCoreApplication::instance()))
              class DataSourceController;
+             class VariableController;
              class VisualizationController;
              /**
                  void initialize();
                  /// Accessors for the differents sciqlop controllers
-                 DataSourceController &dataSourceController() const noexcept;
-                 VisualizationController &visualizationController() const noexcept;
+                 DataSourceController &dataSourceController() noexcept;
+                 VariableController &variableController() noexcept;
+                 VisualizationController &visualizationController() noexcept;
              private:
                  class SqpApplicationPrivate;

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

              #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 {
+             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;
              };
              #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H

gui/include/Visualization/VisualizationTabWidget.h +19 -1

              #ifndef SCIQLOP_VISUALIZATIONTABWIDGET_H
              #define SCIQLOP_VISUALIZATIONTABWIDGET_H
+             #include "Visualization/IVisualizationWidget.h"
              #include <QWidget>
+             class VisualizationZoneWidget;
              namespace Ui {
              class VisualizationTabWidget;
              } // namespace Ui
-             class VisualizationTabWidget : public QWidget {
+             class VisualizationTabWidget : public QWidget, public IVisualizationWidget {
                  Q_OBJECT
              public:
                  explicit VisualizationTabWidget(QWidget *parent = 0);
                  virtual ~VisualizationTabWidget();
+                 /// Add a zone widget
+                 void addZone(VisualizationZoneWidget *zoneWidget);
+                 /// Create a zone using a Variable
+                 VisualizationZoneWidget *createZone();
+                 /// Remove a zone
+                 void removeZone(VisualizationZoneWidget *zone);
+                 // IVisualizationWidget interface
+                 void accept(IVisualizationWidget *visitor) override;
+                 void close() override;
+                 QString name() const override;
              private:
                  Ui::VisualizationTabWidget *ui;
              };

gui/include/Visualization/VisualizationWidget.h +19 -1

              #ifndef SCIQLOP_VISUALIZATIONWIDGET_H
              #define SCIQLOP_VISUALIZATIONWIDGET_H
+             #include "Visualization/IVisualizationWidget.h"
              #include <QLoggingCategory>
              #include <QWidget>
+             class VisualizationTabWidget;
              Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationWidget)
              namespace Ui {
              class VisualizationWidget;
              } // namespace Ui
-             class VisualizationWidget : public QWidget {
+             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;
              private:
                  Ui::VisualizationWidget *ui;
              };

gui/include/Visualization/VisualizationZoneWidget.h +19 -1

              #ifndef SCIQLOP_VISUALIZATIONZONEWIDGET_H
              #define SCIQLOP_VISUALIZATIONZONEWIDGET_H
+             #include "Visualization/IVisualizationWidget.h"
+             class VisualizationGraphWidget;
              #include <QWidget>
              namespace Ui {
              class VisualizationZoneWidget;
              } // Ui
-             class VisualizationZoneWidget : public QWidget {
+             class VisualizationZoneWidget : public QWidget, public IVisualizationWidget {
                  Q_OBJECT
              public:
                  explicit VisualizationZoneWidget(QWidget *parent = 0);
                  virtual ~VisualizationZoneWidget();
+                 /// Add a graph widget
+                 void addGraph(VisualizationGraphWidget *graphWidget);
+                 /// Create a graph using a Variable
+                 VisualizationGraphWidget *createGraph();
+                 /// Remove a graph
+                 void removeGraph(VisualizationGraphWidget *graph);
+                 // IVisualizationWidget interface
+                 void accept(IVisualizationWidget *visitor) override;
+                 void close() override;
+                 QString name() const override;
              private:
                  Ui::VisualizationZoneWidget *ui;
              };

gui/resources/sqpguiresources.qrc +2 0

              <RCC>
                  <qresource prefix="/">
                      <file>icones/openInspector.png</file>
+                     <file>icones/next.png</file>
+                     <file>icones/previous.png</file>
                  </qresource>
              </RCC>

gui/src/DataSource/DataSourceTreeWidgetItem.cpp +26 0

              #include <DataSource/DataSourceItem.h>
+             #include <DataSource/DataSourceItemAction.h>
              #include <DataSource/DataSourceTreeWidgetItem.h>
              #include <SqpApplication.h>
+             #include <QAction>
              Q_LOGGING_CATEGORY(LOG_DataSourceTreeWidgetItem, "DataSourceTreeWidgetItem")
              namespace {
                  /// Model used to retrieve data source information
                  const DataSourceItem *m_Data;
+                 /// Actions associated to the item. The parent of the item (QTreeWidget) takes the ownership of
+                 /// the actions
+                 QList<QAction *> m_Actions;
              };
              DataSourceTreeWidgetItem::DataSourceTreeWidgetItem(const DataSourceItem *data, int type)
              {
                  // Sets the icon depending on the data source
                  setIcon(0, itemIcon(impl->m_Data));
+                 // Generates tree actions based on the item actions
+                 auto createTreeAction = [this, &parent](const auto &itemAction) {
+                     auto treeAction = new QAction{itemAction->name(), parent};
+                     // Executes item action when tree action is triggered
+                     QObject::connect(treeAction, &QAction::triggered, itemAction,
+                                      &DataSourceItemAction::execute);
+                     return treeAction;
+                 };
+                 auto itemActions = impl->m_Data->actions();
+                 std::transform(std::cbegin(itemActions), std::cend(itemActions),
+                                std::back_inserter(impl->m_Actions), createTreeAction);
              }
              QVariant DataSourceTreeWidgetItem::data(int column, int role) const
                      QTreeWidgetItem::setData(column, role, value);
                  }
              }
+             QList<QAction *> DataSourceTreeWidgetItem::actions() const noexcept
+             {
+                 return impl->m_Actions;
+             }

gui/src/DataSource/DataSourceWidget.cpp +26 -17

              #include <DataSource/DataSourceItem.h>
              #include <DataSource/DataSourceTreeWidgetItem.h>
+             #include <QMenu>
              namespace {
              /// Number of columns displayed in the tree
              } // namespace
-             class DataSourceWidget::DataSourceWidgetPrivate {
-             public:
-                 explicit DataSourceWidgetPrivate(DataSourceWidget &widget)
-                         : m_Ui{std::make_unique<Ui::DataSourceWidget>()}
+                 {
-                     m_Ui->setupUi(&widget);
-                     // Set tree properties
-                     m_Ui->treeWidget->setColumnCount(TREE_NB_COLUMNS);
-                     m_Ui->treeWidget->setHeaderLabels(TREE_HEADER_LABELS);
+                 }
+             DataSourceWidget::DataSourceWidget(QWidget *parent) : QWidget{parent}, ui{new Ui::DataSourceWidget}
+             {
+                 ui->setupUi(this);
-                 std::unique_ptr<Ui::DataSourceWidget> m_Ui;
-             };
+                 // Set tree properties
+                 ui->treeWidget->setColumnCount(TREE_NB_COLUMNS);
+                 ui->treeWidget->setHeaderLabels(TREE_HEADER_LABELS);
+                 ui->treeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
-             DataSourceWidget::DataSourceWidget(QWidget *parent)
-                     : QWidget{parent}, impl{spimpl::make_unique_impl<DataSourceWidgetPrivate>(*this)}
+             {
+                 // Connection to show a menu when right clicking on the tree
+                 connect(ui->treeWidget, &QTreeWidget::customContextMenuRequested, this,
+                         &DataSourceWidget::onTreeMenuRequested);
              }
              void DataSourceWidget::addDataSource(DataSourceItem *dataSource) noexcept
                  // Creates the item associated to the source and adds it to the tree widget. The tree widget
                  // takes the ownership of the item
                  if (dataSource) {
-                     impl->m_Ui->treeWidget->addTopLevelItem(createTreeWidgetItem(dataSource));
+                     ui->treeWidget->addTopLevelItem(createTreeWidgetItem(dataSource));
+                 }
+             }
+             void DataSourceWidget::onTreeMenuRequested(const QPoint &pos) noexcept
+             {
+                 // Retrieves the selected item in the tree, and build the menu from its actions
+                 if (auto selectedItem = dynamic_cast<DataSourceTreeWidgetItem *>(ui->treeWidget->itemAt(pos))) {
+                     QMenu treeMenu{};
+                     treeMenu.addActions(selectedItem->actions());
+                     if (!treeMenu.isEmpty()) {
+                         treeMenu.exec(mapToGlobal(pos));
+                     }
                  }
              }

gui/src/SidePane/SqpSidePane.cpp 0 -7

                  this->layout()->addWidget(m_SidePaneToolbar);
                  m_SidePaneToolbar->setStyleSheet(SQPSIDEPANESTYLESHEET);
-                 this->setStyleSheet(
-                     " QWidget {"
-                     "background: red;"
-                     "border: 1px;"
-                     " }");
              }
              SqpSidePane::~SqpSidePane()

gui/src/SqpApplication.cpp +21 -2

              #include <DataSource/DataSourceController.h>
              #include <QThread>
+             #include <Variable/VariableController.h>
              #include <Visualization/VisualizationController.h>
              Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
              public:
                  SqpApplicationPrivate()
                          : m_DataSourceController{std::make_unique<DataSourceController>()},
+                           m_VariableController{std::make_unique<VariableController>()},
                            m_VisualizationController{std::make_unique<VisualizationController>()}
                  {
                      m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
+                     m_VariableController->moveToThread(&m_VariableControllerThread);
                      m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
                  }
                      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;
              };
                  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_DataSourceControllerThread.start();
+                 impl->m_VariableControllerThread.start();
                  impl->m_VisualizationControllerThread.start();
              }
              {
              }
-             DataSourceController &SqpApplication::dataSourceController() const noexcept
+             DataSourceController &SqpApplication::dataSourceController() noexcept
              {
                  return *impl->m_DataSourceController;
              }
-             VisualizationController &SqpApplication::visualizationController() const noexcept
+             VariableController &SqpApplication::variableController() noexcept
+             {
+                 return *impl->m_VariableController;
+             }
+             VisualizationController &SqpApplication::visualizationController() noexcept
              {
                  return *impl->m_VisualizationController;
              }

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

		@@ -1,8 +1,21
1	1	#include "Visualization/VisualizationGraphWidget.h"
2	2	#include "ui_VisualizationGraphWidget.h"
3	3
	4	#include <Variable/Variable.h>
	5
	6	#include <unordered_map>
	7
	8	struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
	9
	10	// 1 variable -> n qcpplot
	11	std::unordered_map<std::shared_ptr<Variable>, std::unique_ptr<QCPAbstractPlottable> >
	12	m_VariableToPlotMap;
	13	};
	14
4	15	VisualizationGraphWidget::VisualizationGraphWidget(QWidget *parent)
5		: QWidget(parent), ui(new Ui::VisualizationGraphWidget)
	16	: QWidget{parent},
	17	ui{new Ui::VisualizationGraphWidget},
	18	impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
6	19	{
7	20	ui->setupUi(this);
8	21	}
		@@ -11,3 +24,24 VisualizationGraphWidget::~VisualizationGraphWidget()
11	24	{
12	25	delete ui;
13	26	}
	27
	28	void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
	29	{
	30	// todo: first check is variable contains data then check how many plot have to be created
	31	}
	32
	33	void VisualizationGraphWidget::accept(IVisualizationWidget *visitor)
	34	{
	35	// TODO: manage the visitor
	36	}
	37
	38	void VisualizationGraphWidget::close()
	39	{
	40	// The main view cannot be directly closed.
	41	return;
	42	}
	43
	44	QString VisualizationGraphWidget::name() const
	45	{
	46	return QStringLiteral("MainView");
	47	}

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

		@@ -1,6 +1,9
1	1	#include "Visualization/VisualizationTabWidget.h"
2	2	#include "ui_VisualizationTabWidget.h"
3	3
	4	#include "Visualization/VisualizationZoneWidget.h"
	5
	6
4	7	VisualizationTabWidget::VisualizationTabWidget(QWidget *parent)
5	8	: QWidget{parent}, ui{new Ui::VisualizationTabWidget}
6	9	{
		@@ -11,3 +14,36 VisualizationTabWidget::~VisualizationTabWidget()
11	14	{
12	15	delete ui;
13	16	}
	17
	18	void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
	19	{
	20	this->layout()->addWidget(zoneWidget);
	21	}
	22
	23	VisualizationZoneWidget *VisualizationTabWidget::createZone()
	24	{
	25	auto zoneWidget = new VisualizationZoneWidget{this};
	26	this->addZone(zoneWidget);
	27
	28	return zoneWidget;
	29	}
	30
	31	void VisualizationTabWidget::removeZone(VisualizationZoneWidget *zone)
	32	{
	33	}
	34
	35	void VisualizationTabWidget::accept(IVisualizationWidget *visitor)
	36	{
	37	// TODO: manage the visitor
	38	}
	39
	40	void VisualizationTabWidget::close()
	41	{
	42	// The main view cannot be directly closed.
	43	return;
	44	}
	45
	46	QString VisualizationTabWidget::name() const
	47	{
	48	return QStringLiteral("MainView");
	49	}

gui/src/Visualization/VisualizationWidget.cpp +40 -3

              #include "Visualization/VisualizationWidget.h"
              #include "Visualization/VisualizationTabWidget.h"
+             #include "Visualization/qcustomplot.h"
              #include "ui_VisualizationWidget.h"
-             #include <QDebug>
              #include <QToolButton>
-             #include "iostream"
              Q_LOGGING_CATEGORY(LOG_VisualizationWidget, "VisualizationWidget")
              VisualizationWidget::VisualizationWidget(QWidget *parent)
                  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),
              {
                  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");
+             }

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

		@@ -1,6 +1,8
1	1	#include "Visualization/VisualizationZoneWidget.h"
2	2	#include "ui_VisualizationZoneWidget.h"
3	3
	4	#include "Visualization/VisualizationGraphWidget.h"
	5
4	6	VisualizationZoneWidget::VisualizationZoneWidget(QWidget *parent)
5	7	: QWidget{parent}, ui{new Ui::VisualizationZoneWidget}
6	8	{
		@@ -11,3 +13,36 VisualizationZoneWidget::~VisualizationZoneWidget()
11	13	{
12	14	delete ui;
13	15	}
	16
	17	void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
	18	{
	19	ui->visualizationZoneFrame->layout()->addWidget(graphWidget);
	20	}
	21
	22	VisualizationGraphWidget *VisualizationZoneWidget::createGraph()
	23	{
	24	auto graphWidget = new VisualizationGraphWidget{this};
	25	this->addGraph(graphWidget);
	26
	27	return graphWidget;
	28	}
	29
	30	void VisualizationZoneWidget::removeGraph(VisualizationGraphWidget *graph)
	31	{
	32	}
	33
	34	void VisualizationZoneWidget::accept(IVisualizationWidget *visitor)
	35	{
	36	// TODO: manage the visitor
	37	}
	38
	39	void VisualizationZoneWidget::close()
	40	{
	41	// The main view cannot be directly closed.
	42	return;
	43	}
	44
	45	QString VisualizationZoneWidget::name() const
	46	{
	47	return QStringLiteral("MainView");
	48	}

gui/ui/SidePane/SqpSidePane.ui ~~gui/ui/sidepane/SqpSidePane.ui~~ renamed 0 0

NO CONTENT: file renamed from gui/ui/sidepane/SqpSidePane.ui to gui/ui/SidePane/SqpSidePane.ui

gui/ui/Visualization/VisualizationGraphWidget.ui ~~gui/ui/visualization/VisualizationGraphWidget.ui~~ renamed +16 -5

+             <?xml version="1.0" encoding="UTF-8"?>
              <ui version="4.0">
-              <author/>
-              <comment/>
-              <exportmacro/>
               <class>VisualizationGraphWidget</class>
-              <widget name="VisualizationGraphWidget" class="QWidget">
+              <widget class="QWidget" name="VisualizationGraphWidget">
                <property name="geometry">
                 <rect>
                  <x>0</x>
                <property name="windowTitle">
                 <string>Form</string>
                </property>
+               <layout class="QVBoxLayout" name="verticalLayout">
+                <item>
+                 <widget class="QCustomPlot" name="widget" native="true"/>
+                </item>
+               </layout>
               </widget>
-              <pixmapfunction/>
+              <customwidgets>
+               <customwidget>
+                <class>QCustomPlot</class>
+                <extends>QWidget</extends>
+                <header>Visualization/qcustomplot.h</header>
+                <container>1</container>
+               </customwidget>
+              </customwidgets>
+              <resources/>
               <connections/>
              </ui>

gui/ui/Visualization/VisualizationTabWidget.ui ~~gui/ui/visualization/VisualizationTabWidget.ui~~ renamed +4 -5

+             <?xml version="1.0" encoding="UTF-8"?>
              <ui version="4.0">
-              <author/>
-              <comment/>
-              <exportmacro/>
               <class>VisualizationTabWidget</class>
-              <widget name="VisualizationTabWidget" class="QWidget">
+              <widget class="QWidget" name="VisualizationTabWidget">
                <property name="geometry">
                 <rect>
                  <x>0</x>
                <property name="windowTitle">
                 <string>Form</string>
                </property>
+               <layout class="QVBoxLayout" name="verticalLayout"/>
               </widget>
-              <pixmapfunction/>
+              <resources/>
               <connections/>
              </ui>

gui/ui/Visualization/VisualizationWidget.ui ~~gui/ui/visualization/VisualizationWidget.ui~~ renamed 0 0

NO CONTENT: file renamed from gui/ui/visualization/VisualizationWidget.ui to gui/ui/Visualization/VisualizationWidget.ui

gui/ui/Visualization/VisualizationZoneWidget.ui ~~gui/ui/visualization/VisualizationZoneWidget.ui~~ renamed +16 -5

+             <?xml version="1.0" encoding="UTF-8"?>
              <ui version="4.0">
-              <author/>
-              <comment/>
-              <exportmacro/>
               <class>VisualizationZoneWidget</class>
-              <widget name="VisualizationZoneWidget" class="QWidget">
+              <widget class="QWidget" name="VisualizationZoneWidget">
                <property name="geometry">
                 <rect>
                  <x>0</x>
                <property name="windowTitle">
                 <string>Form</string>
                </property>
+               <layout class="QVBoxLayout" name="verticalLayout_2">
+                <item>
+                 <widget class="QFrame" name="visualizationZoneFrame">
+                  <property name="frameShape">
+                   <enum>QFrame::StyledPanel</enum>
+                  </property>
+                  <property name="frameShadow">
+                   <enum>QFrame::Raised</enum>
+                  </property>
+                  <layout class="QVBoxLayout" name="verticalLayout"/>
+                 </widget>
+                </item>
+               </layout>
               </widget>
-              <pixmapfunction/>
+              <resources/>
               <connections/>
              </ui>

plugins/mockplugin/CMakeLists.txt +6 0

              #LIST(APPEND CHECKSTYLE_EXCLUSION_FILES ${CMAKE_CURRENT_SOURCE_DIR}/vera-exclusions/exclusions.txt)
              SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_EXCLUSION_FILES)
+             # Temporary target to copy to plugins dir
+             find_package(sciqlop-mockplugin)
+             ADD_CUSTOM_TARGET(plugins
+                 COMMAND ${CMAKE_COMMAND} -E copy ${SCIQLOP-MOCKPLUGIN_LIBRARIES} "${LIBRARY_OUTPUT_PATH}/plugins/${SCIQLOP-MOCKPLUGIN_LIBRARIES_NAME}"
+             )
              #
              # Compile the tests
              #

plugins/mockplugin/cmake/Findsciqlop-mockplugin.cmake +2 -1

                  set (OS_LIB_EXTENSION "dll")
              endif(WIN32)
              # TODO: Add Mac Support
-             set(SCIQLOP-MOCKPLUGIN_LIBRARIES ${LIBRARY_OUTPUT_PATH}/libsciqlop_mockplugin${DEBUG_SUFFIX}.${OS_LIB_EXTENSION})
+             set(SCIQLOP-MOCKPLUGIN_LIBRARIES_NAME "libsciqlop_mockplugin${DEBUG_SUFFIX}.${OS_LIB_EXTENSION}")
+             set(SCIQLOP-MOCKPLUGIN_LIBRARIES "${LIBRARY_OUTPUT_PATH}/${SCIQLOP-MOCKPLUGIN_LIBRARIES_NAME}")
              set(SCIQLOP-MOCKPLUGIN_FOUND TRUE)

plugins/mockplugin/include/MockPlugin.h 0 -4

              public:
                  /// @sa IPlugin::initialize()
                  void initialize() override;
-             private:
-                 /// Creates the data source item relative to the plugin
-                 std::unique_ptr<DataSourceItem> createDataSourceItem() const noexcept;
              };
              #endif // SCIQLOP_MOCKPLUGIN_H

plugins/mockplugin/src/MockPlugin.cpp +45 -21

-             #include <MockPlugin.h>
+             #include "MockPlugin.h"
+             #include "CosinusProvider.h"
              #include <DataSource/DataSourceController.h>
              #include <DataSource/DataSourceItem.h>
+             #include <DataSource/DataSourceItemAction.h>
              #include <SqpApplication.h>
              /// Name of the data source
              const auto DATA_SOURCE_NAME = QStringLiteral("MMS");
-             } // namespace
+             /// Creates the data provider relative to the plugin
+             std::unique_ptr<IDataProvider> createDataProvider() noexcept
+             {
+                 return std::make_unique<CosinusProvider>();
+             }
-             void MockPlugin::initialize()
+             std::unique_ptr<DataSourceItem> createProductItem(const QString &productName)
              {
-                 if (auto app = sqpApp) {
-                     // Registers to the data source controller
-                     auto &dataSourceController = app->dataSourceController();
-                     auto dataSourceUid = dataSourceController.registerDataSource(DATA_SOURCE_NAME);
+                 auto result = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT,
+                                                                QVector<QVariant>{productName});
-                     dataSourceController.setDataSourceItem(dataSourceUid, createDataSourceItem());
+                 }
-                 else {
-                     qCWarning(LOG_MockPlugin()) << tr("Can't access to SciQlop application");
+                 }
+                 // Add action to load product from DataSourceController
+                 result->addAction(std::make_unique<DataSourceItemAction>(
+                     QObject::tr("Load %1 product").arg(productName), [productName](DataSourceItem &item) {
+                         if (auto app = sqpApp) {
+                             app->dataSourceController().loadProductItem(item);
+                         }
+                     }));
+                 return result;
              }
-             std::unique_ptr<DataSourceItem> MockPlugin::createDataSourceItem() const noexcept
+             /// Creates the data source item relative to the plugin
+             std::unique_ptr<DataSourceItem> createDataSourceItem() noexcept
              {
                  // Magnetic field products
-                 auto fgmProduct = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT,
-                                                                    QVector<QVariant>{QStringLiteral("FGM")});
-                 auto scProduct = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT,
-                                                                   QVector<QVariant>{QStringLiteral("SC")});
                  auto magneticFieldFolder = std::make_unique<DataSourceItem>(
                      DataSourceItemType::NODE, QVector<QVariant>{QStringLiteral("Magnetic field")});
-                 magneticFieldFolder->appendChild(std::move(fgmProduct));
-                 magneticFieldFolder->appendChild(std::move(scProduct));
+                 magneticFieldFolder->appendChild(createProductItem(QStringLiteral("FGM")));
+                 magneticFieldFolder->appendChild(createProductItem(QStringLiteral("SC")));
                  // Electric field products
                  auto electricFieldFolder = std::make_unique<DataSourceItem>(
                  root->appendChild(std::move(magneticFieldFolder));
                  root->appendChild(std::move(electricFieldFolder));
-                 return std::move(root);
+                 return root;
+             }
+             } // namespace
+             void MockPlugin::initialize()
+             {
+                 if (auto app = sqpApp) {
+                     // Registers to the data source controller
+                     auto &dataSourceController = app->dataSourceController();
+                     auto dataSourceUid = dataSourceController.registerDataSource(DATA_SOURCE_NAME);
+                     // Sets data source tree
+                     dataSourceController.setDataSourceItem(dataSourceUid, createDataSourceItem());
+                     // Sets data provider
+                     dataSourceController.setDataProvider(dataSourceUid, createDataProvider());
+                 }
+                 else {
+                     qCWarning(LOG_MockPlugin()) << tr("Can't access to SciQlop application");
+                 }
              }

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