GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r150:723bff6bece1

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

perrinel -

r150:723bff6bece1

parent child

Context file:

r150: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

             /*------------------------------------------------------------------------------
             -- 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 <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);
-                // 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
+                auto leftSidePane = m_Ui->leftInspectorSidePane->sidePane();
-                    if (checked) {
+                auto openLeftInspectorAction = new QAction{QIcon{
-                        impl->m_LastOpenLeftInspectorSize = m_Ui->leftMainInspectorWidget->size();
+                                                               ":/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();
+                auto spacerLeftTop = new QWidget{};
-                    if (checked) {
+                spacerLeftTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
-                        // 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 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 &lastInspectorSize
-                auto openRightInspector = [this](bool checked) {
+                        = 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]
+                        currentSizes[splitterInspectorIndex] -= lastInspectorSize.width();
-                            -= impl->m_LastOpenRightInspectorSize.width();
+                        currentSizes[VIEWPLITTERINDEX] += lastInspectorSize.width();
-                        currentSizes[VIEWPLITTERINDEX] += impl->m_LastOpenRightInspectorSize.width();
                         m_Ui->splitter->setSizes(currentSizes);
                     }
                     else {
                         // adjust sizes individually here, e.g.
-                        currentSizes[RIGHTMAININSPECTORWIDGETSPLITTERINDEX]
+                        currentSizes[splitterInspectorIndex] += lastInspectorSize.width();
-                            += impl->m_LastOpenRightInspectorSize.width();
+                        currentSizes[VIEWPLITTERINDEX] -= lastInspectorSize.width();
-                        currentSizes[VIEWPLITTERINDEX] -= impl->m_LastOpenRightInspectorSize.width();
                         m_Ui->splitter->setSizes(currentSizes);
                     }
                 };
-                QToolBar *leftSidePane = m_Ui->leftInspectorSidePane->sidePane();
+                connect(openLeftInspectorAction, &QAction::triggered,
-                auto openLeftInspectorAction = leftSidePane->addAction(
+                        [openInspector, openLeftInspectorAction](bool checked) {
-                    QIcon{
+                            openInspector(checked, false, openLeftInspectorAction);
-                        ":/icones/openInspector.png",
+                        });
-                    },
+                connect(openRightInspectorAction, &QAction::triggered,
-                    tr("Show/hide the left inspector"), openLeftInspector);
+                        [openInspector, openRightInspectorAction](bool checked) {
+                            openInspector(checked, true, openRightInspectorAction);
-                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);
                 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 *)),
                         m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem *)));
                 /*    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;
                 }
             }

app/ui/MainWindow.ui +8 -2

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>MainWindow</class>
              <widget class="QMainWindow" name="MainWindow">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>800</width>
                 <height>600</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>QLop</string>
               </property>
               <property name="dockNestingEnabled">
                <bool>true</bool>
               </property>
               <widget class="QWidget" name="centralWidget">
                <property name="enabled">
                 <bool>true</bool>
                </property>
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="maximumSize">
                 <size>
                  <width>16777215</width>
                  <height>16777215</height>
                 </size>
                </property>
                <layout class="QHBoxLayout" name="horizontalLayout">
                 <property name="spacing">
                  <number>0</number>
                 </property>
                 <property name="leftMargin">
                  <number>0</number>
                 </property>
                 <property name="topMargin">
                  <number>0</number>
                 </property>
                 <property name="rightMargin">
                  <number>0</number>
                 </property>
                 <property name="bottomMargin">
                  <number>0</number>
                 </property>
                 <item>
                  <widget class="QSplitter" name="splitter">
                   <property name="orientation">
                    <enum>Qt::Horizontal</enum>
                   </property>
                   <widget class="QWidget" name="leftMainInspectorWidget" native="true">
                    <layout class="QVBoxLayout" name="verticalLayout">
                     <property name="spacing">
                      <number>0</number>
                     </property>
                     <property name="leftMargin">
                      <number>0</number>
                     </property>
                     <property name="topMargin">
                      <number>0</number>
                     </property>
                     <property name="rightMargin">
                      <number>0</number>
                     </property>
                     <property name="bottomMargin">
                      <number>0</number>
                     </property>
                     <item>
                      <widget class="DataSourceWidget" name="dataSourceWidget" native="true"/>
                     </item>
                     <item>
                      <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>
                   <widget class="SqpSidePane" name="leftInspectorSidePane" native="true"/>
                   <widget class="VisualizationWidget" name="view" native="true">
                    <property name="sizePolicy">
                     <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
                      <horstretch>0</horstretch>
                      <verstretch>0</verstretch>
                     </sizepolicy>
                    </property>
                   </widget>
                   <widget class="SqpSidePane" name="rightInspectorSidePane" native="true"/>
                   <widget class="QWidget" name="rightMainInspectorWidget" native="true">
                    <layout class="QVBoxLayout" name="verticalLayout_3">
                     <property name="spacing">
                      <number>0</number>
                     </property>
                     <property name="leftMargin">
                      <number>0</number>
                     </property>
                     <property name="topMargin">
                      <number>0</number>
                     </property>
                     <property name="rightMargin">
                      <number>0</number>
                     </property>
                     <property name="bottomMargin">
                      <number>0</number>
                     </property>
                     <item>
                      <widget class="QWidget" name="commonPropertyInspectorWidget" native="true"/>
                     </item>
                     <item>
                      <widget class="DataSourceWidget" name="catalogWidget" native="true"/>
                     </item>
                    </layout>
                   </widget>
                  </widget>
                 </item>
                </layout>
               </widget>
               <widget class="QMenuBar" name="menuBar">
                <property name="geometry">
                 <rect>
                  <x>0</x>
                  <y>0</y>
                  <width>800</width>
-                 <height>28</height>
+                 <height>26</height>
                 </rect>
                </property>
               </widget>
               <widget class="QStatusBar" name="statusBar"/>
              </widget>
              <layoutdefault spacing="6" margin="11"/>
              <customwidgets>
               <customwidget>
                <class>VisualizationWidget</class>
                <extends>QWidget</extends>
                <header location="global">Visualization/VisualizationWidget.h</header>
                <container>1</container>
               </customwidget>
               <customwidget>
                <class>SqpSidePane</class>
                <extends>QWidget</extends>
                <header location="global">SidePane/SqpSidePane.h</header>
                <container>1</container>
               </customwidget>
               <customwidget>
                <class>DataSourceWidget</class>
                <extends>QWidget</extends>
                <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/>
             </ui>

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

             #ifndef SCIQLOP_DATASOURCECONTROLLER_H
             #define SCIQLOP_DATASOURCECONTROLLER_H
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             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
              * 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 DataSourceController : public QObject {
                 Q_OBJECT
             public:
                 explicit DataSourceController(QObject *parent = 0);
                 virtual ~DataSourceController();
                 /**
                  * Registers a data source. The method delivers a unique id that can be used afterwards to
                  * access to the data source properties (structure, connection parameters, data provider, etc.)
                  * @param dataSourceName the name of the data source
                  * @return the unique id with which the data source has been registered
                  */
                 QUuid registerDataSource(const QString &dataSourceName) noexcept;
                 /**
                  * Sets the structure of a data source. The controller takes ownership of the structure.
                  * @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 dataSourceItem the structure of the data source
                  * @sa registerDataSource()
                  */
                 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();
                 void finalize();
             signals:
                 /// Signal emitted when a structure has been set for a data source
                 void dataSourceItemSet(DataSourceItem *dataSourceItem);
             private:
                 void waitForFinish();
                 class DataSourceControllerPrivate;
                 spimpl::unique_impl_ptr<DataSourceControllerPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCECONTROLLER_H

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

             #ifndef SCIQLOP_DATASOURCEITEM_H
             #define SCIQLOP_DATASOURCEITEM_H
             #include <Common/spimpl.h>
             #include <QVariant>
             #include <QVector>
