GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r288:1ae4a887fc77

Merge branch 'feature/VariousCorrections' into develop

Alexandre Leroux -

r288:1ae4a887fc77

parent child

Context file:

r288:1ae4a887fc77

Expand all files

core/include/Common/MetaTypes.h created 644 +46 0

@@ -0,0 +1,46
	1	#ifndef SCIQLOP_METATYPES_H
	2	#define SCIQLOP_METATYPES_H
	3
	4	#include <QMetaType>
	5
	6	/**
	7	* Struct used to create an instance that registers a type in Qt for signals / slots mechanism
	8	* @tparam T the type to register
	9	*/
	10	template <typename T>
	11	struct MetaTypeRegistry {
	12	explicit MetaTypeRegistry() { qRegisterMetaType<T>(); }
	13	};
	14
	15	/**
	16	* This macro can be used to :
	17	* - declare a type as a Qt meta type
	18	* - and register it (through a static instance) at the launch of SciQlop, so it can be passed in
	19	* Qt signals/slots
	20	*
	21	* It can be used both in .h or in .cpp files
	22	*
	23	* @param NAME name of the instance under which the type will be registered (in uppercase)
	24	* @param TYPE type to register
	25	*
	26	* Example:
	27	* ~~~cpp
	28	* // The following macro :
	29	* // - declares std::shared_ptr<Variable> as a Qt meta type
	30	* // - registers it through an instance named VAR_SHARED_PTR
	31	* SCIQLOP_REGISTER_META_TYPE(VAR_SHARED_PTR, std::shared_ptr<Variable>)
	32	*
	33	* // The following macro :
	34	* // - declares a raw pointer of Variable as a Qt meta type
	35	* // - registers it through an instance named VAR_RAW_PTR
	36	* SCIQLOP_REGISTER_META_TYPE(VAR_RAW_PTR, Variable*)
	37	* ~~~
	38	*
	39	*/
	40	// clang-format off
	41	#define SCIQLOP_REGISTER_META_TYPE(NAME, TYPE) \
	42	Q_DECLARE_METATYPE(TYPE) \
	43	const auto NAME = MetaTypeRegistry<TYPE>{}; \
	44	// clang-format on
	45
	46	#endif // SCIQLOP_METATYPES_H

app/src/MainWindow.cpp 0 -2

                 connect(timeWidget, SIGNAL(timeUpdated(SqpDateTime)), &sqpApp->timeController(),
                         SLOT(onTimeToUpdate(SqpDateTime)));
-                qRegisterMetaType<SqpDateTime>();
                 connect(&sqpApp->timeController(), SIGNAL(timeUpdated(SqpDateTime)),
                         &sqpApp->variableController(), SLOT(onDateTimeOnSelection(SqpDateTime)));
                 // Widgets / widgets connections
-                qRegisterMetaType<std::shared_ptr<Variable> >();
                 // For the following connections, we use DirectConnection to allow each widget that can
                 // potentially attach a menu to the variable's menu to do so before this menu is displayed.

core/include/Data/DataSeries.h +24 -1

             public:
                 /// @sa IDataSeries::xAxisData()
                 std::shared_ptr<ArrayData<1> > xAxisData() override { return m_XAxisData; }
+                const std::shared_ptr<ArrayData<1> > xAxisData() const { return m_XAxisData; }
                 /// @sa IDataSeries::xAxisUnit()
                 Unit xAxisUnit() const override { return m_XAxisUnit; }
                 /// @return the values dataset
-                std::shared_ptr<ArrayData<Dim> > valuesData() const { return m_ValuesData; }
+                std::shared_ptr<ArrayData<Dim> > valuesData() { return m_ValuesData; }
+                const std::shared_ptr<ArrayData<Dim> > valuesData() const { return m_ValuesData; }
                 /// @sa IDataSeries::valuesUnit()
                 Unit valuesUnit() const override { return m_ValuesUnit; }
                 {
                 }
+                /// Copy ctor
+                explicit DataSeries(const DataSeries<Dim> &other)
+                        : m_XAxisData{std::make_shared<ArrayData<1> >(*other.m_XAxisData)},
+                          m_XAxisUnit{other.m_XAxisUnit},
+                          m_ValuesData{std::make_shared<ArrayData<Dim> >(*other.m_ValuesData)},
+                          m_ValuesUnit{other.m_ValuesUnit}
+                {
+                }
+                /// Assignment operator
+                template <int D>
+                DataSeries &operator=(DataSeries<D> other)
+                {
+                    std::swap(m_XAxisData, other.m_XAxisData);
+                    std::swap(m_XAxisUnit, other.m_XAxisUnit);
+                    std::swap(m_ValuesData, other.m_ValuesData);
+                    std::swap(m_ValuesUnit, other.m_ValuesUnit);
+                    return *this;
+                }
             private:
                 std::shared_ptr<ArrayData<1> > m_XAxisData;
                 Unit m_XAxisUnit;

core/include/Data/IDataProvider.h +5 -2

             #include <QObject>
+            #include <Common/MetaTypes.h>
             #include <Data/SqpDateTime.h>
             class DataProviderParameters;
             public:
                 virtual ~IDataProvider() noexcept = default;
-                virtual std::unique_ptr<IDataSeries>
+                virtual std::shared_ptr<IDataSeries>
                 retrieveData(const DataProviderParameters &parameters) const = 0;
             signals:
                 void dataProvided(std::shared_ptr<IDataSeries> dateSerie, const SqpDateTime &dateTime);
             };
             // Required for using shared_ptr in signals/slots
-            Q_DECLARE_METATYPE(std::shared_ptr<IDataProvider>)
+            SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_PTR_REGISTRY, std::shared_ptr<IDataProvider>)
             #endif // SCIQLOP_IDATAPROVIDER_H

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

             #ifndef SCIQLOP_IDATASERIES_H
             #define SCIQLOP_IDATASERIES_H
+            #include <Common/MetaTypes.h>
             #include <memory>
-            #include <QObject>
             #include <QString>
             template <int Dim>
                 /// Returns the x-axis dataset
                 virtual std::shared_ptr<ArrayData<1> > xAxisData() = 0;
+                /// Returns the x-axis dataset (as const)
+                virtual const std::shared_ptr<ArrayData<1> > xAxisData() const = 0;
                 virtual Unit xAxisUnit() const = 0;
                 virtual Unit valuesUnit() const = 0;
                 virtual void merge(IDataSeries *dataSeries) = 0;
+                virtual std::unique_ptr<IDataSeries> clone() const = 0;
             };
             // Required for using shared_ptr in signals/slots
-            Q_DECLARE_METATYPE(std::shared_ptr<IDataSeries>)
+            SCIQLOP_REGISTER_META_TYPE(IDATASERIES_PTR_REGISTRY, std::shared_ptr<IDataSeries>)
             #endif // SCIQLOP_IDATASERIES_H

core/include/Data/ScalarSeries.h +2 0

                  * @param value the value data
                  */
                 void setData(int index, double x, double value) noexcept;
+                std::unique_ptr<IDataSeries> clone() const;
             };
             #endif // SCIQLOP_SCALARSERIES_H

core/include/Data/SqpDateTime.h +3 -1

             #include <QDateTime>
             #include <QDebug>
+            #include <Common/MetaTypes.h>
             /**
              * @brief The SqpDateTime struct holds the information of time parameters
              */
             }
             // Required for using shared_ptr in signals/slots
-            Q_DECLARE_METATYPE(SqpDateTime)
+            SCIQLOP_REGISTER_META_TYPE(SQPDATETIME_REGISTRY, SqpDateTime)
             #endif // SCIQLOP_SQPDATETIME_H

core/include/Variable/Variable.h +3 -4

             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
+            #include <Common/MetaTypes.h>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_Variable)
                 bool contains(const SqpDateTime &dateTime);
                 bool intersect(const SqpDateTime &dateTime);
