GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1349:aa6b3e9d2907

Merge branch 'feature/CatalogueGuiPart5' into develop

trabillard -

r1349:aa6b3e9d2907

parent child

Context file:

r1349:aa6b3e9d2907

core/include/Data/DataSeriesType.h created 644 +26 0

@@ -0,0 +1,26
	1	#ifndef SCIQLOP_DATASERIESTYPE_H
	2	#define SCIQLOP_DATASERIESTYPE_H
	3
	4	#include <QString>
	5
	6	enum class DataSeriesType { SCALAR, SPECTROGRAM, VECTOR, UNKNOWN };
	7
	8	struct DataSeriesTypeUtils {
	9	static DataSeriesType fromString(const QString &type)
	10	{
	11	if (type == QStringLiteral("scalar")) {
	12	return DataSeriesType::SCALAR;
	13	}
	14	else if (type == QStringLiteral("spectrogram")) {
	15	return DataSeriesType::SPECTROGRAM;
	16	}
	17	else if (type == QStringLiteral("vector")) {
	18	return DataSeriesType::VECTOR;
	19	}
	20	else {
	21	return DataSeriesType::UNKNOWN;
	22	}
	23	}
	24	};
	25
	26	#endif // SCIQLOP_DATASERIESTYPE_H

app/src/MainWindow.cpp +2 -2

                 if (hasChanges) {
                     // There are some unsaved changes
                     switch (QMessageBox::question(
-                        parentWidget, "Save changes",
+                        parentWidget, tr("Save changes"),
-                        tr("The catalogue controller unsaved changes.\nDo you want to save them ?"),
+                        tr("The catalogue controller has unsaved changes.\nDo you want to save them ?"),
                         QMessageBox::SaveAll | QMessageBox::Discard | QMessageBox::Cancel,
                         QMessageBox::SaveAll)) {
                         case QMessageBox::SaveAll:

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

                 void initialize();
                 void finalize();
+                /// Request the creation of a variable from the ID_DATA_KEY of a product
+                void requestVariableFromProductIdKey(const QString &datasourceIdKey);
+                /// Request the creation of a variable from metadata of a product
                 void requestVariable(const QVariantHash &productData);
             signals:

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

                  */
                 DataSourceItem *findItem(const QVariantHash &data, bool recursive);
+                /**
+                 * @brief Searches the first child matching the specified \p ID_DATA_KEY in its metadata.
+                 * @param id The id to search.
+                 * @param recursive So the search recursively.
+                 * @return the item matching the data or nullptr if it was not found.
+                 */
+                DataSourceItem *findItem(const QString &datasourceIdKey, bool recursive);
                 bool operator==(const DataSourceItem &other);
                 bool operator!=(const DataSourceItem &other);

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

             #include "CoreGlobal.h"
             #include <Data/DataSeriesIterator.h>
+            #include <Data/DataSeriesType.h>
             #include <Data/SqpRange.h>
             #include <QLoggingCategory>
                 /// @return the data of the variable, nullptr if there is no data
                 std::shared_ptr<IDataSeries> dataSeries() const noexcept;
+                /// @return the type of data that the variable holds
+                DataSeriesType type() const noexcept;
                 QVariantHash metadata() const noexcept;
                 bool contains(const SqpRange &range) const noexcept;
             signals:
                 void updated();
+                /// Signal emitted when when the data series of the variable is loaded for the first time
+                void dataInitialized();
             private:
                 class VariablePrivate;

core/include/Variable/VariableController.h +22 -20

@@ -48,26 +48,6 public:
48	*/	48	*/
49	std::shared_ptr<Variable> cloneVariable(std::shared_ptr<Variable> variable) noexcept;	49	std::shared_ptr<Variable> cloneVariable(std::shared_ptr<Variable> variable) noexcept;
50		50
51	/**
52	* Deletes from the controller the variable passed in parameter.
53	*
54	* Delete a variable includes:
55	* - the deletion of the various references to the variable in SciQlop
56	* - the deletion of the model variable
57	* - the deletion of the provider associated with the variable
58	* - removing the cache associated with the variable
59	*
60	* @param variable the variable to delete from the controller.
61	*/
62	void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
63
64	/**
65	* Deletes from the controller the variables passed in parameter.
66	* @param variables the variables to delete from the controller.
67	* @sa deleteVariable()
68	*/
69	void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
70
71	/// Returns the MIME data associated to a list of variables	51	/// Returns the MIME data associated to a list of variables
72	QByteArray mimeDataForVariables(const QList<std::shared_ptr<Variable> > &variables) const;	52	QByteArray mimeDataForVariables(const QList<std::shared_ptr<Variable> > &variables) const;
73		53
@@ -89,7 +69,29 signals:
89	/// validated, canceled, or failed)	69	/// validated, canceled, or failed)
90	void acquisitionFinished();	70	void acquisitionFinished();
91		71
		72	void variableAdded(const std::shared_ptr<Variable> &variable);
		73
92	public slots:	74	public slots:
		75	/**
		76	* Deletes from the controller the variable passed in parameter.
		77	*
		78	* Delete a variable includes:
		79	* - the deletion of the various references to the variable in SciQlop
		80	* - the deletion of the model variable
		81	* - the deletion of the provider associated with the variable
		82	* - removing the cache associated with the variable
		83	*
		84	* @param variable the variable to delete from the controller.
		85	*/
		86	void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
		87
		88	/**
		89	* Deletes from the controller the variables passed in parameter.
		90	* @param variables the variables to delete from the controller.
		91	* @sa deleteVariable()
		92	*/
		93	void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
		94
93	/// Request the data loading of the variable whithin range	95	/// Request the data loading of the variable whithin range
94	void onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables, const SqpRange &range,	96	void onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables, const SqpRange &range,
95	bool synchronise);	97	bool synchronise);

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

@@ -37,6 +37,20 public:
37		37
38	return sourceItem;	38	return sourceItem;
39	}	39	}
		40
		41	// Search for the first datasource item matching the specified ID_DATA_KEY
		42	DataSourceItem *findDataSourceItem(const QString &datasourceIdKey)
		43	{
		44	DataSourceItem *sourceItem = nullptr;
		45	for (const auto &item : m_DataSourceItems) {
		46	sourceItem = item.second->findItem(datasourceIdKey, true);
		47	if (sourceItem) {
		48	break;
		49	}
		50	}
		51
		52	return sourceItem;
		53	}
40	};	54	};
41		55
42	DataSourceController::DataSourceController(QObject *parent)	56	DataSourceController::DataSourceController(QObject *parent)
@@ -149,6 +163,20 void DataSourceController::finalize()
149	impl->m_WorkingMutex.unlock();	163	impl->m_WorkingMutex.unlock();
150	}	164	}
151		165
		166	void DataSourceController::requestVariableFromProductIdKey(const QString &datasourceIdKey)
		167	{
		168	auto sourceItem = impl->findDataSourceItem(datasourceIdKey);
		169
		170	if (sourceItem) {
		171	auto sourceName = sourceItem->rootItem().name();
		172	auto sourceId = impl->m_DataSources.key(sourceName);
		173	loadProductItem(sourceId, *sourceItem);
		174	}
		175	else {
		176	qCWarning(LOG_DataSourceController()) << tr("requestVariable, product data not found");
		177	}
		178	}
		179
152	void DataSourceController::requestVariable(const QVariantHash &productData)	180	void DataSourceController::requestVariable(const QVariantHash &productData)
153	{	181	{
154	auto sourceItem = impl->findDataSourceItem(productData);	182	auto sourceItem = impl->findDataSourceItem(productData);

core/src/DataSource/DataSourceItem.cpp +18 0

@@ -165,6 +165,24 DataSourceItem *DataSourceItem::findItem(const QVariantHash &data, bool recursiv
165	return nullptr;	165	return nullptr;
166	}	166	}
167		167
		168	DataSourceItem *DataSourceItem::findItem(const QString &datasourceIdKey, bool recursive)
		169	{
		170	for (const auto &child : impl->m_Children) {
		171	auto childId = child->impl->m_Data.value(ID_DATA_KEY);
		172	if (childId == datasourceIdKey) {
		173	return child.get();
		174	}
		175
		176	if (recursive) {
		177	if (auto foundItem = child->findItem(datasourceIdKey, true)) {
		178	return foundItem;
		179	}
		180	}
		181	}
		182
		183	return nullptr;
		184	}
		185
168	bool DataSourceItem::operator==(const DataSourceItem &other)	186	bool DataSourceItem::operator==(const DataSourceItem &other)
169	{	187	{
170	// Compares items' attributes	188	// Compares items' attributes

core/src/Variable/Variable.cpp +44 -2

             Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
+            namespace {
+            /**
+             * Searches in metadata for a value that can be converted to DataSeriesType
+             * @param metadata the metadata where to search
+             * @return the value converted to a DataSeriesType if it was found, UNKNOWN type otherwise
+             * @sa DataSeriesType
+             */
+            DataSeriesType findDataSeriesType(const QVariantHash &metadata)
+            {
+                auto dataSeriesType = DataSeriesType::UNKNOWN;
+                // Go through the metadata and stop at the first value that could be converted to DataSeriesType
+                for (auto it = metadata.cbegin(), end = metadata.cend();
+                     it != end && dataSeriesType == DataSeriesType::UNKNOWN; ++it) {
+                    dataSeriesType = DataSeriesTypeUtils::fromString(it.value().toString());
+                }
+                return dataSeriesType;
+            }
+            } // namespace
             struct Variable::VariablePrivate {
                 explicit VariablePrivate(const QString &name, const QVariantHash &metadata)
                         : m_Name{name},
                           m_Metadata{metadata},
                           m_DataSeries{nullptr},
                           m_RealRange{INVALID_RANGE},
-                          m_NbPoints{0}
+                          m_NbPoints{0},
+                          m_Type{findDataSeriesType(m_Metadata)}
                 {
                 }
                           m_Metadata{other.m_Metadata},
                           m_DataSeries{other.m_DataSeries != nullptr ? other.m_DataSeries->clone() : nullptr},
                           m_RealRange{other.m_RealRange},
-                          m_NbPoints{other.m_NbPoints}
+                          m_NbPoints{other.m_NbPoints},
+                          m_Type{findDataSeriesType(m_Metadata)}
                 {
                 }
                 std::shared_ptr<IDataSeries> m_DataSeries;
                 SqpRange m_RealRange;
                 int m_NbPoints;
+                DataSeriesType m_Type;
                 QReadWriteLock m_Lock;
             };
                     return;
                 }
+                auto dataInit = false;
                 // Add or merge the data
                 impl->lockWrite();
                 if (!impl->m_DataSeries) {
                     impl->m_DataSeries = dataSeries->clone();
+                    dataInit = true;
                 }
                 else {
                     impl->m_DataSeries->merge(dataSeries.get());
                 }
                 impl->purgeDataSeries();
                 impl->unlock();
+                if (dataInit) {
+                    emit dataInitialized();
+                }
             }
                 return dataSeries;
             }