+            class DataSourceItemAction;
             /**
              * Possible types of an item
              */
             enum class DataSourceItemType { NODE, PRODUCT };
             /**
              * @brief The DataSourceItem class aims to represent a structure element of a data source.
              * A data source has a tree structure that is made up of a main DataSourceItem object (root)
              * containing other DataSourceItem objects (children).
              * For each DataSourceItem can be associated a set of data representing it.
              */
             class DataSourceItem {
             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
                  */
                 void appendChild(std::unique_ptr<DataSourceItem> child) noexcept;
                 /**
                  * Returns the item's child associated to an index
                  * @param childIndex the index to search
                  * @return a pointer to the child if index is valid, nullptr otherwise
                  */
                 DataSourceItem *child(int childIndex) const noexcept;
                 int childCount() const noexcept;
                 /**
                  * Get the data associated to an index
                  * @param dataIndex the index to search
                  * @return the data found if index is valid, default QVariant otherwise
                  */
                 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
                  */
                 DataSourceItem *parentItem() const noexcept;
                 DataSourceItemType type() const noexcept;
             private:
                 class DataSourceItemPrivate;
                 spimpl::unique_impl_ptr<DataSourceItemPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCEITEMMODEL_H

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

             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
+            #include <Data/IDataProvider.h>
             #include <QMutex>
             #include <QThread>
             #include <QDir>
             #include <QStandardPaths>
             Q_LOGGING_CATEGORY(LOG_DataSourceController, "DataSourceController")
             class DataSourceController::DataSourceControllerPrivate {
             public:
                 QMutex m_WorkingMutex;
                 /// Data sources registered
                 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)
                     : impl{spimpl::make_unique_impl<DataSourceControllerPrivate>()}
             {
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController construction")
                                                     << QThread::currentThread();
             }
             DataSourceController::~DataSourceController()
             {
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController destruction")
                                                     << QThread::currentThread();
                 this->waitForFinish();
             }
             QUuid DataSourceController::registerDataSource(const QString &dataSourceName) noexcept
             {
                 auto dataSourceUid = QUuid::createUuid();
                 impl->m_DataSources.insert(dataSourceUid, dataSourceName);
                 return dataSourceUid;
             }
             void DataSourceController::setDataSourceItem(
                 const QUuid &dataSourceUid, std::unique_ptr<DataSourceItem> dataSourceItem) noexcept
             {
                 if (impl->m_DataSources.contains(dataSourceUid)) {
                     impl->m_DataSourceItems.insert(std::make_pair(dataSourceUid, std::move(dataSourceItem)));
                     // Retrieves the data source item to emit the signal with it
                     auto it = impl->m_DataSourceItems.find(dataSourceUid);
                     if (it != impl->m_DataSourceItems.end()) {
                         emit dataSourceItemSet(it->second.get());
                     }
                 }
                 else {
                     qCWarning(LOG_DataSourceController()) << tr("Can't set data source item for uid %1 : no "
                                                                 "data source has been registered with the uid")
                                                                  .arg(dataSourceUid.toString());
                 }
             }
+            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")
                                                     << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController init END");
             }
             void DataSourceController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void DataSourceController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

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{}
                 {
                 }
                 DataSourceItem *m_Parent;
                 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)
                     : impl{spimpl::make_unique_impl<DataSourceItemPrivate>(type, std::move(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;
                 impl->m_Children.push_back(std::move(child));
             }
             DataSourceItem *DataSourceItem::child(int childIndex) const noexcept
             {
                 if (childIndex < 0 || childIndex >= childCount()) {
                     return nullptr;
                 }
                 else {
                     return impl->m_Children.at(childIndex).get();
                 }
             }
             int DataSourceItem::childCount() const noexcept
             {
                 return impl->m_Children.size();
             }
             QVariant DataSourceItem::data(int dataIndex) const noexcept
             {
                 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;
             }
             DataSourceItemType DataSourceItem::type() const noexcept
             {
                 return impl->m_Type;
             }

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

             # On ignore toutes les règles vera++ pour le fichier spimpl
             Common/spimpl\.h:\d+:.*
             # 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

             #ifndef SCIQLOP_DATASOURCETREEWIDGETITEM_H
             #define SCIQLOP_DATASOURCETREEWIDGETITEM_H
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             #include <QTreeWidgetItem>
             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSourceTreeWidgetItem)
             class DataSourceItem;
             /**
              * @brief The DataSourceTreeWidgetItem is the graphical representation of a data source item. It is
              * intended to be displayed in a QTreeWidget.
              * @sa DataSourceItem
              */
             class DataSourceTreeWidgetItem : public QTreeWidgetItem {
             public:
                 explicit DataSourceTreeWidgetItem(const DataSourceItem *data, int type = Type);
                 explicit DataSourceTreeWidgetItem(QTreeWidget *parent, const DataSourceItem *data,
                                                   int type = Type);
                 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;
             };
             #endif // SCIQLOP_DATASOURCETREEWIDGETITEM_H

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;
             /**
              * @brief The DataSourceWidget handles the graphical representation (as a tree) of the data sources
              * attached to SciQlop.
              */
             class DataSourceWidget : public QWidget {
                 Q_OBJECT
             public:
                 explicit DataSourceWidget(QWidget *parent = 0);
             public slots:
                 /**
                  * Adds a data source. An item associated to the data source is created and then added to the
                  * representation tree
                  * @param dataSource the data source to add. The pointer has to be not null
                  */
                 void addDataSource(DataSourceItem *dataSource) noexcept;
             private:
-                class DataSourceWidgetPrivate;
+                Ui::DataSourceWidget *ui;
-                spimpl::unique_impl_ptr<DataSourceWidgetPrivate> impl;
+            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

             #ifndef SCIQLOP_SQPAPPLICATION_H
             #define SCIQLOP_SQPAPPLICATION_H
             #include "SqpApplication.h"
             #include <QApplication>
             #include <QLoggingCategory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_SqpApplication)
             #if defined(sqpApp)
             #undef sqpApp
             #endif
             #define sqpApp (static_cast<SqpApplication *>(QCoreApplication::instance()))
             class DataSourceController;
+            class VariableController;
             class VisualizationController;
             /**
              * @brief The SqpApplication 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 load 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 SqpApplication : public QApplication {
                 Q_OBJECT
             public:
                 explicit SqpApplication(int &argc, char **argv);
                 virtual ~SqpApplication();
                 void initialize();
                 /// Accessors for the differents sciqlop controllers
-                DataSourceController &dataSourceController() const noexcept;
+                DataSourceController &dataSourceController() noexcept;
-                VisualizationController &visualizationController() const noexcept;
+                VariableController &variableController() noexcept;
+                VisualizationController &visualizationController() noexcept;
             private:
                 class SqpApplicationPrivate;
                 spimpl::unique_impl_ptr<SqpApplicationPrivate> impl;
             };
             #endif // SCIQLOP_SQPAPPLICATION_H

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;
             };
             #endif // SCIQLOP_VISUALIZATIONTABWIDGET_H

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;
             };
             #endif // VISUALIZATIONWIDGET_H

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;
             };
             #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H

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 {
             QIcon itemIcon(const DataSourceItem *dataSource)
             {
                 if (dataSource) {
                     auto dataSourceType = dataSource->type();
                     switch (dataSourceType) {
                         case DataSourceItemType::NODE:
                             return sqpApp->style()->standardIcon(QStyle::SP_DirIcon);
                         case DataSourceItemType::PRODUCT:
                             return sqpApp->style()->standardIcon(QStyle::SP_FileIcon);
                         default:
                             // No action
                             break;
                     }
                     qCWarning(LOG_DataSourceTreeWidgetItem())
                         << QObject::tr("Can't set data source icon : unknown data source type");
                 }
                 else {
                     qCWarning(LOG_DataSourceTreeWidgetItem())
                         << QObject::tr("Can't set data source icon : the data source is null");
                 }
                 // Default cases
                 return QIcon{};
             }
             } // namespace
             struct DataSourceTreeWidgetItem::DataSourceTreeWidgetItemPrivate {
                 explicit DataSourceTreeWidgetItemPrivate(const DataSourceItem *data) : m_Data{data} {}
                 /// 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)
                     : DataSourceTreeWidgetItem{nullptr, data, type}
             {
             }
             DataSourceTreeWidgetItem::DataSourceTreeWidgetItem(QTreeWidget *parent, const DataSourceItem *data,
                                                                int type)
                     : QTreeWidgetItem{parent, type},
                       impl{spimpl::make_unique_impl<DataSourceTreeWidgetItemPrivate>(data)}
             {
                 // 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
             {
                 if (role == Qt::DisplayRole) {
                     return (impl->m_Data) ? impl->m_Data->data(column) : QVariant{};
                 }
                 else {
                     return QTreeWidgetItem::data(column, role);
                 }
             }
             void DataSourceTreeWidgetItem::setData(int column, int role, const QVariant &value)
             {
                 // Data can't be changed by edition
                 if (role != Qt::EditRole) {
                     QTreeWidgetItem::setData(column, role, value);
                 }
             }
+            QList<QAction *> DataSourceTreeWidgetItem::actions() const noexcept
+            {
+                return impl->m_Actions;
+            }

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

             #include <DataSource/DataSourceWidget.h>
             #include <ui_DataSourceWidget.h>
             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceTreeWidgetItem.h>
+            #include <QMenu>
             namespace {
             /// Number of columns displayed in the tree
             const auto TREE_NB_COLUMNS = 1;
             /// Header labels for the tree
             const auto TREE_HEADER_LABELS = QStringList{QObject::tr("Name")};
             /**
              * Creates the item associated to a data source
              * @param dataSource the data source for which to create the item
              * @return the new item
              */
             DataSourceTreeWidgetItem *createTreeWidgetItem(DataSourceItem *dataSource)
             {
                 // Creates item for the data source
                 auto item = new DataSourceTreeWidgetItem{dataSource};
                 // Generates items for the children of the data source
                 for (auto i = 0; i < dataSource->childCount(); ++i) {
                     item->addChild(createTreeWidgetItem(dataSource->child(i)));
                 }
                 return item;
             }
             } // namespace
-            class DataSourceWidget::DataSourceWidgetPrivate {
+            DataSourceWidget::DataSourceWidget(QWidget *parent) : QWidget{parent}, ui{new Ui::DataSourceWidget}
-            public:
-                explicit DataSourceWidgetPrivate(DataSourceWidget &widget)
+                ui->setupUi(this);
-                        : 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);
-                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)
+                // Connection to show a menu when right clicking on the tree
-                    : QWidget{parent}, impl{spimpl::make_unique_impl<DataSourceWidgetPrivate>(*this)}
+                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

             #include "SidePane/SqpSidePane.h"
             #include "ui_SqpSidePane.h"
             #include <QAction>
             #include <QLayout>
             #include <QToolBar>
             namespace {
             static const QString SQPSIDEPANESTYLESHEET
                 = "QToolBar {"
                   " background: qlineargradient(x1: 0, y1: 0, x2: 1, y2: 0,"
                   "                              stop: 0.0 #5a5a5a,"
                   "                              stop: 1.0 #414141);"
                   " border: none;"
                   " border-left: 1px solid #424242;"
                   "border-right: 1px solid #393939;"
                   " }"
                   " QToolButton {"
                   "background: none;"
                   "border: none;"
                   " }";
             }
             SqpSidePane::SqpSidePane(QWidget *parent) : QWidget{parent}, ui{new Ui::SqpSidePane}
             {
                 //    QVBoxLayout *sidePaneLayout = new QVBoxLayout(this);
                 //    sidePaneLayout->setContentsMargins(0, 0, 0, 0);
                 //    this->setLayout(sidePaneLayout);
                 ui->setupUi(this);
                 m_SidePaneToolbar = new QToolBar();
                 m_SidePaneToolbar->setOrientation(Qt::Vertical);
                 this->layout()->addWidget(m_SidePaneToolbar);
                 m_SidePaneToolbar->setStyleSheet(SQPSIDEPANESTYLESHEET);
-                this->setStyleSheet(
-                    " QWidget {"
-                    "background: red;"
-                    "border: 1px;"
-                    " }");
             }
             SqpSidePane::~SqpSidePane()
             {
                 delete ui;
             }
             QToolBar *SqpSidePane::sidePane()
             {
                 return m_SidePaneToolbar;
             }

gui/src/SqpApplication.cpp +21 -2

             #include "SqpApplication.h"
             #include <DataSource/DataSourceController.h>
             #include <QThread>
+            #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>()}
                 {
                     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() 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,13 +1,47
1	#include "Visualization/VisualizationGraphWidget.h"	1	#include "Visualization/VisualizationGraphWidget.h"
2	#include "ui_VisualizationGraphWidget.h"	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	VisualizationGraphWidget::VisualizationGraphWidget(QWidget *parent)	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	ui->setupUi(this);	20	ui->setupUi(this);
8	}	21	}
9		22
10	VisualizationGraphWidget::~VisualizationGraphWidget()	23	VisualizationGraphWidget::~VisualizationGraphWidget()
11	{	24	{
12	delete ui;	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,13 +1,49
1	#include "Visualization/VisualizationTabWidget.h"	1	#include "Visualization/VisualizationTabWidget.h"
2	#include "ui_VisualizationTabWidget.h"	2	#include "ui_VisualizationTabWidget.h"
3		3
		4	#include "Visualization/VisualizationZoneWidget.h"
		5
		6
4	VisualizationTabWidget::VisualizationTabWidget(QWidget *parent)	7	VisualizationTabWidget::VisualizationTabWidget(QWidget *parent)
5	: QWidget{parent}, ui{new Ui::VisualizationTabWidget}	8	: QWidget{parent}, ui{new Ui::VisualizationTabWidget}
6	{	9	{
7	ui->setupUi(this);	10	ui->setupUi(this);
8	}	11	}
9		12
10	VisualizationTabWidget::~VisualizationTabWidget()	13	VisualizationTabWidget::~VisualizationTabWidget()
11	{	14	{
12	delete ui;	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)
                     : 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");
+            }

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

@@ -1,13 +1,48
1	#include "Visualization/VisualizationZoneWidget.h"	1	#include "Visualization/VisualizationZoneWidget.h"
2	#include "ui_VisualizationZoneWidget.h"	2	#include "ui_VisualizationZoneWidget.h"
3		3
		4	#include "Visualization/VisualizationGraphWidget.h"
		5
4	VisualizationZoneWidget::VisualizationZoneWidget(QWidget *parent)	6	VisualizationZoneWidget::VisualizationZoneWidget(QWidget *parent)
5	: QWidget{parent}, ui{new Ui::VisualizationZoneWidget}	7	: QWidget{parent}, ui{new Ui::VisualizationZoneWidget}
6	{	8	{
7	ui->setupUi(this);	9	ui->setupUi(this);
8	}	10	}
9		11
10	VisualizationZoneWidget::~VisualizationZoneWidget()	12	VisualizationZoneWidget::~VisualizationZoneWidget()
11	{	13	{
12	delete ui;	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>
                 <y>0</y>
                 <width>400</width>
                 <height>300</height>
                </rect>
               </property>
               <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>
                 <y>0</y>
                 <width>400</width>
                 <height>300</height>
                </rect>
               </property>
               <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>
                 <y>0</y>
                 <width>400</width>
                 <height>300</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
+              <layout class="QVBoxLayout" name="verticalLayout_2">
+               <item>
+                <widget class="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

             ## mockplugin - CMakeLists.txt
             STRING(TOLOWER ${CMAKE_PROJECT_NAME} LIBRARY_PREFFIX)
             SET(SQPMOCKPLUGIN_LIBRARY_NAME "${LIBRARY_PREFFIX}_mockplugin${DEBUG_SUFFIX}")
             SET(SOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src")
             SET(INCLUDES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")
             SET(RESOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/resources")
             # Include mockplugin directory
             INCLUDE_DIRECTORIES(${INCLUDES_DIR})
             INCLUDE_DIRECTORIES(${RESOURCES_DIR})
             #
             # Find Qt modules
             #
             SCIQLOP_FIND_QT(Core Widgets)
             #
             # Find dependent libraries
             # ========================
             # sciqlop plugin
             find_package(sciqlop-plugin)
             INCLUDE_DIRECTORIES(${SCIQLOP-PLUGIN_INCLUDE_DIR})
             # sciqlop core
             find_package(sciqlop-core)
             INCLUDE_DIRECTORIES(${SCIQLOP-CORE_INCLUDE_DIR})
             list(APPEND LIBRARIES ${SCIQLOP-CORE_LIBRARIES})
             # sciqlop gui
             find_package(sciqlop-gui)
             INCLUDE_DIRECTORIES(${SCIQLOP-GUI_INCLUDE_DIR})
             list(APPEND LIBRARIES ${SCIQLOP-GUI_LIBRARIES})
             # Resources files
             FILE (GLOB_RECURSE PROJECT_RESOURCES ${RESOURCES_DIR}/*.json)
             #
             # Compile the library
             #
             FILE (GLOB_RECURSE MODULE_SOURCES
                     ${INCLUDES_DIR}/*.h
                     ${SOURCES_DIR}/*.c
                     ${SOURCES_DIR}/*.cpp
                     ${SOURCES_DIR}/*.h
                     ${PROJECT_RESOURCES})
             ADD_LIBRARY(${SQPMOCKPLUGIN_LIBRARY_NAME} ${MODULE_SOURCES})
             set_property(TARGET ${SQPMOCKPLUGIN_LIBRARY_NAME} PROPERTY CXX_STANDARD 14)
             set_property(TARGET ${SQPMOCKPLUGIN_LIBRARY_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
             TARGET_LINK_LIBRARIES(${SQPMOCKPLUGIN_LIBRARY_NAME} ${LIBRARIES})
             qt5_use_modules(${SQPMOCKPLUGIN_LIBRARY_NAME} Core Widgets)
             add_dependencies(${SQPMOCKPLUGIN_LIBRARY_NAME} ${SQPPLUGIN_LIBRARY_NAME} ${SQPGUI_LIBRARY_NAME} ${SQPCORE_LIBRARY_NAME})
             # From cmake documentation: http://www.cmake.org/cmake/help/v3.0/manual/cmake-buildsystem.7.html
             # Entries in the COMPILE_DEFINITIONS are prefixed with -D or /D and added to the compile line in an unspecified order.
             # The DEFINE_SYMBOL target property is also added as a compile definition as a special convenience case for SHARED and MODULE library targets
             IF(BUILD_SHARED_LIBS)
                     SET_TARGET_PROPERTIES(${SQPMOCKPLUGIN_LIBRARY_NAME} PROPERTIES COMPILE_DEFINITIONS "SCIQLOP_EXPORT")
             ELSE()
                     TARGET_COMPILE_DEFINITIONS(${SQPMOCKPLUGIN_LIBRARY_NAME} PUBLIC "SCIQLOP_STATIC_LIBRARIES")
             ENDIF()
             # Set the variable to parent scope so that the other projects can copy the
             # dependent shared libraries
             SCIQLOP_SET_TO_PARENT_SCOPE(SQPMOCKPLUGIN_LIBRARY_NAME)
             # Copy extern shared libraries to the lib folder
             SCIQLOP_COPY_TO_TARGET(LIBRARY ${SQPMOCKPLUGIN_LIBRARY_NAME} ${EXTERN_SHARED_LIBRARIES})
             # Add the files to the list of files to be analyzed
             LIST(APPEND CHECKSTYLE_INPUT_FILES ${MODULE_SOURCES})
             SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_INPUT_FILES)
             # Vera++ exclusion files
             #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
             #
             IF(BUILD_TESTS)
                     INCLUDE_DIRECTORIES(${SOURCES_DIR})
                     FILE (GLOB_RECURSE TESTS_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/Test*.cpp)
                     FILE (GLOB_RECURSE TESTS_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/Test*.h)
                     SET( TEST_LIBRARIES ${SQPGUI_LIBRARY_NAME})
                     FOREACH( testFile ${TESTS_SOURCES} )
                             GET_FILENAME_COMPONENT( testDirectory ${testFile} DIRECTORY )
                             GET_FILENAME_COMPONENT( testName ${testFile} NAME_WE )
                             # Add to the list of sources files all the sources in the same
                             # directory that aren't another test
                             FILE (GLOB currentTestSources
                                     ${testDirectory}/*.c
                                     ${testDirectory}/*.cpp
                                     ${testDirectory}/*.h)
                             LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES})
                             # LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS})
                             ADD_EXECUTABLE(${testName} ${testFile} ${currentTestSources})
                             set_property(TARGET ${testName} PROPERTY CXX_STANDARD 14)
                             set_property(TARGET ${testName} PROPERTY CXX_STANDARD_REQUIRED ON)
                             TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} )
                             qt5_use_modules(${testName} Test)
                             ADD_TEST( NAME ${testName} COMMAND ${testName} )
                             SCIQLOP_COPY_TO_TARGET(RUNTIME ${testName} ${EXTERN_SHARED_LIBRARIES})
                     ENDFOREACH( testFile )
                     LIST(APPEND testFilesToFormat ${TESTS_SOURCES})
                     LIST(APPEND testFilesToFormat ${TESTS_HEADERS})
                     LIST(APPEND FORMATTING_INPUT_FILES ${testFilesToFormat})
                     SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
             ENDIF(BUILD_TESTS)
             #
             # Set the files that must be formatted by clang-format.
             #
             LIST (APPEND FORMATTING_INPUT_FILES ${MODULE_SOURCES})
             SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
             #
             # Set the directories that doxygen must browse to generate the
             # documentation.
             #
             # Source directories:
             LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/docs")
             LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
             SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_INPUT_DIRS)
             # Source directories to exclude from the documentation generation
             #LIST (APPEND DOXYGEN_EXCLUDE_PATTERNS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir/*")
             SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_EXCLUDE_PATTERNS)
             #
             # Set the directories with the sources to analyze and propagate the
             # modification to the parent scope
             #
             # Source directories to analyze:
             LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
             LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/tests")
             SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_INPUT_DIRS)
             # Source directories to exclude from the analysis
             #LIST (APPEND ANALYSIS_EXCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir")
             SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_EXCLUDE_DIRS)

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

             # - Try to find sciqlop-mockplugin
             # Once done this will define
             #  SCIQLOP-MOCKPLUGIN_FOUND - System has sciqlop-mockplugin
             #  SCIQLOP-MOCKPLUGIN_INCLUDE_DIR - The sciqlop-mockplugin include directories
             #  SCIQLOP-MOCKPLUGIN_LIBRARIES - The libraries needed to use sciqlop-mockplugin
             if(SCIQLOP-MOCKPLUGIN_FOUND)
                 return()
             endif(SCIQLOP-MOCKPLUGIN_FOUND)
             set(SCIQLOP-MOCKPLUGIN_INCLUDE_DIR ${sciqlop-mockplugin_DIR}/../include)
             set (OS_LIB_EXTENSION "so")
             if(WIN32)
                 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

             #ifndef SCIQLOP_MOCKPLUGIN_H
             #define SCIQLOP_MOCKPLUGIN_H
             #include <Plugin/IPlugin.h>
             #include <QLoggingCategory>
             #include <memory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_MockPlugin)
             class DataSourceItem;
             class MockPlugin : public QObject, public IPlugin {
                 Q_OBJECT
                 Q_INTERFACES(IPlugin)
                 Q_PLUGIN_METADATA(IID "sciqlop.plugin.IPlugin" FILE "mockplugin.json")
             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

@@ -1,55 +1,79
1	#include <MockPlugin.h>	1	#include "MockPlugin.h"
		2	#include "CosinusProvider.h"
2		3
3	#include <DataSource/DataSourceController.h>	4	#include <DataSource/DataSourceController.h>
4	#include <DataSource/DataSourceItem.h>	5	#include <DataSource/DataSourceItem.h>
		6	#include <DataSource/DataSourceItemAction.h>
5		7
6	#include <SqpApplication.h>	8	#include <SqpApplication.h>
7		9
8	Q_LOGGING_CATEGORY(LOG_MockPlugin, "MockPlugin")	10	Q_LOGGING_CATEGORY(LOG_MockPlugin, "MockPlugin")
9		11
10	namespace {	12	namespace {
11		13
12	/// Name of the data source	14	/// Name of the data source
13	const auto DATA_SOURCE_NAME = QStringLiteral("MMS");	15	const auto DATA_SOURCE_NAME = QStringLiteral("MMS");
14		16
15	} // namespace	17	/// Creates the data provider relative to the plugin
		18	std::unique_ptr<IDataProvider> createDataProvider() noexcept
		19	{
		20	return std::make_unique<CosinusProvider>();
		21	}
16		22
17	void MockPlugin::initialize()	23	std::unique_ptr<DataSourceItem> createProductItem(const QString &productName)
18	{	24	{
19	if (auto app = sqpApp) {	25	auto result = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT,
20	// Registers to the data source controller	26	QVector<QVariant>{productName});
21	auto &dataSourceController = app->dataSourceController();
22	auto dataSourceUid = dataSourceController.registerDataSource(DATA_SOURCE_NAME);
23		27
24	dataSourceController.setDataSourceItem(dataSourceUid, createDataSourceItem());	28	// Add action to load product from DataSourceController
25	}	29	result->addAction(std::make_unique<DataSourceItemAction>(
26	else {	30	QObject::tr("Load %1 product").arg(productName), [productName](DataSourceItem &item) {
27	qCWarning(LOG_MockPlugin()) << tr("Can't access to SciQlop application");	31	if (auto app = sqpApp) {
28	}	32	app->dataSourceController().loadProductItem(item);
		33	}
		34	}));
		35
		36	return result;
29	}	37	}
30		38
31	std::unique_ptr<DataSourceItem> MockPlugin::createDataSourceItem() const noexcept	39	/// Creates the data source item relative to the plugin
		40	std::unique_ptr<DataSourceItem> createDataSourceItem() noexcept
32	{	41	{
33	// Magnetic field products	42	// Magnetic field products
34	auto fgmProduct = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT,
35	QVector<QVariant>{QStringLiteral("FGM")});
36	auto scProduct = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT,
37	QVector<QVariant>{QStringLiteral("SC")});
38
39	auto magneticFieldFolder = std::make_unique<DataSourceItem>(	43	auto magneticFieldFolder = std::make_unique<DataSourceItem>(
40	DataSourceItemType::NODE, QVector<QVariant>{QStringLiteral("Magnetic field")});	44	DataSourceItemType::NODE, QVector<QVariant>{QStringLiteral("Magnetic field")});
41	magneticFieldFolder->appendChild(~~std~~::~~move~~(~~fgmProduct~~));	45	magneticFieldFolder->appendChild(createProductItem(QStringLiteral("FGM")));
42	magneticFieldFolder->appendChild(~~std~~::~~move~~(~~scProduct~~));	46	magneticFieldFolder->appendChild(createProductItem(QStringLiteral("SC")));
43		47
44	// Electric field products	48	// Electric field products
45	auto electricFieldFolder = std::make_unique<DataSourceItem>(	49	auto electricFieldFolder = std::make_unique<DataSourceItem>(
46	DataSourceItemType::NODE, QVector<QVariant>{QStringLiteral("Electric field")});	50	DataSourceItemType::NODE, QVector<QVariant>{QStringLiteral("Electric field")});
47		51
48	// Root	52	// Root
49	auto root = std::make_unique<DataSourceItem>(DataSourceItemType::NODE,	53	auto root = std::make_unique<DataSourceItem>(DataSourceItemType::NODE,
50	QVector<QVariant>{DATA_SOURCE_NAME});	54	QVector<QVariant>{DATA_SOURCE_NAME});
51	root->appendChild(std::move(magneticFieldFolder));	55	root->appendChild(std::move(magneticFieldFolder));
52	root->appendChild(std::move(electricFieldFolder));	56	root->appendChild(std::move(electricFieldFolder));
53		57
54	return ~~std~~::~~move~~(root);	58	return root;
		59	}
		60
		61	} // namespace
		62
		63	void MockPlugin::initialize()
		64	{
		65	if (auto app = sqpApp) {
		66	// Registers to the data source controller
		67	auto &dataSourceController = app->dataSourceController();
		68	auto dataSourceUid = dataSourceController.registerDataSource(DATA_SOURCE_NAME);
		69
		70	// Sets data source tree
		71	dataSourceController.setDataSourceItem(dataSourceUid, createDataSourceItem());
		72
		73	// Sets data provider
		74	dataSourceController.setDataProvider(dataSourceUid, createDataProvider());
		75	}
		76	else {
		77	qCWarning(LOG_MockPlugin()) << tr("Can't access to SciQlop application");
		78	}
55	}	79	}

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