-                void setDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept;
             public slots:
-                void onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
+                void setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
             signals:
                 void updated();
             };
             // Required for using shared_ptr in signals/slots
-            Q_DECLARE_METATYPE(std::shared_ptr<Variable>)
+            SCIQLOP_REGISTER_META_TYPE(VARIABLE_PTR_REGISTRY, std::shared_ptr<Variable>)
             #endif // SCIQLOP_VARIABLE_H

core/include/Variable/VariableModel.h +1 -1

                  */
                 std::shared_ptr<Variable>
                 createVariable(const QString &name, const SqpDateTime &dateTime,
-                               std::unique_ptr<IDataSeries> defaultDataSeries) noexcept;
+                               std::shared_ptr<IDataSeries> defaultDataSeries) noexcept;
                 std::shared_ptr<Variable> variable(int index) const;

core/src/Data/ScalarSeries.cpp +5 0

@@ -11,3 +11,8 void ScalarSeries::setData(int index, double x, double value) noexcept
11	xAxisData()->setData(index, x);	11	xAxisData()->setData(index, x);
12	valuesData()->setData(index, value);	12	valuesData()->setData(index, value);
13	}	13	}
		14
		15	std::unique_ptr<IDataSeries> ScalarSeries::clone() const
		16	{
		17	return std::make_unique<ScalarSeries>(*this);
		18	}

core/src/Variable/Variable.cpp +9 -7

                 impl->m_DateTime = dateTime;
             }
-            void Variable::setDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept
+            void Variable::setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
-                if (!impl->m_DataSeries) {
+                if (!dataSeries) {
-                    impl->m_DataSeries = std::move(dataSeries);
+                    /// @todo ALX : log
+                    return;
                 }
-            void Variable::onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
+                // Inits the data series of the variable
+                if (!impl->m_DataSeries) {
-                if (impl->m_DataSeries) {
+                    impl->m_DataSeries = dataSeries->clone();
+                }
+                else {
                     impl->m_DataSeries->merge(dataSeries.get());
                     emit updated();

core/src/Variable/VariableController.cpp +2 -4

             /// @todo Generates default dataseries, according to the provider passed in parameter. This method
             /// will be deleted when the timerange is recovered from SciQlop
-            std::unique_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider,
+            std::shared_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider,
                                                                    const SqpDateTime &dateTime) noexcept
             {
                 auto parameters = DataProviderParameters{dateTime};
                     // store the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
-                    qRegisterMetaType<std::shared_ptr<IDataSeries> >();
-                    qRegisterMetaType<SqpDateTime>();
                     connect(provider.get(), &IDataProvider::dataProvided, newVariable.get(),
-                            &Variable::onAddDataSeries);
+                            &Variable::setDataSeries);
                     // store in cache

core/src/Variable/VariableModel.cpp +1 -1

             std::shared_ptr<Variable>
             VariableModel::createVariable(const QString &name, const SqpDateTime &dateTime,
-                                          std::unique_ptr<IDataSeries> defaultDataSeries) noexcept
+                                          std::shared_ptr<IDataSeries> defaultDataSeries) noexcept
             {
                 auto insertIndex = rowCount();
                 beginInsertRows({}, insertIndex, insertIndex);

gui/include/Visualization/VisualizationTabWidget.h +3 0

                 QString name() const override;
             private:
+                /// @return the layout of tab in which zones are added
+                QLayout &tabLayout() const noexcept;
                 Ui::VisualizationTabWidget *ui;
                 class VisualizationTabWidgetPrivate;

gui/src/SqpApplication.cpp 0 -2

                     // /////////////////////////////// //
                     // VariableController <-> DataSourceController
-                    qRegisterMetaType<std::shared_ptr<IDataProvider> >();
                     connect(m_DataSourceController.get(),
                             SIGNAL(variableCreationRequested(const QString &, std::shared_ptr<IDataProvider>)),
                             m_VariableController.get(),
                             SLOT(createVariable(const QString &, std::shared_ptr<IDataProvider>)));
                     // VariableController <-> VisualizationController
-                    qRegisterMetaType<std::shared_ptr<Variable> >();
                     connect(m_VariableController.get(), SIGNAL(variableCreated(std::shared_ptr<Variable>)),
                             m_VisualizationController.get(),
                             SIGNAL(variableCreated(std::shared_ptr<Variable>)));

gui/src/Visualization/VisualizationTabWidget.cpp +10 -4

             void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
             {
-                this->layout()->addWidget(zoneWidget);
+                tabLayout().addWidget(zoneWidget);
             }
             VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
             {
-                auto zoneWidget = new VisualizationZoneWidget{defaultZoneName(*layout()), this};
+                auto zoneWidget = new VisualizationZoneWidget{defaultZoneName(tabLayout()), this};
                 this->addZone(zoneWidget);
                 // Creates a new graph into the zone
                     visitor->visitEnter(this);
                     // Apply visitor to zone children
-                    for (auto i = 0; i < layout()->count(); ++i) {
+                    auto &layout = tabLayout();
-                        if (auto item = layout()->itemAt(i)) {
+                    for (auto i = 0; i < layout.count(); ++i) {
+                        if (auto item = layout.itemAt(i)) {
                             // Widgets different from zones are not visited (no action)
                             if (auto visualizationZoneWidget
                                 = dynamic_cast<VisualizationZoneWidget *>(item->widget())) {
             {
                 return impl->m_Name;
             }
+            QLayout &VisualizationTabWidget::tabLayout() const noexcept
+            {
+                return *ui->scrollAreaWidgetContents->layout();
+            }

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

             namespace {
+            /// Minimum height for graph added in zones (in pixels)
+            const auto GRAPH_MINIMUM_HEIGHT = 300;
             /// Generates a default name for a new graph, according to the number of graphs already displayed in
             /// the zone
             QString defaultGraphName(const QLayout &layout)
             {
                 auto graphWidget = new VisualizationGraphWidget{
                     defaultGraphName(*ui->visualizationZoneFrame->layout()), this};
+                // Set graph properties
+                graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
+                graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
                 this->addGraph(graphWidget);
                 graphWidget->addVariable(variable);

gui/src/Visualization/operations/GenerateVariableMenuOperation.cpp +16 0

                 {
                 }
+                void visitRootEnter()
+                {
+                    // Creates the root menu
+                    m_MenuBuilder.addMenu(QObject::tr("Plot"));
+                }
+                void visitRootLeave()
+                {
+                    // Closes the root menu
+                    m_MenuBuilder.closeMenu();
+                }
                 void visitNodeEnter(const IVisualizationWidget &container)
                 {
                     // Opens a new menu associated to the node
             {
                 // VisualizationWidget is not intended to accommodate a variable
                 Q_UNUSED(widget)
+                impl->visitRootEnter();
             }
             void GenerateVariableMenuOperation::visitLeave(VisualizationWidget *widget)
             {
                 // VisualizationWidget is not intended to accommodate a variable
                 Q_UNUSED(widget)
+                impl->visitRootLeave();
             }
             void GenerateVariableMenuOperation::visitEnter(VisualizationTabWidget *tabWidget)

gui/ui/Visualization/VisualizationTabWidget.ui +41 -1

@@ -13,7 +13,47
13	<property name="windowTitle">	13	<property name="windowTitle">
14	<string>Form</string>	14	<string>Form</string>
15	</property>	15	</property>
16	<layout class="QVBoxLayout" name="verticalLayout"/>	16	<layout class="QVBoxLayout" name="verticalLayout">
		17	<property name="leftMargin">
		18	<number>0</number>
		19	</property>
		20	<property name="topMargin">
		21	<number>0</number>
		22	</property>
		23	<property name="rightMargin">
		24	<number>0</number>
		25	</property>
		26	<property name="bottomMargin">
		27	<number>0</number>
		28	</property>
		29	<item>
		30	<widget class="QScrollArea" name="scrollArea">
		31	<property name="styleSheet">
		32	<string notr="true">background-color: transparent;</string>
		33	</property>
		34	<property name="frameShape">
		35	<enum>QFrame::NoFrame</enum>
		36	</property>
		37	<property name="frameShadow">
		38	<enum>QFrame::Sunken</enum>
		39	</property>
		40	<property name="widgetResizable">
		41	<bool>true</bool>
		42	</property>
		43	<widget class="QWidget" name="scrollAreaWidgetContents">
		44	<property name="geometry">
		45	<rect>
		46	<x>0</x>
		47	<y>0</y>
		48	<width>400</width>
		49	<height>300</height>
		50	</rect>
		51	</property>
		52	<layout class="QVBoxLayout" name="verticalLayout_3"/>
		53	</widget>
		54	</widget>
		55	</item>
		56	</layout>
17	</widget>	57	</widget>
18	<resources/>	58	<resources/>
19	<connections/>	59	<connections/>

plugins/mockplugin/include/CosinusProvider.h +1 -1

             class CosinusProvider : public IDataProvider {
             public:
                 /// @sa IDataProvider::retrieveData()
-                std::unique_ptr<IDataSeries>
+                std::shared_ptr<IDataSeries>
                 retrieveData(const DataProviderParameters &parameters) const override;
                 void requestDataLoading(const QVector<SqpDateTime> &dateTimeList) override;

plugins/mockplugin/src/CosinusProvider.cpp +10 -37

@@ -9,47 +9,11
9		9
10	Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")	10	Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
11		11
12	std::~~unique~~_ptr<IDataSeries>	12	std::shared_ptr<IDataSeries>
13	CosinusProvider::retrieveData(const DataProviderParameters &parameters) const	13	CosinusProvider::retrieveData(const DataProviderParameters &parameters) const
14	{	14	{
15	auto dateTime = parameters.m_Time;	15	auto dateTime = parameters.m_Time;
16		16
17	// Gets the timerange from the parameters
18	auto start = dateTime.m_TStart;
19	auto end = dateTime.m_TEnd;
20
21
22	// We assure that timerange is valid
23	if (end < start) {
24	std::swap(start, end);
25	}
26
27	// Generates scalar series containing cosinus values (one value per second)
28	auto scalarSeries
29	= std::make_unique<ScalarSeries>(end - start, Unit{QStringLiteral("t"), true}, Unit{});
30
31	auto dataIndex = 0;
32	for (auto time = start; time < end; ++time, ++dataIndex) {
33	scalarSeries->setData(dataIndex, time, std::cos(time));
34	}
35
36	return scalarSeries;
37	}
38
39	void CosinusProvider::requestDataLoading(const QVector<SqpDateTime> &dateTimeList)
40	{
41	// NOTE: Try to use multithread if possible
42	for (const auto &dateTime : dateTimeList) {
43
44	auto scalarSeries = this->retrieveDataSeries(dateTime);
45
46	emit dataProvided(scalarSeries, dateTime);
47	}
48	}
49
50
51	std::shared_ptr<IDataSeries> CosinusProvider::retrieveDataSeries(const SqpDateTime &dateTime)
52	{
53	auto dataIndex = 0;	17	auto dataIndex = 0;
54		18
55	// Gets the timerange from the parameters	19	// Gets the timerange from the parameters
@@ -72,3 +36,12 std::shared_ptr<IDataSeries> CosinusProvider::retrieveDataSeries(const SqpDateTi
72	}	36	}
73	return scalarSeries;	37	return scalarSeries;
74	}	38	}
		39
		40	void CosinusProvider::requestDataLoading(const QVector<SqpDateTime> &dateTimeList)
		41	{
		42	// NOTE: Try to use multithread if possible
		43	for (const auto &dateTime : dateTimeList) {
		44	auto scalarSeries = this->retrieveData(DataProviderParameters{dateTime});
		45	emit dataProvided(scalarSeries, dateTime);
		46	}
		47	}

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