+            DataSeriesType Variable::type() const noexcept
+            {
+                impl->lockRead();
+                auto type = impl->m_Type;
+                impl->unlock();
+                return type;
+            }
             QVariantHash Variable::metadata() const noexcept
             {
                 impl->lockRead();

core/src/Variable/VariableController.cpp +2 0

                     //        impl->processRequest(newVariable, range, varRequestId);
                     //        impl->updateVariableRequest(varRequestId);
+                    emit variableAdded(newVariable);
                     return newVariable;
                 }

gui/include/Catalogue/CatalogueEventsWidget.h +6 0

             class DBEvent;
             class DBEventProduct;
             class VisualizationWidget;
+            class VisualizationSelectionZoneItem;
             namespace Ui {
             class CatalogueEventsWidget;
             signals:
                 void eventsSelected(const QVector<std::shared_ptr<DBEvent> > &event);
+                void eventsRemoved(const QVector<std::shared_ptr<DBEvent> > &event);
                 void eventProductsSelected(
                     const QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > >
                         &eventproducts);
                 void selectionCleared();
+                void selectionZoneAdded(const std::shared_ptr<DBEvent> &event, const QString &productId,
+                                        VisualizationSelectionZoneItem *selectionZone);
             public:
                 explicit CatalogueEventsWidget(QWidget *parent = 0);
                 bool isAllEventsDisplayed() const;
                 bool isEventDisplayed(const std::shared_ptr<DBEvent> &event) const;
+                void refreshEvent(const std::shared_ptr<DBEvent> &event);
             public slots:
                 void populateWithCatalogues(const QVector<std::shared_ptr<DBCatalogue> > &catalogues);
                 void populateWithAllEvents();

gui/include/Catalogue/CatalogueExplorer.h +8 0

             class CatalogueSideBarWidget;
             class VisualizationWidget;
+            class VisualizationSelectionZoneItem;
+            class DBEvent;
             class CatalogueExplorer : public QDialog {
                 Q_OBJECT
                 CatalogueEventsWidget &eventsWidget() const;
                 CatalogueSideBarWidget &sideBarWidget() const;
+                void clearSelectionZones();
+                void addSelectionZoneItem(const std::shared_ptr<DBEvent> &event, const QString &productId,
+                                          VisualizationSelectionZoneItem *selectionZone);
             private:
                 Ui::CatalogueExplorer *ui;

gui/include/Catalogue/CatalogueInspectorWidget.h +2 0

                                      const std::shared_ptr<DBEventProduct> &eventProduct);
                 void setCatalogue(const std::shared_ptr<DBCatalogue> &catalogue);
+                void refresh();
             public slots:
                 void showPage(Page page);

gui/include/Visualization/AxisRenderingUtils.h +9 -2

             class QCPAxis;
             class QCustomPlot;
             class SqpColorScale;
+            class Variable;
             /// Formats a data value according to the axis on which it is present
             QString formatValue(double value, const QCPAxis &axis);
                 /// @param plot the plot for which to set axe properties
                 /// @param colorScale the color scale for which to set properties
                 virtual void setProperties(QCustomPlot &plot, SqpColorScale &colorScale) = 0;
+                /// Set the units of the plot's axes and the color scale associated to plot passed as
+                /// parameters
+                /// @param plot the plot for which to set axe units
+                /// @param colorScale the color scale for which to set unit
+                virtual void setUnits(QCustomPlot &plot, SqpColorScale &colorScale) = 0;
             };
             struct IAxisHelperFactory {
-                /// Creates IAxisHelper according to a data series
+                /// Creates IPlottablesHelper according to the type of data series a variable holds
-                static std::unique_ptr<IAxisHelper> create(std::shared_ptr<IDataSeries> dataSeries) noexcept;
+                static std::unique_ptr<IAxisHelper> create(const Variable &variable) noexcept;
             };
             #endif // SCIQLOP_AXISRENDERINGUTILS_H

gui/include/Visualization/PlottablesRenderingUtils.h +5 -4

             #ifndef SCIQLOP_PLOTTABLESRENDERINGUTILS_H
             #define SCIQLOP_PLOTTABLESRENDERINGUTILS_H
+            #include <Data/DataSeriesType.h>
             #include <Visualization/VisualizationDefs.h>
             #include <memory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_PlottablesRenderingUtils)
-            class IDataSeries;
             class QCPColorScale;
             class QCustomPlot;
+            class Variable;
             /**
              * Helper used to handle plottables rendering
             };
             struct IPlottablesHelperFactory {
-                /// Creates IPlottablesHelper according to a data series
+                /// Creates IPlottablesHelper according to the type of data series a variable holds
-                static std::unique_ptr<IPlottablesHelper>
+                static std::unique_ptr<IPlottablesHelper> create(const Variable &variable) noexcept;
-                create(std::shared_ptr<IDataSeries> dataSeries) noexcept;
             };
             #endif // SCIQLOP_PLOTTABLESRENDERINGUTILS_H

gui/include/Visualization/VisualizationGraphHelper.h +1 -1

                  */
                 static PlottablesMap create(std::shared_ptr<Variable> variable, QCustomPlot &plot) noexcept;
-                static void updateData(PlottablesMap &plottables, std::shared_ptr<IDataSeries> dataSeries,
+                static void updateData(PlottablesMap &plottables, std::shared_ptr<Variable> variable,
                                        const SqpRange &dateTime);
                 static void setYAxisRange(std::shared_ptr<Variable> variable, QCustomPlot &plot) noexcept;

gui/include/Visualization/VisualizationGraphRenderingDelegate.h +7 -5

             class QCustomPlot;
             class QMouseEvent;
             class Unit;
+            class Variable;
             class VisualizationGraphWidget;
             class VisualizationGraphRenderingDelegate {
                 /// Updates rendering when data of plot changed
                 void onPlotUpdated() noexcept;
-                /// Sets properties of the plot's axes from the data series passed as parameter
+                /// Sets units of the plot's axes according to the properties of the variable passed as
-                void setAxesProperties(std::shared_ptr<IDataSeries> dataSeries) noexcept;
+                /// parameter
+                void setAxesUnits(const Variable &variable) noexcept;
-                /// Sets rendering properties of the plottables passed as parameter, from the data series that
+                /// Sets graph properties of the plottables passed as parameter, from the variable that
                 /// generated these
-                void setPlottablesProperties(std::shared_ptr<IDataSeries> dataSeries,
+                void setGraphProperties(const Variable &variable, PlottablesMap &plottables) noexcept;
-                                             PlottablesMap &plottables) noexcept;
                 /// Shows or hides graph overlay (name, close button, etc.)
                 void showGraphOverlay(bool show) noexcept;

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

                 /// Sets the y-axis range based on the data of a variable
                 void setYRange(std::shared_ptr<Variable> variable);
                 SqpRange graphRange() const noexcept;
-                void setGraphRange(const SqpRange &range);
+                void setGraphRange(const SqpRange &range, bool calibration = false);
+                void setAutoRangeOnVariableInitialization(bool value);
                 // Zones
                 /// Returns the ranges of all the selection zones on the graph
                 QVector<SqpRange> selectionZoneRanges() const;
                 /// Adds new selection zones in the graph
                 void addSelectionZones(const QVector<SqpRange> &ranges);
+                /// Adds a new selection zone in the graph
+                VisualizationSelectionZoneItem *addSelectionZone(const QString &name, const SqpRange &range);
                 /// Removes the specified selection zone
                 void removeSelectionZone(VisualizationSelectionZoneItem *selectionZone);

gui/include/Visualization/VisualizationSelectionZoneItem.h +5 0

             class VisualizationGraphWidget;
             class VisualizationSelectionZoneItem : public QCPItemRect {
+                Q_OBJECT
+            signals:
+                /// Signal emitted when the zone range is edited manually
+                void rangeEdited(const SqpRange &range);
             public:
                 VisualizationSelectionZoneItem(QCustomPlot *plot);

gui/meson.build +1 0

               'include/Visualization/VisualizationDragDropContainer.h',
               'include/Visualization/VisualizationDragWidget.h',
               'include/Visualization/ColorScaleEditor.h',
+              'include/Visualization/VisualizationSelectionZoneItem.h',
               'include/Actions/SelectionZoneAction.h',
               'include/Visualization/VisualizationMultiZoneSelectionDialog.h',
               'include/Catalogue/CatalogueExplorer.h',

gui/src/Catalogue/CatalogueActionManager.cpp +6 -2

                             auto eventProduct = std::make_shared<DBEventProduct>();
                             eventProduct->setEvent(*event);
+                            auto productId
+                                = var->metadata().value(DataSourceItem::ID_DATA_KEY, "UnknownID").toString();
                             auto zoneRange = zone->range();
                             eventProduct->setTStart(zoneRange.m_TStart);
                             eventProduct->setTEnd(zoneRange.m_TEnd);
-                            eventProduct->setProductId(
+                            eventProduct->setProductId(productId);
-                                var->metadata().value(DataSourceItem::ID_DATA_KEY, "UnknownID").toString());
                             productList.push_back(*eventProduct);
+                            m_CatalogueExplorer->addSelectionZoneItem(event, productId, zone);
                         }
                     }

gui/src/Catalogue/CatalogueEventsWidget.cpp +137 -17

@@ -6,7 +6,13
6	#include <Catalogue/CatalogueExplorerHelper.h>	6	#include <Catalogue/CatalogueExplorerHelper.h>
7	#include <CatalogueDao.h>	7	#include <CatalogueDao.h>
8	#include <DBCatalogue.h>	8	#include <DBCatalogue.h>
		9	#include <DBEventProduct.h>
		10	#include <DataSource/DataSourceController.h>
		11	#include <DataSource/DataSourceItem.h>
9	#include <SqpApplication.h>	12	#include <SqpApplication.h>
		13	#include <Variable/Variable.h>
		14	#include <Variable/VariableController.h>
		15	#include <Visualization/VisualizationGraphWidget.h>
10	#include <Visualization/VisualizationTabWidget.h>	16	#include <Visualization/VisualizationTabWidget.h>
11	#include <Visualization/VisualizationWidget.h>	17	#include <Visualization/VisualizationWidget.h>
12	#include <Visualization/VisualizationZoneWidget.h>	18	#include <Visualization/VisualizationZoneWidget.h>
@@ -21,6 +27,9 Q_LOGGING_CATEGORY(LOG_CatalogueEventsWidget, "CatalogueEventsWidget")
21	/// Fixed size of the validation column	27	/// Fixed size of the validation column
22	const auto VALIDATION_COLUMN_SIZE = 35;	28	const auto VALIDATION_COLUMN_SIZE = 35;
23		29
		30	/// Percentage added to the range of a event when it is displayed
		31	const auto EVENT_RANGE_MARGE = 30; // in %
		32
24	struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {	33	struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
25		34
26	CatalogueEventsModel *m_Model = nullptr;	35	CatalogueEventsModel *m_Model = nullptr;
@@ -28,6 +37,7 struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
28	QString m_ZoneForGraphMode;	37	QString m_ZoneForGraphMode;
29	QVector<std::shared_ptr<DBCatalogue> > m_DisplayedCatalogues;	38	QVector<std::shared_ptr<DBCatalogue> > m_DisplayedCatalogues;
30	bool m_AllEventDisplayed = false;	39	bool m_AllEventDisplayed = false;
		40	QVector<VisualizationGraphWidget *> m_CustomGraphs;
31		41
32	VisualizationWidget *m_VisualizationWidget = nullptr;	42	VisualizationWidget *m_VisualizationWidget = nullptr;
33		43
@@ -178,31 +188,134 struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
178	}	188	}
179	}	189	}
180		190
181	void updateForGraphMode(QTreeView *treeView)	191	QVector<SqpRange> getGraphRanges(const std::shared_ptr<DBEvent> &event)
182	{	192	{
183	auto selectedRows = treeView->selectionModel()->selectedRows();	193	// Retrieves the range of each product and the maximum size
		194	QVector<SqpRange> graphRanges;
		195	double maxDt = 0;
		196	for (auto eventProduct : event->getEventProducts()) {
		197	SqpRange eventRange;
		198	eventRange.m_TStart = eventProduct.getTStart();
		199	eventRange.m_TEnd = eventProduct.getTEnd();
		200	graphRanges << eventRange;
184		201
185	if (selectedRows.count() == 1) {	202	auto dt = eventRange.m_TEnd - eventRange.m_TStart;
186	auto event = m_Model->getEvent(selectedRows.first());	203	if (dt > maxDt) {
187	if (m_VisualizationWidget) {	204	maxDt = dt;
188	if (auto tab = m_VisualizationWidget->currentTabWidget()) {
189	if (auto zone = tab->getZoneWithName(m_ZoneForGraphMode)) {
190	// TODO
191	}	205	}
192	}	206	}
193	else {	207
194	qCWarning(LOG_CatalogueEventsWidget())	208	// Adds the marge
195	<< "updateGraphMode: no tab found in the visualization";	209	maxDt *= (100.0 + EVENT_RANGE_MARGE) / 100.0;
		210
		211	// Corrects the graph ranges so that they all have the same size
		212	QVector<SqpRange> correctedGraphRanges;
		213	for (auto range : graphRanges) {
		214	auto dt = range.m_TEnd - range.m_TStart;
		215	auto diff = qAbs((maxDt - dt) / 2.0);
		216
		217	SqpRange correctedRange;
		218	correctedRange.m_TStart = range.m_TStart - diff;
		219	correctedRange.m_TEnd = range.m_TEnd + diff;
		220
		221	correctedGraphRanges << correctedRange;
196	}	222	}
		223
		224	return correctedGraphRanges;
197	}	225	}
198	else {	226
		227	void updateForGraphMode(CatalogueEventsWidget *catalogueEventWidget)
		228	{
		229	auto selectedRows = catalogueEventWidget->ui->treeView->selectionModel()->selectedRows();
		230	if (selectedRows.count() != 1) {
		231	qCWarning(LOG_CatalogueEventsWidget())
		232	<< "updateGraphMode: not compatible with multiple events selected";
		233	return;
		234	}
		235
		236	if (!m_VisualizationWidget) {
199	qCWarning(LOG_CatalogueEventsWidget())	237	qCWarning(LOG_CatalogueEventsWidget())
200	<< "updateGraphMode: visualization widget not found";	238	<< "updateGraphMode: visualization widget not found";
		239	return;
201	}	240	}
		241
		242	auto event = m_Model->getEvent(selectedRows.first());
		243	if (!event) {
		244	// A event product is probably selected
		245	qCInfo(LOG_CatalogueEventsWidget()) << "updateGraphMode: no events are selected";
		246	return;
202	}	247	}
203	else {	248
		249	auto tab = m_VisualizationWidget->currentTabWidget();
		250	if (!tab) {
204	qCWarning(LOG_CatalogueEventsWidget())	251	qCWarning(LOG_CatalogueEventsWidget())
205	<< "updateGraphMode: no~~t compatible with multiple events selected~~";	252	<< "updateGraphMode: no tab found in the visualization";
		253	return;
		254	}
		255
		256	auto zone = tab->getZoneWithName(m_ZoneForGraphMode);
		257	if (!zone) {
		258	qCWarning(LOG_CatalogueEventsWidget()) << "updateGraphMode: zone not found";
		259	return;
		260	}
		261
		262	// Close the previous graph and delete the asociated variables
		263	for (auto graph : m_CustomGraphs) {
		264	graph->close();
		265	auto variables = graph->variables().toVector();
		266
		267	QMetaObject::invokeMethod(&sqpApp->variableController(), "deleteVariables",
		268	Qt::QueuedConnection,
		269	Q_ARG(QVector<std::shared_ptr<Variable> >, variables));
		270	}
		271	m_CustomGraphs.clear();
		272
		273	// Calculates the range of each graph which will be created
		274	auto graphRange = getGraphRanges(event);
		275
		276	// Loops through the event products and create the graph
		277	auto itRange = graphRange.cbegin();
		278	for (auto eventProduct : event->getEventProducts()) {
		279	auto productId = eventProduct.getProductId();
		280
		281	auto range = *itRange;
		282	++itRange;
		283
		284	SqpRange productRange;
		285	productRange.m_TStart = eventProduct.getTStart();
		286	productRange.m_TEnd = eventProduct.getTEnd();
		287
		288	auto context = new QObject{catalogueEventWidget};
		289	QObject::connect(
		290	&sqpApp->variableController(), &VariableController::variableAdded, context,
		291	[this, catalogueEventWidget, zone, context, event, range, productRange,
		292	productId](auto variable) {
		293
		294	if (variable->metadata().value(DataSourceItem::ID_DATA_KEY).toString()
		295	== productId) {
		296	auto graph = zone->createGraph(variable);
		297	graph->setAutoRangeOnVariableInitialization(false);
		298
		299	auto selectionZone
		300	= graph->addSelectionZone(event->getName(), productRange);
		301	emit catalogueEventWidget->selectionZoneAdded(event, productId,
		302	selectionZone);
		303	m_CustomGraphs << graph;
		304
		305	graph->setGraphRange(range, true);
		306
		307	// Removes the graph from the graph list if it is closed manually
		308	QObject::connect(graph, &VisualizationGraphWidget::destroyed,
		309	[this, graph]() { m_CustomGraphs.removeAll(graph); });
		310
		311	delete context; // removes the connection
		312	}
		313	},
		314	Qt::QueuedConnection);
		315
		316	QMetaObject::invokeMethod(&sqpApp->dataSourceController(),
		317	"requestVariableFromProductIdKey", Qt::QueuedConnection,
		318	Q_ARG(QString, productId));
206	}	319	}
207	}	320	}
208		321
@@ -256,7 +369,7 CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
256	this->mapToGlobal(ui->btnChart->frameGeometry().center()))	369	this->mapToGlobal(ui->btnChart->frameGeometry().center()))
257	.value(0);	370	.value(0);
258		371
259	impl->updateForGraphMode(ui->~~treeView~~);	372	impl->updateForGraphMode(this);
260	}	373	}
261	});	374	});
262		375
@@ -268,7 +381,7 CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
268	if (!events.isEmpty() && eventProducts.isEmpty()) {	381	if (!events.isEmpty() && eventProducts.isEmpty()) {
269		382
270	if (QMessageBox::warning(this, tr("Remove Event(s)"),	383	if (QMessageBox::warning(this, tr("Remove Event(s)"),
271	tr("The selected event(s) will be ~~com~~pletly removed "	384	tr("The selected event(s) will be permanently removed "
272	"from the repository!\nAre you sure you want to continue?"),	385	"from the repository!\nAre you sure you want to continue?"),
273	QMessageBox::Yes \| QMessageBox::No, QMessageBox::No)	386	QMessageBox::Yes \| QMessageBox::No, QMessageBox::No)
274	== QMessageBox::Yes) {	387	== QMessageBox::Yes) {
@@ -277,6 +390,8 CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
277	sqpApp->catalogueController().removeEvent(event);	390	sqpApp->catalogueController().removeEvent(event);
278	impl->removeEvent(event, ui->treeView);	391	impl->removeEvent(event, ui->treeView);
279	}	392	}
		393
		394	emit this->eventsRemoved(events);
280	}	395	}
281	}	396	}
282	});	397	});
@@ -295,7 +410,7 CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
295	impl->updateForTimeMode(ui->treeView);	410	impl->updateForTimeMode(ui->treeView);
296	}	411	}
297	else if (isNotMultiSelection && ui->btnChart->isChecked()) {	412	else if (isNotMultiSelection && ui->btnChart->isChecked()) {
298	impl->updateForGraphMode(ui->~~treeView~~);	413	impl->updateForGraphMode(this);
299	}	414	}
300		415
301	QVector<std::shared_ptr<DBEvent> > events;	416	QVector<std::shared_ptr<DBEvent> > events;
@@ -398,6 +513,11 bool CatalogueEventsWidget::isEventDisplayed(const std::shared_ptr<DBEvent> &eve
398	return impl->m_Model->indexOf(event).isValid();	513	return impl->m_Model->indexOf(event).isValid();
399	}	514	}
400		515
		516	void CatalogueEventsWidget::refreshEvent(const std::shared_ptr<DBEvent> &event)
		517	{
		518	impl->m_Model->refreshEvent(event, true);
		519	}
		520
401	void CatalogueEventsWidget::populateWithCatalogues(	521	void CatalogueEventsWidget::populateWithCatalogues(
402	const QVector<std::shared_ptr<DBCatalogue> > &catalogues)	522	const QVector<std::shared_ptr<DBCatalogue> > &catalogues)
403	{	523	{

gui/src/Catalogue/CatalogueExplorer.cpp +67 0

@@ -4,13 +4,22
4	#include <Catalogue/CatalogueActionManager.h>	4	#include <Catalogue/CatalogueActionManager.h>
5	#include <Catalogue/CatalogueController.h>	5	#include <Catalogue/CatalogueController.h>
6	#include <SqpApplication.h>	6	#include <SqpApplication.h>
		7	#include <Visualization/VisualizationGraphWidget.h>
		8	#include <Visualization/VisualizationSelectionZoneItem.h>
7	#include <Visualization/VisualizationWidget.h>	9	#include <Visualization/VisualizationWidget.h>
8		10
9	#include <DBCatalogue.h>	11	#include <DBCatalogue.h>
10	#include <DBEvent.h>	12	#include <DBEvent.h>
		13	#include <DBEventProduct.h>
		14
		15	#include <unordered_map>
11		16
12	struct CatalogueExplorer::CatalogueExplorerPrivate {	17	struct CatalogueExplorer::CatalogueExplorerPrivate {
13	CatalogueActionManager m_ActionManager;	18	CatalogueActionManager m_ActionManager;
		19	std::unordered_map<std::shared_ptr<DBEvent>, QVector<VisualizationSelectionZoneItem *> >
		20	m_SelectionZonesPerEvents;
		21
		22	QMetaObject::Connection m_Conn;
14		23
15	CatalogueExplorerPrivate(CatalogueExplorer *catalogueExplorer)	24	CatalogueExplorerPrivate(CatalogueExplorer *catalogueExplorer)
16	: m_ActionManager(catalogueExplorer)	25	: m_ActionManager(catalogueExplorer)
@@ -27,6 +36,7 CatalogueExplorer::CatalogueExplorer(QWidget *parent)
27		36
28	impl->m_ActionManager.installSelectionZoneActions();	37	impl->m_ActionManager.installSelectionZoneActions();
29		38
		39	// Updates events and inspector when something is selected in the catalogue widget
30	connect(ui->catalogues, &CatalogueSideBarWidget::catalogueSelected, [this](auto catalogues) {	40	connect(ui->catalogues, &CatalogueSideBarWidget::catalogueSelected, [this](auto catalogues) {
31	if (catalogues.count() == 1) {	41	if (catalogues.count() == 1) {
32	ui->inspector->setCatalogue(catalogues.first());	42	ui->inspector->setCatalogue(catalogues.first());
@@ -66,6 +76,7 CatalogueExplorer::CatalogueExplorer(QWidget *parent)
66	ui->events->clear();	76	ui->events->clear();
67	});	77	});
68		78
		79	// Updates the inspectot when something is selected in the events
69	connect(ui->events, &CatalogueEventsWidget::eventsSelected, [this](auto events) {	80	connect(ui->events, &CatalogueEventsWidget::eventsSelected, [this](auto events) {
70	if (events.count() == 1) {	81	if (events.count() == 1) {
71	ui->inspector->setEvent(events.first());	82	ui->inspector->setEvent(events.first());
@@ -88,6 +99,27 CatalogueExplorer::CatalogueExplorer(QWidget *parent)
88	connect(ui->events, &CatalogueEventsWidget::selectionCleared,	99	connect(ui->events, &CatalogueEventsWidget::selectionCleared,
89	[this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });	100	[this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
90		101
		102	// Manage Selection Zones associated to events
		103	connect(ui->events, &CatalogueEventsWidget::selectionZoneAdded,
		104	[this](auto event, auto productId, auto zone) {
		105	this->addSelectionZoneItem(event, productId, zone);
		106	});
		107
		108	connect(ui->events, &CatalogueEventsWidget::eventsRemoved, [this](auto events) {
		109	for (auto event : events) {
		110	auto associatedSelectionZonesIt = impl->m_SelectionZonesPerEvents.find(event);
		111	if (associatedSelectionZonesIt != impl->m_SelectionZonesPerEvents.cend()) {
		112	for (auto selectionZone : associatedSelectionZonesIt->second) {
		113	auto parentGraph = selectionZone->parentGraphWidget();
		114	parentGraph->removeSelectionZone(selectionZone);
		115	}
		116
		117	impl->m_SelectionZonesPerEvents.erase(event);
		118	}
		119	}
		120	});
		121
		122	// Updates changes from the inspector
91	connect(ui->inspector, &CatalogueInspectorWidget::catalogueUpdated, [this](auto catalogue) {	123	connect(ui->inspector, &CatalogueInspectorWidget::catalogueUpdated, [this](auto catalogue) {
92	sqpApp->catalogueController().updateCatalogue(catalogue);	124	sqpApp->catalogueController().updateCatalogue(catalogue);
93	ui->catalogues->setCatalogueChanges(catalogue, true);	125	ui->catalogues->setCatalogueChanges(catalogue, true);
@@ -107,6 +139,7 CatalogueExplorer::CatalogueExplorer(QWidget *parent)
107		139
108	CatalogueExplorer::~CatalogueExplorer()	140	CatalogueExplorer::~CatalogueExplorer()
109	{	141	{
		142	disconnect(impl->m_Conn);
110	delete ui;	143	delete ui;
111	}	144	}
112		145
@@ -124,3 +157,37 CatalogueSideBarWidget &CatalogueExplorer::sideBarWidget() const
124	{	157	{
125	return *ui->catalogues;	158	return *ui->catalogues;
126	}	159	}
		160
		161	void CatalogueExplorer::clearSelectionZones()
		162	{
		163	impl->m_SelectionZonesPerEvents.clear();
		164	}
		165
		166	void CatalogueExplorer::addSelectionZoneItem(const std::shared_ptr<DBEvent> &event,
		167	const QString &productId,
		168	VisualizationSelectionZoneItem *selectionZone)
		169	{
		170	impl->m_SelectionZonesPerEvents[event] << selectionZone;
		171	connect(selectionZone, &VisualizationSelectionZoneItem::rangeEdited,
		172	[event, productId, this](auto range) {
		173	auto productList = event->getEventProducts();
		174	for (auto &product : productList) {
		175	if (product.getProductId() == productId) {
		176	product.setTStart(range.m_TStart);
		177	product.setTEnd(range.m_TEnd);
		178	}
		179	}
		180	event->setEventProducts(productList);
		181	sqpApp->catalogueController().updateEvent(event);
		182	ui->events->refreshEvent(event);
		183	ui->events->setEventChanges(event, true);
		184	ui->inspector->refresh();
		185	});
		186
		187	impl->m_Conn = connect(selectionZone, &VisualizationSelectionZoneItem::destroyed,
		188	[event, selectionZone, this]() {
		189	if (!impl->m_SelectionZonesPerEvents.empty()) {
		190	impl->m_SelectionZonesPerEvents[event].removeAll(selectionZone);
		191	}
		192	});
		193	}

gui/src/Catalogue/CatalogueInspectorWidget.cpp +16 0

@@ -209,3 +209,19 void CatalogueInspectorWidget::setCatalogue(const std::shared_ptr<DBCatalogue> &
209		209
210	blockSignals(false);	210	blockSignals(false);
211	}	211	}
		212
		213	void CatalogueInspectorWidget::refresh()
		214	{
		215	switch (static_cast<Page>(ui->stackedWidget->currentIndex())) {
		216	case Page::CatalogueProperties:
		217	setCatalogue(impl->m_DisplayedCatalogue);
		218	break;
		219	case Page::EventProperties: {
		220	auto isEventShowed = ui->leEventName->isEnabled();
		221	setEvent(impl->m_DisplayedEvent);
		222	if (!isEventShowed && impl->m_DisplayedEvent) {
		223	setEventProduct(impl->m_DisplayedEvent, impl->m_DisplayedEventProduct);
		224	}
		225	}
		226	}
		227	}

gui/src/DragAndDrop/DragDropGuiController.cpp +12 0

             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/operations/FindVariableOperation.h"
+            #include "DataSource/DataSourceController.h"
             #include "Variable/Variable.h"
             #include "Variable/VariableController.h"
                         // result = false: cannot drop multiple variables in the visualisation
                     }
                 }
+                else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
+                    auto productDataList = sqpApp->dataSourceController().productsDataForMimeData(
+                        mimeData->data(MIME_TYPE_PRODUCT_LIST));
+                    if (productDataList.count() == 1) {
+                        result = true;
+                    }
+                    else {
+                        // result = false: cannot drop multiple products in the visualisation
+                    }
+                }
                 else {
                     // Other MIME data
                     // no special rules, accepted by default
                     result = true;
                 }
                 return result;
             }

gui/src/Visualization/AxisRenderingUtils.cpp +60 -30

             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
+            #include <Variable/Variable.h>
             #include <Visualization/SqpColorScale.h>
             #include <Visualization/qcustomplot.h>
              */
             template <typename T, typename Enabled = void>
             struct AxisSetter {
-                static void setProperties(T &, QCustomPlot &, SqpColorScale &)
+                static void setProperties(QCustomPlot &, SqpColorScale &)
                 {
                     // Default implementation does nothing
                     qCCritical(LOG_AxisRenderingUtils()) << "Can't set axis properties: unmanaged type of data";
                 }
+                static void setUnits(T &, QCustomPlot &, SqpColorScale &)
+                {
+                    // Default implementation does nothing
+                    qCCritical(LOG_AxisRenderingUtils()) << "Can't set axis units: unmanaged type of data";
+                }
             };
             /**
             template <typename T>
             struct AxisSetter<T, typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
                                                            or std::is_base_of<VectorSeries, T>::value> > {
-                static void setProperties(T &dataSeries, QCustomPlot &plot, SqpColorScale &)
+                static void setProperties(QCustomPlot &, SqpColorScale &)
+                {
+                    // Nothing to do
+                }
+                static void setUnits(T &dataSeries, QCustomPlot &plot, SqpColorScale &)
                 {
                     dataSeries.lockRead();
                     auto xAxisUnit = dataSeries.xAxisUnit();
              */
             template <typename T>
             struct AxisSetter<T, typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
-                static void setProperties(T &dataSeries, QCustomPlot &plot, SqpColorScale &colorScale)
+                static void setProperties(QCustomPlot &plot, SqpColorScale &colorScale)
                 {
-                    dataSeries.lockRead();
-                    auto xAxisUnit = dataSeries.xAxisUnit();
-                    auto yAxisUnit = dataSeries.yAxisUnit();
-                    auto valuesUnit = dataSeries.valuesUnit();
-                    dataSeries.unlock();
-                    setAxisProperties(*plot.xAxis, xAxisUnit);
-                    setAxisProperties(*plot.yAxis, yAxisUnit, QCPAxis::stLogarithmic);
                     // Displays color scale in plot
                     plot.plotLayout()->insertRow(0);
                     plot.plotLayout()->addElement(0, 0, colorScale.m_Scale);
                     }
                     // Set color scale properties
-                    setAxisProperties(*colorScale.m_Scale->axis(), valuesUnit, QCPAxis::stLogarithmic);
                     colorScale.m_AutomaticThreshold = true;
                 }
+                static void setUnits(T &dataSeries, QCustomPlot &plot, SqpColorScale &colorScale)
+                {
+                    dataSeries.lockRead();
+                    auto xAxisUnit = dataSeries.xAxisUnit();
+                    auto yAxisUnit = dataSeries.yAxisUnit();
+                    auto valuesUnit = dataSeries.valuesUnit();
+                    dataSeries.unlock();
+                    setAxisProperties(*plot.xAxis, xAxisUnit);
+                    setAxisProperties(*plot.yAxis, yAxisUnit, QCPAxis::stLogarithmic);
+                    setAxisProperties(*colorScale.m_Scale->axis(), valuesUnit, QCPAxis::stLogarithmic);
+                }
             };
             /**
              */
             template <typename T>
             struct AxisHelper : public IAxisHelper {
-                explicit AxisHelper(T &dataSeries) : m_DataSeries{dataSeries} {}
+                explicit AxisHelper(std::shared_ptr<T> dataSeries) : m_DataSeries{dataSeries} {}
                 void setProperties(QCustomPlot &plot, SqpColorScale &colorScale) override
                 {
-                    AxisSetter<T>::setProperties(m_DataSeries, plot, colorScale);
+                    AxisSetter<T>::setProperties(plot, colorScale);
+                }
+                void setUnits(QCustomPlot &plot, SqpColorScale &colorScale) override
+                {
+                    if (m_DataSeries) {
+                        AxisSetter<T>::setUnits(*m_DataSeries, plot, colorScale);
+                    }
+                    else {
+                        qCCritical(LOG_AxisRenderingUtils()) << "Can't set units: inconsistency between the "
+                                                                "type of data series and the type supposed";
+                    }
                 }
-                T &m_DataSeries;
+                std::shared_ptr<T> m_DataSeries;
             };
             } // namespace
                 }
             }
-            std::unique_ptr<IAxisHelper>
+            std::unique_ptr<IAxisHelper> IAxisHelperFactory::create(const Variable &variable) noexcept
-            IAxisHelperFactory::create(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
-                if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
+                switch (variable.type()) {
-                    return std::make_unique<AxisHelper<ScalarSeries> >(*scalarSeries);
+                    case DataSeriesType::SCALAR:
+                        return std::make_unique<AxisHelper<ScalarSeries> >(
-                else if (auto spectrogramSeries = std::dynamic_pointer_cast<SpectrogramSeries>(dataSeries)) {
+                            std::dynamic_pointer_cast<ScalarSeries>(variable.dataSeries()));
-                    return std::make_unique<AxisHelper<SpectrogramSeries> >(*spectrogramSeries);
+                    case DataSeriesType::SPECTROGRAM:
+                        return std::make_unique<AxisHelper<SpectrogramSeries> >(
-                else if (auto vectorSeries = std::dynamic_pointer_cast<VectorSeries>(dataSeries)) {
+                            std::dynamic_pointer_cast<SpectrogramSeries>(variable.dataSeries()));
-                    return std::make_unique<AxisHelper<VectorSeries> >(*vectorSeries);
+                    case DataSeriesType::VECTOR:
+                        return std::make_unique<AxisHelper<VectorSeries> >(
-                else {
+                            std::dynamic_pointer_cast<VectorSeries>(variable.dataSeries()));
-                    return std::make_unique<AxisHelper<IDataSeries> >(*dataSeries);
+                    default:
+                        // Creates default helper
+                        break;
+                }
+                return std::make_unique<AxisHelper<IDataSeries> >(nullptr);
             }

gui/src/Visualization/PlottablesRenderingUtils.cpp +30 -26

             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
+            #include <Variable/Variable.h>
             #include <Visualization/qcustomplot.h>
             Q_LOGGING_CATEGORY(LOG_PlottablesRenderingUtils, "PlottablesRenderingUtils")
              */
             template <typename T, typename Enabled = void>
             struct PlottablesSetter {
-                static void setProperties(T &, PlottablesMap &)
+                static void setProperties(PlottablesMap &)
                 {
                     // Default implementation does nothing
                     qCCritical(LOG_PlottablesRenderingUtils())
             template <typename T>
             struct PlottablesSetter<T, typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
                                                                  or std::is_base_of<VectorSeries, T>::value> > {
-                static void setProperties(T &dataSeries, PlottablesMap &plottables)
+                static void setProperties(PlottablesMap &plottables)
                 {
-                    // Gets the number of components of the data series
+                    // Finds the plottable with the highest index to determine the number of colors to generate
-                    dataSeries.lockRead();
+                    auto end = plottables.cend();
-                    auto componentCount = dataSeries.valuesData()->componentCount();
+                    auto maxPlottableIndexIt
-                    dataSeries.unlock();
+                        = std::max_element(plottables.cbegin(), end, [](const auto &it1, const auto &it2) {
+                              return it1.first < it2.first;
+                          });
+                    auto componentCount = maxPlottableIndexIt != end ? maxPlottableIndexIt->first + 1 : 0;
                     // Generates colors for each component
                     auto colors = ColorUtils::colors(Qt::blue, Qt::red, componentCount);
                     // For each component of the data series, creates a QCPGraph to add to the plot
                     for (auto i = 0; i < componentCount; ++i) {
-                        auto graph = plottables.at(i);
+                        auto graphIt = plottables.find(i);
-                        graph->setPen(QPen{colors.at(i)});
+                        if (graphIt != end) {
+                            graphIt->second->setPen(QPen{colors.at(i)});
+                        }
                     }
                 }
             };
             template <typename T>
             struct PlottablesSetter<T,
                                     typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
-                static void setProperties(T &, PlottablesMap &plottables)
+                static void setProperties(PlottablesMap &plottables)
                 {
                     // Checks that for a spectrogram there is only one plottable, that is a colormap
                     if (plottables.size() != 1) {
              */
             template <typename T>
             struct PlottablesHelper : public IPlottablesHelper {
-                explicit PlottablesHelper(T &dataSeries) : m_DataSeries{dataSeries} {}
                 void setProperties(PlottablesMap &plottables) override
                 {
-                    PlottablesSetter<T>::setProperties(m_DataSeries, plottables);
+                    PlottablesSetter<T>::setProperties(plottables);
                 }
-                T &m_DataSeries;
             };
             } // namespace
             std::unique_ptr<IPlottablesHelper>
-            IPlottablesHelperFactory::create(std::shared_ptr<IDataSeries> dataSeries) noexcept
+            IPlottablesHelperFactory::create(const Variable &variable) noexcept
             {
-                if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
+                switch (variable.type()) {
-                    return std::make_unique<PlottablesHelper<ScalarSeries> >(*scalarSeries);
+                    case DataSeriesType::SCALAR:
+                        return std::make_unique<PlottablesHelper<ScalarSeries> >();
-                else if (auto spectrogramSeries = std::dynamic_pointer_cast<SpectrogramSeries>(dataSeries)) {
+                    case DataSeriesType::SPECTROGRAM:
-                    return std::make_unique<PlottablesHelper<SpectrogramSeries> >(*spectrogramSeries);
+                        return std::make_unique<PlottablesHelper<SpectrogramSeries> >();
+                    case DataSeriesType::VECTOR:
-                else if (auto vectorSeries = std::dynamic_pointer_cast<VectorSeries>(dataSeries)) {
+                        return std::make_unique<PlottablesHelper<VectorSeries> >();
-                    return std::make_unique<PlottablesHelper<VectorSeries> >(*vectorSeries);
+                    default:
+                        // Returns default helper
-                else {
+                        break;
-                    return std::make_unique<PlottablesHelper<IDataSeries> >(*dataSeries);
                 }
+                return std::make_unique<PlottablesHelper<IDataSeries> >();
             }

gui/src/Visualization/VisualizationGraphHelper.cpp +62 -41

              */
             template <typename T, typename Enabled = void>
             struct PlottablesCreator {
-                static PlottablesMap createPlottables(T &, QCustomPlot &)
+                static PlottablesMap createPlottables(QCustomPlot &)
                 {
                     qCCritical(LOG_DataSeries())
                         << QObject::tr("Can't create plottables: unmanaged data series type");
                 }
             };
-            /**
+            PlottablesMap createGraphs(QCustomPlot &plot, int nbGraphs)
-             * Specialization of PlottablesCreator for scalars and vectors
-             * @sa ScalarSeries
-             * @sa VectorSeries
-             */
-            template <typename T>
-            struct PlottablesCreator<T,
-                                     typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
-                                                               or std::is_base_of<VectorSeries, T>::value> > {
-                static PlottablesMap createPlottables(T &dataSeries, QCustomPlot &plot)
             {
                 PlottablesMap result{};
-                    // Gets the number of components of the data series
+                // Creates {nbGraphs} QCPGraph to add to the plot
-                    dataSeries.lockRead();
+                for (auto i = 0; i < nbGraphs; ++i) {
-                    auto componentCount = dataSeries.valuesData()->componentCount();
-                    dataSeries.unlock();
-                    // For each component of the data series, creates a QCPGraph to add to the plot
-                    for (auto i = 0; i < componentCount; ++i) {
                     auto graph = plot.addGraph();
                     result.insert({i, graph});
                 }
                 return result;
             }
+            /**
+             * Specialization of PlottablesCreator for scalars
+             * @sa ScalarSeries
+             */
+            template <typename T>
+            struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value> > {
+                static PlottablesMap createPlottables(QCustomPlot &plot) { return createGraphs(plot, 1); }
+            };
+            /**
+             * Specialization of PlottablesCreator for vectors
+             * @sa VectorSeries
+             */
+            template <typename T>
+            struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<VectorSeries, T>::value> > {
+                static PlottablesMap createPlottables(QCustomPlot &plot) { return createGraphs(plot, 3); }
             };
             /**
             template <typename T>
             struct PlottablesCreator<T,
                                      typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
-                static PlottablesMap createPlottables(T &dataSeries, QCustomPlot &plot)
+                static PlottablesMap createPlottables(QCustomPlot &plot)
                 {
                     PlottablesMap result{};
                     result.insert({0, new QCPColorMap{plot.xAxis, plot.yAxis}});
              */
             template <typename T>
             struct PlottablesHelper : public IPlottablesHelper {
-                explicit PlottablesHelper(T &dataSeries) : m_DataSeries{dataSeries} {}
+                explicit PlottablesHelper(std::shared_ptr<T> dataSeries) : m_DataSeries{dataSeries} {}
                 PlottablesMap create(QCustomPlot &plot) const override
                 {
-                    return PlottablesCreator<T>::createPlottables(m_DataSeries, plot);
+                    return PlottablesCreator<T>::createPlottables(plot);
                 }
                 void update(PlottablesMap &plottables, const SqpRange &range, bool rescaleAxes) const override
                 {
-                    PlottablesUpdater<T>::updatePlottables(m_DataSeries, plottables, range, rescaleAxes);
+                    if (m_DataSeries) {
+                        PlottablesUpdater<T>::updatePlottables(*m_DataSeries, plottables, range, rescaleAxes);
+                    }
+                    else {
+                        qCCritical(LOG_VisualizationGraphHelper()) << "Can't update plottables: inconsistency "
+                                                                      "between the type of data series and the "
+                                                                      "type supposed";
+                    }
                 }
                 void setYAxisRange(const SqpRange &xAxisRange, QCustomPlot &plot) const override
                 {
-                    return PlottablesUpdater<T>::setPlotYAxisRange(m_DataSeries, xAxisRange, plot);
+                    if (m_DataSeries) {
+                        PlottablesUpdater<T>::setPlotYAxisRange(*m_DataSeries, xAxisRange, plot);
+                    }
+                    else {
+                        qCCritical(LOG_VisualizationGraphHelper()) << "Can't update plottables: inconsistency "
+                                                                      "between the type of data series and the "
+                                                                      "type supposed";
+                    }
                 }
-                T &m_DataSeries;
+                std::shared_ptr<T> m_DataSeries;
             };
-            /// Creates IPlottablesHelper according to a data series
+            /// Creates IPlottablesHelper according to the type of data series a variable holds
-            std::unique_ptr<IPlottablesHelper> createHelper(std::shared_ptr<IDataSeries> dataSeries) noexcept
+            std::unique_ptr<IPlottablesHelper> createHelper(std::shared_ptr<Variable> variable) noexcept
             {
-                if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
+                switch (variable->type()) {
-                    return std::make_unique<PlottablesHelper<ScalarSeries> >(*scalarSeries);
+                    case DataSeriesType::SCALAR:
+                        return std::make_unique<PlottablesHelper<ScalarSeries> >(
-                else if (auto spectrogramSeries = std::dynamic_pointer_cast<SpectrogramSeries>(dataSeries)) {
+                            std::dynamic_pointer_cast<ScalarSeries>(variable->dataSeries()));
-                    return std::make_unique<PlottablesHelper<SpectrogramSeries> >(*spectrogramSeries);
+                    case DataSeriesType::SPECTROGRAM:
+                        return std::make_unique<PlottablesHelper<SpectrogramSeries> >(
-                else if (auto vectorSeries = std::dynamic_pointer_cast<VectorSeries>(dataSeries)) {
+                            std::dynamic_pointer_cast<SpectrogramSeries>(variable->dataSeries()));
-                    return std::make_unique<PlottablesHelper<VectorSeries> >(*vectorSeries);
+                    case DataSeriesType::VECTOR:
+                        return std::make_unique<PlottablesHelper<VectorSeries> >(
-                else {
+                            std::dynamic_pointer_cast<VectorSeries>(variable->dataSeries()));
-                    return std::make_unique<PlottablesHelper<IDataSeries> >(*dataSeries);
+                    default:
+                        // Creates default helper
+                        break;
                 }
+                return std::make_unique<PlottablesHelper<IDataSeries> >(nullptr);
             }
             } // namespace
                                                            QCustomPlot &plot) noexcept
             {
                 if (variable) {
-                    auto helper = createHelper(variable->dataSeries());
+                    auto helper = createHelper(variable);
                     auto plottables = helper->create(plot);
                     return plottables;
                 }
                                                          QCustomPlot &plot) noexcept
             {
                 if (variable) {
-                    auto helper = createHelper(variable->dataSeries());
+                    auto helper = createHelper(variable);
                     helper->setYAxisRange(variable->range(), plot);
                 }
                 else {
             }
             void VisualizationGraphHelper::updateData(PlottablesMap &plottables,
-                                                      std::shared_ptr<IDataSeries> dataSeries,
+                                                      std::shared_ptr<Variable> variable,
                                                       const SqpRange &dateTime)
             {
-                auto helper = createHelper(dataSeries);
+                auto helper = createHelper(variable);
                 helper->update(plottables, dateTime);
             }

gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp +15 -9

             #include <Common/DateUtils.h>
             #include <Data/IDataSeries.h>
+            #include <Variable/Variable.h>
             #include <SqpApplication.h>
                 impl->m_Plot.replot();
             }
-            void VisualizationGraphRenderingDelegate::setAxesProperties(
+            void VisualizationGraphRenderingDelegate::setAxesUnits(const Variable &variable) noexcept
-                std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
-                // Stores x-axis label to be able to retrieve it when x-axis pixmap is unselected
-                impl->m_XAxisLabel = dataSeries->xAxisUnit().m_Name;
-                auto axisHelper = IAxisHelperFactory::create(dataSeries);
+                auto axisHelper = IAxisHelperFactory::create(variable);
-                axisHelper->setProperties(impl->m_Plot, impl->m_ColorScale);
+                axisHelper->setUnits(impl->m_Plot, impl->m_ColorScale);
+                // Stores x-axis label to be able to retrieve it when x-axis pixmap is unselected
+                impl->m_XAxisLabel = impl->m_Plot.xAxis->label();
                 // Updates x-axis state
                 impl->updateXAxisState();
                 impl->m_Plot.layer(AXES_LAYER)->replot();
             }
-            void VisualizationGraphRenderingDelegate::setPlottablesProperties(
+            void VisualizationGraphRenderingDelegate::setGraphProperties(const Variable &variable,
-                std::shared_ptr<IDataSeries> dataSeries, PlottablesMap &plottables) noexcept
+                                                                         PlottablesMap &plottables) noexcept
             {
-                auto plottablesHelper = IPlottablesHelperFactory::create(dataSeries);
+                // Axes' properties
+                auto axisHelper = IAxisHelperFactory::create(variable);
+                axisHelper->setProperties(impl->m_Plot, impl->m_ColorScale);
+                // Plottables' properties
+                auto plottablesHelper = IPlottablesHelperFactory::create(variable);
                 plottablesHelper->setProperties(plottables);
             }

gui/src/Visualization/VisualizationGraphWidget.cpp +71 -20

                 {
                 }
-                void updateData(PlottablesMap &plottables, std::shared_ptr<IDataSeries> dataSeries,
+                void updateData(PlottablesMap &plottables, std::shared_ptr<Variable> variable,
                                 const SqpRange &range)
                 {
-                    VisualizationGraphHelper::updateData(plottables, dataSeries, range);
+                    VisualizationGraphHelper::updateData(plottables, variable, range);
                     // Prevents that data has changed to update rendering
                     m_RenderingDelegate->onPlotUpdated();
                 bool m_HasMovedMouse = false; // Indicates if the mouse moved in a releaseMouse even
+                bool m_VariableAutoRangeOnInit = true;
                 void startDrawingRect(const QPoint &pos, QCustomPlot &plot)
                 {
                     removeDrawingRect(plot);
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
             {
-                // Uses delegate to create the qcpplot components according to the variable
+                /// Lambda used to set graph's units and range according to the variable passed in parameter
-                auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
+                auto loadRange = [this](std::shared_ptr<Variable> variable, const SqpRange &range) {
+                    impl->m_RenderingDelegate->setAxesUnits(*variable);
+                    this->setFlags(GraphFlag::DisableAll);
+                    setGraphRange(range);
+                    this->setFlags(GraphFlag::EnableAll);
-                if (auto dataSeries = variable->dataSeries()) {
+                    emit requestDataLoading({variable}, range, false);
-                    // Set axes properties according to the units of the data series
+                };
-                    impl->m_RenderingDelegate->setAxesProperties(dataSeries);
-                    // Sets rendering properties for the new plottables
+                connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
-                    // Warning: this method must be called after setAxesProperties(), as it can access to some
-                    // axes properties that have to be initialized
+                // Calls update of graph's range and units when the data of the variable have been initialized.
-                    impl->m_RenderingDelegate->setPlottablesProperties(dataSeries, createdPlottables);
+                // Note: we use QueuedConnection here as the update event must be called in the UI thread
+                connect(variable.get(), &Variable::dataInitialized, this,
+                        [ varW = std::weak_ptr<Variable>{variable}, range, loadRange, this ]() {
+                            if (auto var = varW.lock()) {
+                                // If the variable is the first added in the graph, we load its range
+                                auto firstVariableInGraph = range == INVALID_RANGE;
+                                auto loadedRange = graphRange();
+                                if (impl->m_VariableAutoRangeOnInit) {
+                                    loadedRange = firstVariableInGraph ? var->range() : range;
+                                }
+                                loadRange(var, loadedRange);
+                                setYRange(var);
                             }
+                        },
+                        Qt::QueuedConnection);
-                impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
+                // Uses delegate to create the qcpplot components according to the variable
+                auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
-                connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
+                // Sets graph properties
+                impl->m_RenderingDelegate->setGraphProperties(*variable, createdPlottables);
-                this->setFlags(GraphFlag::DisableAll);
+                impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
-                this->setGraphRange(range);
-                this->setFlags(GraphFlag::EnableAll);
-                emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable, range, false);
+                // If the variable already has its data loaded, load its units and its range in the graph
+                if (variable->dataSeries() != nullptr) {
+                    loadRange(variable, range);
+                }
                 emit variableAdded(variable);
             }
                 return SqpRange{graphRange.lower, graphRange.upper};
             }
-            void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
+            void VisualizationGraphWidget::setGraphRange(const SqpRange &range, bool calibration)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
+                if (calibration) {
+                    impl->m_IsCalibration = true;
+                }
                 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                 ui->widget->replot();
+                if (calibration) {
+                    impl->m_IsCalibration = false;
+                }
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
             }
+            void VisualizationGraphWidget::setAutoRangeOnVariableInitialization(bool value)
+            {
+                impl->m_VariableAutoRangeOnInit = value;
+            }
             QVector<SqpRange> VisualizationGraphWidget::selectionZoneRanges() const
             {
                 QVector<SqpRange> ranges;
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
+            VisualizationSelectionZoneItem *VisualizationGraphWidget::addSelectionZone(const QString &name,
+                                                                                       const SqpRange &range)
+            {
+                // note: ownership is transfered to QCustomPlot
+                auto zone = new VisualizationSelectionZoneItem(&plot());
+                zone->setName(name);
+                zone->setRange(range.m_TStart, range.m_TEnd);
+                impl->addSelectionZone(zone);
+                plot().replot(QCustomPlot::rpQueuedReplot);
+                return zone;
+            }
             void VisualizationGraphWidget::removeSelectionZone(VisualizationSelectionZoneItem *selectionZone)
             {
                 parentVisualizationWidget()->selectionZoneManager().setSelected(selectionZone, false);
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
                     if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
-                        impl->updateData(variableEntry.second, variable->dataSeries(), variable->range());
+                        impl->updateData(variableEntry.second, variable, variable->range());
                     }
                 }
             }
             {
                 auto it = impl->m_VariableToPlotMultiMap.find(variable);
                 if (it != impl->m_VariableToPlotMultiMap.end()) {
-                    impl->updateData(it->second, variable->dataSeries(), range);
+                    impl->updateData(it->second, variable, range);
                 }
             }

gui/src/Visualization/VisualizationSelectionZoneItem.cpp +3 0

                             break;
                     }
+                    emit rangeEdited(range());
                     for (auto associatedZone : impl->m_AssociatedEditedZones) {
                         associatedZone->parentPlot()->replot();
+                        emit associatedZone->rangeEdited(associatedZone->range());
                     }
                 }
                 else {

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

             #include "Visualization/MacScrollBarStyle.h"
+            #include "DataSource/DataSourceController.h"
             #include "Variable/VariableController.h"
             #include "Common/MimeTypesDef.h"
                 void dropZone(int index, VisualizationTabWidget *tabWidget);
                 void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
                                    VisualizationTabWidget *tabWidget);
+                void dropProducts(const QVariantList &productsMetaData, int index,
+                                  VisualizationTabWidget *tabWidget);
             };
             VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *parent)
                                                    VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_VARIABLE_LIST,
                                                    VisualizationDragDropContainer::DropBehavior::Inserted);
+                ui->dragDropContainer->setMimeType(MIME_TYPE_PRODUCT_LIST,
+                                                   VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropGuiController().checkMimeDataForVisualization(mimeData,
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     impl->dropVariables(variables, index, this);
                 }
+                else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
+                    auto productsData = sqpApp->dataSourceController().productsDataForMimeData(
+                        mimeData->data(MIME_TYPE_PRODUCT_LIST));
+                    impl->dropProducts(productsData, index, this);
+                }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropMimeData, unknown MIME data received.");
                 tabWidget->createZone(variables, index);
             }
+            void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropProducts(
+                const QVariantList &productsMetaData, int index, VisualizationTabWidget *tabWidget)
+            {
+                // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
+                // compatible variable here
+                if (productsMetaData.count() != 1) {
+                    qCWarning(LOG_VisualizationZoneWidget())
+                        << tr("VisualizationTabWidget::dropProducts, dropping multiple products, operation "
+                              "aborted.");
+                    return;
+                }
+                auto context = new QObject{tabWidget};
+                connect(&sqpApp->variableController(), &VariableController::variableAdded, context,
+                        [this, index, tabWidget, context](auto variable) {
+                            tabWidget->createZone({variable}, index);
+                            delete context; // removes the connection
+                        },
+                        Qt::QueuedConnection);
+                auto productData = productsMetaData.first().toHash();
+                QMetaObject::invokeMethod(&sqpApp->dataSourceController(), "requestVariable",
+                                          Qt::QueuedConnection, Q_ARG(QVariantHash, productData));
+            }

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

@@ -10,6 +10,7
10	#include "Common/VisualizationDef.h"	10	#include "Common/VisualizationDef.h"
11		11
12	#include <Data/SqpRange.h>	12	#include <Data/SqpRange.h>
		13	#include <DataSource/DataSourceController.h>
13	#include <Time/TimeController.h>	14	#include <Time/TimeController.h>
14	#include <Variable/Variable.h>	15	#include <Variable/Variable.h>
15	#include <Variable/VariableController.h>	16	#include <Variable/VariableController.h>
@@ -78,6 +79,8 struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
78	void dropGraph(int index, VisualizationZoneWidget *zoneWidget);	79	void dropGraph(int index, VisualizationZoneWidget *zoneWidget);
79	void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,	80	void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
80	VisualizationZoneWidget *zoneWidget);	81	VisualizationZoneWidget *zoneWidget);
		82	void dropProducts(const QVariantList &productsData, int index,
		83	VisualizationZoneWidget *zoneWidget);
81	};	84	};
82		85
83	VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)	86	VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
@@ -94,6 +97,8 VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *p
94	VisualizationDragDropContainer::DropBehavior::Inserted);	97	VisualizationDragDropContainer::DropBehavior::Inserted);
95	ui->dragDropContainer->setMimeType(	98	ui->dragDropContainer->setMimeType(
96	MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);	99	MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
		100	ui->dragDropContainer->setMimeType(
		101	MIME_TYPE_PRODUCT_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
97	ui->dragDropContainer->setMimeType(MIME_TYPE_TIME_RANGE,	102	ui->dragDropContainer->setMimeType(MIME_TYPE_TIME_RANGE,
98	VisualizationDragDropContainer::DropBehavior::Merged);	103	VisualizationDragDropContainer::DropBehavior::Merged);
99	ui->dragDropContainer->setMimeType(MIME_TYPE_ZONE,	104	ui->dragDropContainer->setMimeType(MIME_TYPE_ZONE,
@@ -477,6 +482,11 void VisualizationZoneWidget::dropMimeData(int index, const QMimeData *mimeData)
477	mimeData->data(MIME_TYPE_VARIABLE_LIST));	482	mimeData->data(MIME_TYPE_VARIABLE_LIST));
478	impl->dropVariables(variables, index, this);	483	impl->dropVariables(variables, index, this);
479	}	484	}
		485	else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
		486	auto products = sqpApp->dataSourceController().productsDataForMimeData(
		487	mimeData->data(MIME_TYPE_PRODUCT_LIST));
		488	impl->dropProducts(products, index, this);
		489	}
480	else {	490	else {
481	qCWarning(LOG_VisualizationZoneWidget())	491	qCWarning(LOG_VisualizationZoneWidget())
482	<< tr("VisualizationZoneWidget::dropMimeData, unknown MIME data received.");	492	<< tr("VisualizationZoneWidget::dropMimeData, unknown MIME data received.");
@@ -502,6 +512,22 void VisualizationZoneWidget::dropMimeDataOnGraph(VisualizationDragWidget *dragW
502	graphWidget->addVariable(var, graphWidget->graphRange());	512	graphWidget->addVariable(var, graphWidget->graphRange());
503	}	513	}
504	}	514	}
		515	else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
		516	auto products = sqpApp->dataSourceController().productsDataForMimeData(
		517	mimeData->data(MIME_TYPE_PRODUCT_LIST));
		518
		519	auto context = new QObject{this};
		520	connect(&sqpApp->variableController(), &VariableController::variableAdded, context,
		521	[this, graphWidget, context](auto variable) {
		522	graphWidget->addVariable(variable, graphWidget->graphRange());
		523	delete context; // removes the connection
		524	},
		525	Qt::QueuedConnection);
		526
		527	auto productData = products.first().toHash();
		528	QMetaObject::invokeMethod(&sqpApp->dataSourceController(), "requestVariable",
		529	Qt::QueuedConnection, Q_ARG(QVariantHash, productData));
		530	}
505	else if (mimeData->hasFormat(MIME_TYPE_TIME_RANGE)) {	531	else if (mimeData->hasFormat(MIME_TYPE_TIME_RANGE)) {
506	auto range = TimeController::timeRangeForMimeData(mimeData->data(MIME_TYPE_TIME_RANGE));	532	auto range = TimeController::timeRangeForMimeData(mimeData->data(MIME_TYPE_TIME_RANGE));
507	graphWidget->setGraphRange(range);	533	graphWidget->setGraphRange(range);
@@ -599,3 +625,28 void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropVariables(
599		625
600	zoneWidget->createGraph(variables, index);	626	zoneWidget->createGraph(variables, index);
601	}	627	}
		628
		629	void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropProducts(
		630	const QVariantList &productsData, int index, VisualizationZoneWidget *zoneWidget)
		631	{
		632	// Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
		633	// compatible variable here
		634	if (productsData.count() != 1) {
		635	qCWarning(LOG_VisualizationZoneWidget())
		636	<< tr("VisualizationTabWidget::dropProducts, dropping multiple products, operation "
		637	"aborted.");
		638	return;
		639	}
		640
		641	auto context = new QObject{zoneWidget};
		642	connect(&sqpApp->variableController(), &VariableController::variableAdded, context,
		643	[this, index, zoneWidget, context](auto variable) {
		644	zoneWidget->createGraph(variable, index);
		645	delete context; // removes the connection
		646	},
		647	Qt::QueuedConnection);
		648
		649	auto productData = productsData.first().toHash();
		650	QMetaObject::invokeMethod(&sqpApp->dataSourceController(), "requestVariable",
		651	Qt::QueuedConnection, Q_ARG(QVariantHash, productData));
		652	}

gui/ui/Catalogue/CatalogueEventsWidget.ui 0 -3

                  </item>
                  <item>
                   <widget class="QToolButton" name="btnChart">
-                   <property name="enabled">
-                    <bool>false</bool>
-                   </property>
                    <property name="text">
                     <string>G</string>
                    </property>

plugins/amda/include/AmdaResultParser.h +3 -3

             #include "AmdaGlobal.h"
+            #include <Data/DataSeriesType.h>
             #include <QLoggingCategory>
             #include <memory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaResultParser)
             struct SCIQLOP_AMDA_EXPORT AmdaResultParser {
-                enum class ValueType { SCALAR, SPECTROGRAM, VECTOR, UNKNOWN };
                 static std::shared_ptr<IDataSeries> readTxt(const QString &filePath,
-                                                            ValueType valueType) noexcept;
+                                                            DataSeriesType valueType) noexcept;
             };
             #endif // SCIQLOP_AMDARESULTPARSER_H

plugins/amda/src/AmdaProvider.cpp +2 -16

@@ -39,21 +39,6 QString dateFormat(double sqpRange) noexcept
39	return dateTime.toString(AMDA_TIME_FORMAT);	39	return dateTime.toString(AMDA_TIME_FORMAT);
40	}	40	}
41		41
42	AmdaResultParser::ValueType valueType(const QString &valueType)
43	{
44	if (valueType == QStringLiteral("scalar")) {
45	return AmdaResultParser::ValueType::SCALAR;
46	}
47	else if (valueType == QStringLiteral("spectrogram")) {
48	return AmdaResultParser::ValueType::SPECTROGRAM;
49	}
50	else if (valueType == QStringLiteral("vector")) {
51	return AmdaResultParser::ValueType::VECTOR;
52	}
53	else {
54	return AmdaResultParser::ValueType::UNKNOWN;
55	}
56	}
57		42
58	} // namespace	43	} // namespace
59		44
@@ -171,7 +156,8 void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVa
171		156
172	// Retrieves the data type that determines whether the expected format for the result file is	157	// Retrieves the data type that determines whether the expected format for the result file is
173	// scalar, vector...	158	// scalar, vector...
174	auto productValueType = valueType(data.value(AMDA_DATA_TYPE_KEY).toString());	159	auto productValueType
		160	= DataSeriesTypeUtils::fromString(data.value(AMDA_DATA_TYPE_KEY).toString());
175		161
176	// /////////// //	162	// /////////// //
177	// Creates URL //	163	// Creates URL //

plugins/amda/src/AmdaResultParser.cpp +8 -8

              * @param valueType the type of values expected in the AMDA file (scalars, vectors, spectrograms...)
              * @return the helper created
              */
-            std::unique_ptr<IAmdaResultParserHelper> createHelper(AmdaResultParser::ValueType valueType)
+            std::unique_ptr<IAmdaResultParserHelper> createHelper(DataSeriesType valueType)
             {
                 switch (valueType) {
-                    case AmdaResultParser::ValueType::SCALAR:
+                    case DataSeriesType::SCALAR:
                         return std::make_unique<ScalarParserHelper>();
-                    case AmdaResultParser::ValueType::SPECTROGRAM:
+                    case DataSeriesType::SPECTROGRAM:
                         return std::make_unique<SpectrogramParserHelper>();
-                    case AmdaResultParser::ValueType::VECTOR:
+                    case DataSeriesType::VECTOR:
                         return std::make_unique<VectorParserHelper>();
-                    case AmdaResultParser::ValueType::UNKNOWN:
+                    case DataSeriesType::UNKNOWN:
                         // Invalid case
                         break;
                 }
             } // namespace
             std::shared_ptr<IDataSeries> AmdaResultParser::readTxt(const QString &filePath,
-                                                                   ValueType valueType) noexcept
+                                                                   DataSeriesType type) noexcept
             {
-                if (valueType == ValueType::UNKNOWN) {
+                if (type == DataSeriesType::UNKNOWN) {
                     qCCritical(LOG_AmdaResultParser())
                         << QObject::tr("Can't retrieve AMDA data: the type of values to be read is unknown");
                     return nullptr;
                     return nullptr;
                 }
-                auto helper = createHelper(valueType);
+                auto helper = createHelper(type);
                 Q_ASSERT(helper != nullptr);
                 // Reads header file to retrieve properties

plugins/amda/tests/TestAmdaAcquisition.cpp +1 -1

                 // Retrieves data file
                 QFETCH(QString, dataFilename);
                 auto filePath = QFileInfo{TESTS_RESOURCES_PATH, dataFilename}.absoluteFilePath();
-                auto results = AmdaResultParser::readTxt(filePath, AmdaResultParser::ValueType::SCALAR);
+                auto results = AmdaResultParser::readTxt(filePath, DataSeriesType::SCALAR);
                 /// Lambda used to validate a variable at each step
                 auto validateVariable = [results](std::shared_ptr<Variable> variable, const SqpRange &range) {

plugins/amda/tests/TestAmdaResultParser.cpp +4 -4

                 }
                 template <typename T>
-                void testRead(AmdaResultParser::ValueType valueType)
+                void testRead(DataSeriesType valueType)
                 {
                     QFETCH(QString, inputFileName);
                     QFETCH(ExpectedResults<T>, expectedResults);
             void TestAmdaResultParser::testReadScalarTxt()
             {
-                testRead<ScalarSeries>(AmdaResultParser::ValueType::SCALAR);
+                testRead<ScalarSeries>(DataSeriesType::SCALAR);
             }
             void TestAmdaResultParser::testReadSpectrogramTxt_data()
             void TestAmdaResultParser::testReadSpectrogramTxt()
             {
-                testRead<SpectrogramSeries>(AmdaResultParser::ValueType::SPECTROGRAM);
+                testRead<SpectrogramSeries>(DataSeriesType::SPECTROGRAM);
             }
             void TestAmdaResultParser::testReadVectorTxt_data()
             void TestAmdaResultParser::testReadVectorTxt()
             {
-                testRead<VectorSeries>(AmdaResultParser::ValueType::VECTOR);
+                testRead<VectorSeries>(DataSeriesType::VECTOR);
             }
             QTEST_MAIN(TestAmdaResultParser)

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