GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r141:c468e470fe0c

Merge pull request from SCIQLOP-Initialisation develop...

perrinel -

r141:c468e470fe0c

parent child

Context file:

r141:c468e470fe0c

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/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	}

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/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/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>

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;
                 }
             }

core/include/DataSource/DataSourceController.h +12 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;
             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/src/DataSource/DataSourceController.cpp +17 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::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/Variable/VariableController.cpp +4 -4

             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <QMutex>
             #include <QThread>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate()
                         : m_WorkingMutex{}, m_VariableModel{std::make_unique<VariableModel>()}
                 {
                 }
                 QMutex m_WorkingMutex;
                 std::unique_ptr<VariableModel> m_VariableModel;
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>()}
             {
-                qCDebug(LOG_VariableController())
+                qCDebug(LOG_VariableController()) << tr("VariableController construction")
-                    << tr("VariableController construction") << QThread::currentThread();
+                                                  << QThread::currentThread();
             }
             VariableController::~VariableController()
             {
-                qCDebug(LOG_VariableController())
+                qCDebug(LOG_VariableController()) << tr("VariableController destruction")
-                    << tr("VariableController destruction") << QThread::currentThread();
+                                                  << QThread::currentThread();
                 this->waitForFinish();
             }
             Variable *VariableController::createVariable(const QString &name) noexcept
             {
                 return impl->m_VariableModel->createVariable(name);
             }
             void VariableController::initialize()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableController()) << tr("VariableController init END");
             }
             void VariableController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

core/vera-exclusions/exclusions.txt +4 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)

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/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/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

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 +28 -16

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

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages