HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r547:9a7b9cf5359e

Merge pull request from SCIQLOP-Initialisation develop...

leroux -

r547:9a7b9cf5359e

parent child

Context file:

r547:9a7b9cf5359e

Expand all files

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

@@ -0,0 +1,25
	1	#ifndef SCIQLOP_ACQUISITIONDATAPACKET_H
	2	#define SCIQLOP_ACQUISITIONDATAPACKET_H
	3
	4	#include <QObject>
	5
	6	#include <Common/DateUtils.h>
	7	#include <Common/MetaTypes.h>
	8	#include <Data/IDataSeries.h>
	9	#include <Data/SqpRange.h>
	10
	11	#include <memory>
	12
	13	/**
	14	* @brief The AcquisitionDataPacket struct holds the information of an acquisition request result
	15	* part.
	16	*/
	17	struct AcquisitionDataPacket {
	18	std::shared_ptr<IDataSeries> m_DateSeries;
	19	SqpRange m_Range;
	20	};
	21
	22	SCIQLOP_REGISTER_META_TYPE(ACQUISITIONDATAPACKET_REGISTRY, AcquisitionDataPacket)
	23	SCIQLOP_REGISTER_META_TYPE(ACQUISITIONDATAPACKETVECTOR_REGISTRY, QVector<AcquisitionDataPacket>)
	24
	25	#endif // SCIQLOP_ACQUISITIONREQUEST_H

core/include/Data/AcquisitionRequest.h created 644 +38 0

@@ -0,0 +1,38
	1	#ifndef SCIQLOP_ACQUISITIONREQUEST_H
	2	#define SCIQLOP_ACQUISITIONREQUEST_H
	3
	4	#include <QObject>
	5
	6	#include <QUuid>
	7
	8	#include <Common/DateUtils.h>
	9	#include <Common/MetaTypes.h>
	10	#include <Data/DataProviderParameters.h>
	11	#include <Data/IDataProvider.h>
	12	#include <Data/SqpRange.h>
	13
	14	#include <memory>
	15
	16	/**
	17	* @brief The AcquisitionRequest struct holds the information of an acquisition request
	18	*/
	19	struct AcquisitionRequest {
	20	AcquisitionRequest()
	21	{
	22
	23	m_AcqIdentifier = QUuid::createUuid();
	24	m_Size = 0;
	25	}
	26
	27	QUuid m_AcqIdentifier;
	28	QUuid m_vIdentifier;
	29	DataProviderParameters m_DataProviderParameters;
	30	SqpRange m_RangeRequested;
	31	SqpRange m_CacheRangeRequested;
	32	int m_Size;
	33	std::shared_ptr<IDataProvider> m_Provider;
	34	};
	35
	36	SCIQLOP_REGISTER_META_TYPE(ACQUISITIONREQUEST_REGISTRY, AcquisitionRequest)
	37
	38	#endif // SCIQLOP_ACQUISITIONREQUEST_H

core/include/Variable/VariableAcquisitionWorker.h created 644 +61 0

@@ -0,0 +1,61
	1	#ifndef SCIQLOP_VARIABLEACQUISITIONWORKER_H
	2	#define SCIQLOP_VARIABLEACQUISITIONWORKER_H
	3
	4	#include "CoreGlobal.h"
	5
	6	#include <Data/DataProviderParameters.h>
	7	#include <QLoggingCategory>
	8	#include <QObject>
	9	#include <QUuid>
	10
	11	#include <Data/AcquisitionDataPacket.h>
	12	#include <Data/IDataSeries.h>
	13	#include <Data/SqpRange.h>
	14
	15	#include <QLoggingCategory>
	16
	17	#include <Common/spimpl.h>
	18
	19	Q_DECLARE_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker)
	20
	21	class Variable;
	22	class IDataProvider;
	23
	24	/// This class aims to handle all acquisition request
	25	class SCIQLOP_CORE_EXPORT VariableAcquisitionWorker : public QObject {
	26	Q_OBJECT
	27	public:
	28	explicit VariableAcquisitionWorker(QObject *parent = 0);
	29	virtual ~VariableAcquisitionWorker();
	30
	31	void pushVariableRequest(QUuid vIdentifier, SqpRange rangeRequested,
	32	SqpRange cacheRangeRequested, DataProviderParameters parameters,
	33	std::shared_ptr<IDataProvider> provider);
	34
	35	void abortProgressRequested(QUuid vIdentifier);
	36
	37	void initialize();
	38	void finalize();
	39	signals:
	40	void dataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
	41	const SqpRange &cacheRangeRequested,
	42	QVector<AcquisitionDataPacket> dataAcquired);
	43
	44	void variableRequestInProgress(QUuid vIdentifier, double progress);
	45
	46	public slots:
	47	void onVariableDataAcquired(QUuid acqIdentifier, std::shared_ptr<IDataSeries> dataSeries,
	48	SqpRange dataRangeAcquired);
	49	void onVariableRetrieveDataInProgress(QUuid acqIdentifier, double progress);
	50
	51	private slots:
	52	void onExecuteRequest(QUuid acqIdentifier);
	53
	54	private:
	55	void waitForFinish();
	56
	57	class VariableAcquisitionWorkerPrivate;
	58	spimpl::unique_impl_ptr<VariableAcquisitionWorkerPrivate> impl;
	59	};
	60
	61	#endif // SCIQLOP_VARIABLEACQUISITIONWORKER_H

core/include/Variable/VariableCacheStrategy.h created 644 +40 0

@@ -0,0 +1,40
	1	#ifndef SCIQLOP_VARIABLECACHESTRATEGY_H
	2	#define SCIQLOP_VARIABLECACHESTRATEGY_H
	3
	4	#include "CoreGlobal.h"
	5
	6	#include <QLoggingCategory>
	7	#include <QObject>
	8
	9	#include <Data/SqpRange.h>
	10
	11	#include <QLoggingCategory>
	12
	13	#include <Common/spimpl.h>
	14	#include <utility>
	15
	16
	17	Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheStrategy)
	18
	19	class Variable;
	20
	21	/**
	22	* Possible types of zoom operation
	23	*/
	24	enum class CacheStrategy { FixedTolerance, TwoThreashold };
	25
	26	/// This class aims to hande the cache strategy.
	27	class SCIQLOP_CORE_EXPORT VariableCacheStrategy : public QObject {
	28	Q_OBJECT
	29	public:
	30	explicit VariableCacheStrategy(QObject *parent = 0);
	31
	32	std::pair<SqpRange, SqpRange> computeCacheRange(const SqpRange &vRange,
	33	const SqpRange &rangeRequested);
	34
	35	private:
	36	class VariableCacheStrategyPrivate;
	37	spimpl::unique_impl_ptr<VariableCacheStrategyPrivate> impl;
	38	};
	39
	40	#endif // SCIQLOP_VARIABLECACHESTRATEGY_H

core/include/Variable/VariableSynchronizationGroup.h created 644 +38 0

@@ -0,0 +1,38
	1	#ifndef SCIQLOP_VARIABLESYNCHRONIZATIONGROUP_H
	2	#define SCIQLOP_VARIABLESYNCHRONIZATIONGROUP_H
	3
	4	#include "CoreGlobal.h"
	5
	6	#include <QLoggingCategory>
	7	#include <QObject>
	8	#include <QUuid>
	9
	10	#include <Data/SqpRange.h>
	11
	12	#include <set>
	13
	14	#include <QLoggingCategory>
	15
	16	#include <Common/spimpl.h>
	17
	18	Q_DECLARE_LOGGING_CATEGORY(LOG_VariableSynchronizationGroup)
	19
	20	class Variable;
	21
	22	/// This class aims to hande the cache strategy.
	23	class SCIQLOP_CORE_EXPORT VariableSynchronizationGroup : public QObject {
	24	Q_OBJECT
	25	public:
	26	explicit VariableSynchronizationGroup(QObject *parent = 0);
	27
	28	void addVariableId(QUuid vIdentifier);
	29	void removeVariableId(QUuid vIdentifier);
	30
	31	const std::set<QUuid> &getIds() const noexcept;
	32
	33	private:
	34	class VariableSynchronizationGroupPrivate;
	35	spimpl::unique_impl_ptr<VariableSynchronizationGroupPrivate> impl;
	36	};
	37
	38	#endif // SCIQLOP_VARIABLESYNCHRONIZATIONGROUP_H

core/src/Variable/VariableAcquisitionWorker.cpp created 644 +225 0

@@ -0,0 +1,225
	1	#include "Variable/VariableAcquisitionWorker.h"
	2
	3	#include "Variable/Variable.h"
	4
	5	#include <Data/AcquisitionRequest.h>
	6	#include <Data/SqpRange.h>
	7
	8	#include <unordered_map>
	9	#include <utility>
	10
	11	#include <QMutex>
	12	#include <QReadWriteLock>
	13	#include <QThread>
	14
	15	Q_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker, "VariableAcquisitionWorker")
	16
	17	struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {
	18
	19	explicit VariableAcquisitionWorkerPrivate() : m_Lock{QReadWriteLock::Recursive} {}
	20
	21	void lockRead() { m_Lock.lockForRead(); }
	22	void lockWrite() { m_Lock.lockForWrite(); }
	23	void unlock() { m_Lock.unlock(); }
	24
	25	void removeVariableRequest(QUuid vIdentifier);
	26
	27	QMutex m_WorkingMutex;
	28	QReadWriteLock m_Lock;
	29
	30	std::map<QUuid, QVector<AcquisitionDataPacket> > m_AcqIdentifierToAcqDataPacketVectorMap;
	31	std::map<QUuid, AcquisitionRequest> m_AcqIdentifierToAcqRequestMap;
	32	std::map<QUuid, std::pair<QUuid, QUuid> > m_VIdentifierToCurrrentAcqIdNextIdPairMap;
	33	};
	34
	35
	36	VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)
	37	: QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>()}
	38	{
	39	}
	40
	41	VariableAcquisitionWorker::~VariableAcquisitionWorker()
	42	{
	43	qCInfo(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker destruction")
	44	<< QThread::currentThread();
	45	this->waitForFinish();
	46	}
	47
	48
	49	void VariableAcquisitionWorker::pushVariableRequest(QUuid vIdentifier, SqpRange rangeRequested,
	50	SqpRange cacheRangeRequested,
	51	DataProviderParameters parameters,
	52	std::shared_ptr<IDataProvider> provider)
	53	{
	54	qCInfo(LOG_VariableAcquisitionWorker())
	55	<< tr("TORM VariableAcquisitionWorker::pushVariableRequest ") << cacheRangeRequested;
	56
	57	// Request creation
	58	auto acqRequest = AcquisitionRequest{};
	59	acqRequest.m_vIdentifier = vIdentifier;
	60	acqRequest.m_DataProviderParameters = parameters;
	61	acqRequest.m_RangeRequested = rangeRequested;
	62	acqRequest.m_CacheRangeRequested = cacheRangeRequested;
	63	acqRequest.m_Size = parameters.m_Times.size();
	64	acqRequest.m_Provider = provider;
	65
	66	// Register request
	67	impl->lockWrite();
	68	impl->m_AcqIdentifierToAcqRequestMap.insert(
	69	std::make_pair(acqRequest.m_AcqIdentifier, acqRequest));
	70
	71	auto it = impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
	72	if (it != impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
	73	// A current request already exists, we can replace the next one
	74	it->second.second = acqRequest.m_AcqIdentifier;
	75	impl->unlock();
	76	}
	77	else {
	78	// First request for the variable, it must be stored and executed
	79	impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.insert(
	80	std::make_pair(vIdentifier, std::make_pair(acqRequest.m_AcqIdentifier, QUuid())));
	81	impl->unlock();
	82
	83	QMetaObject::invokeMethod(this, "onExecuteRequest", Qt::QueuedConnection,
	84	Q_ARG(QUuid, acqRequest.m_AcqIdentifier));
	85	}
	86	}
	87
	88	void VariableAcquisitionWorker::abortProgressRequested(QUuid vIdentifier)
	89	{
	90	// TODO
	91	}
	92
	93	void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,
	94	double progress)
	95	{
	96	// TODO
	97	}
	98
	99	void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
	100	std::shared_ptr<IDataSeries> dataSeries,
	101	SqpRange dataRangeAcquired)
	102	{
	103	qCDebug(LOG_VariableAcquisitionWorker()) << tr("onVariableDataAcquired on range ")
	104	<< acqIdentifier << dataRangeAcquired;
	105	impl->lockWrite();
	106	auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
	107	if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
	108	// Store the result
	109	auto dataPacket = AcquisitionDataPacket{};
	110	dataPacket.m_Range = dataRangeAcquired;
	111	dataPacket.m_DateSeries = dataSeries;
	112
	113	auto aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);
	114	if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {
	115	// A current request result already exists, we can update it
	116	aIdToADPVit->second.push_back(dataPacket);
	117	}
	118	else {
	119	// First request result for the variable, it must be stored
	120	impl->m_AcqIdentifierToAcqDataPacketVectorMap.insert(
	121	std::make_pair(acqIdentifier, QVector<AcquisitionDataPacket>() << dataPacket));
	122	}
	123
	124
	125	// Decrement the counter of the request
	126	auto &acqRequest = aIdToARit->second;
	127	acqRequest.m_Size = acqRequest.m_Size - 1;
	128
	129	// if the counter is 0, we can return data then run the next request if it exists and
	130	// removed the finished request
	131	if (acqRequest.m_Size == 0) {
	132	// Return the data
	133	aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);
	134	if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {
	135	emit dataProvided(acqRequest.m_vIdentifier, acqRequest.m_RangeRequested,
	136	acqRequest.m_CacheRangeRequested, aIdToADPVit->second);
	137	}
	138
	139	// Execute the next one
	140	auto it
	141	= impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(acqRequest.m_vIdentifier);
	142
	143	if (it != impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
	144	if (it->second.second.isNull()) {
	145	// There is no next request, we can remove the varibale request
	146	impl->removeVariableRequest(acqRequest.m_vIdentifier);
	147	}
	148	else {
	149	auto acqIdentifierToRemove = it->second.first;
	150	// Move the next request to the current request
	151	it->second.first = it->second.second;
	152	it->second.second = QUuid();
	153	// Remove AcquisitionRequest and results;
	154	impl->m_AcqIdentifierToAcqRequestMap.erase(acqIdentifierToRemove);
	155	impl->m_AcqIdentifierToAcqDataPacketVectorMap.erase(acqIdentifierToRemove);
	156	// Execute the current request
	157	QMetaObject::invokeMethod(this, "onExecuteRequest", Qt::QueuedConnection,
	158	Q_ARG(QUuid, it->second.first));
	159	}
	160	}
	161	else {
	162	qCCritical(LOG_VariableAcquisitionWorker())
	163	<< tr("Impossible to execute the acquisition on an unfound variable ");
	164	}
	165	}
	166	}
	167	else {
	168	qCCritical(LOG_VariableAcquisitionWorker())
	169	<< tr("Impossible to retrieve AcquisitionRequest for the incoming data");
	170	}
	171	impl->unlock();
	172	}
	173
	174	void VariableAcquisitionWorker::onExecuteRequest(QUuid acqIdentifier)
	175	{
	176	qCInfo(LOG_VariableAcquisitionWorker()) << tr("onExecuteRequest") << QThread::currentThread();
	177	impl->lockRead();
	178	auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
	179	if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
	180	auto request = it->second;
	181	impl->unlock();
	182	request.m_Provider->requestDataLoading(acqIdentifier, request.m_DataProviderParameters);
	183	}
	184	else {
	185	impl->unlock();
	186	// TODO log no acqIdentifier recognized
	187	}
	188	}
	189
	190	void VariableAcquisitionWorker::initialize()
	191	{
	192	qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init")
	193	<< QThread::currentThread();
	194	impl->m_WorkingMutex.lock();
	195	qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init END");
	196	}
	197
	198	void VariableAcquisitionWorker::finalize()
	199	{
	200	impl->m_WorkingMutex.unlock();
	201	}
	202
	203	void VariableAcquisitionWorker::waitForFinish()
	204	{
	205	QMutexLocker locker{&impl->m_WorkingMutex};
	206	}
	207
	208	void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::removeVariableRequest(
	209	QUuid vIdentifier)
	210	{
	211	lockWrite();
	212	auto it = m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
	213
	214	if (it != m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
	215	// A current request already exists, we can replace the next one
	216
	217	m_AcqIdentifierToAcqRequestMap.erase(it->second.first);
	218	m_AcqIdentifierToAcqDataPacketVectorMap.erase(it->second.first);
	219
	220	m_AcqIdentifierToAcqRequestMap.erase(it->second.second);
	221	m_AcqIdentifierToAcqDataPacketVectorMap.erase(it->second.second);
	222	}
	223	m_VIdentifierToCurrrentAcqIdNextIdPairMap.erase(vIdentifier);
	224	unlock();
	225	}

core/src/Variable/VariableCacheStrategy.cpp created 644 +52 0

@@ -0,0 +1,52
	1	#include "Variable/VariableCacheStrategy.h"
	2
	3	#include "Settings/SqpSettingsDefs.h"
	4
	5	#include "Variable/Variable.h"
	6	#include "Variable/VariableController.h"
	7
	8	Q_LOGGING_CATEGORY(LOG_VariableCacheStrategy, "VariableCacheStrategy")
	9
	10	struct VariableCacheStrategy::VariableCacheStrategyPrivate {
	11	VariableCacheStrategyPrivate() : m_CacheStrategy{CacheStrategy::FixedTolerance} {}
	12
	13	CacheStrategy m_CacheStrategy;
	14	};
	15
	16
	17	VariableCacheStrategy::VariableCacheStrategy(QObject *parent)
	18	: QObject{parent}, impl{spimpl::make_unique_impl<VariableCacheStrategyPrivate>()}
	19	{
	20	}
	21
	22	std::pair<SqpRange, SqpRange>
	23	VariableCacheStrategy::computeCacheRange(const SqpRange &vRange, const SqpRange &rangeRequested)
	24	{
	25
	26	auto varRanges = std::pair<SqpRange, SqpRange>{};
	27
	28	auto toleranceFactor = SqpSettings::toleranceValue(GENERAL_TOLERANCE_AT_UPDATE_KEY,
	29	GENERAL_TOLERANCE_AT_UPDATE_DEFAULT_VALUE);
	30	auto tolerance = toleranceFactor * (rangeRequested.m_TEnd - rangeRequested.m_TStart);
	31
	32	switch (impl->m_CacheStrategy) {
	33	case CacheStrategy::FixedTolerance: {
	34	varRanges.first = rangeRequested;
	35	varRanges.second
	36	= SqpRange{rangeRequested.m_TStart - tolerance, rangeRequested.m_TEnd + tolerance};
	37	break;
	38	}
	39
	40	case CacheStrategy::TwoThreashold: {
	41	// TODO Implement
	42	break;
	43	}
	44	default:
	45	qCCritical(LOG_VariableCacheStrategy())
	46	<< tr("Impossible to use compute the cache range with an unknow cache strategy");
	47	// No action
	48	break;
	49	}
	50
	51	return varRanges;
	52	}

core/src/Variable/VariableSynchronizationGroup.cpp created 644 +32 0

@@ -0,0 +1,32
	1	#include "Variable/VariableSynchronizationGroup.h"
	2
	3	#include "Variable/Variable.h"
	4
	5
	6	Q_LOGGING_CATEGORY(LOG_VariableSynchronizationGroup, "VariableSynchronizationGroup")
	7
	8	struct VariableSynchronizationGroup::VariableSynchronizationGroupPrivate {
	9
	10	std::set<QUuid> m_VariableIdSet;
	11	};
	12
	13
	14	VariableSynchronizationGroup::VariableSynchronizationGroup(QObject *parent)
	15	: QObject{parent}, impl{spimpl::make_unique_impl<VariableSynchronizationGroupPrivate>()}
	16	{
	17	}
	18
	19	void VariableSynchronizationGroup::addVariableId(QUuid vIdentifier)
	20	{
	21	impl->m_VariableIdSet.insert(vIdentifier);
	22	}
	23
	24	void VariableSynchronizationGroup::removeVariableId(QUuid vIdentifier)
	25	{
	26	impl->m_VariableIdSet.erase(vIdentifier);
	27	}
	28
	29	const std::set<QUuid> &VariableSynchronizationGroup::getIds() const noexcept
	30	{
	31	return impl->m_VariableIdSet;
	32	}

core/include/Data/DataSeries.h +10 0

             #ifndef SCIQLOP_DATASERIES_H
             #define SCIQLOP_DATASERIES_H
             #include <Common/SortUtils.h>
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <QLoggingCategory>
             #include <QReadLocker>
             #include <QReadWriteLock>
             #include <memory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSeries)
             Q_LOGGING_CATEGORY(LOG_DataSeries, "DataSeries")
             /**
              * @brief The DataSeries class is the base (abstract) implementation of IDataSeries.
              *
              * It proposes to set a dimension for the values data.
              *
              * A DataSeries is always sorted on its x-axis data.
              *
              * @tparam Dim The dimension of the values data
              *
              */
             template <int Dim>
             class DataSeries : public IDataSeries {
             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() { return m_ValuesData; }
                 const std::shared_ptr<ArrayData<Dim> > valuesData() const { return m_ValuesData; }
                 /// @sa IDataSeries::valuesUnit()
                 Unit valuesUnit() const override { return m_ValuesUnit; }
+                SqpRange range() const override
+                {
+                    if (!m_XAxisData->cdata().isEmpty()) {
+                        return SqpRange{m_XAxisData->cdata().first(), m_XAxisData->cdata().last()};
+                    }
+                    return SqpRange{};
+                }
                 void clear()
                 {
                     m_XAxisData->clear();
                     m_ValuesData->clear();
                 }
                 /// Merges into the data series an other data series
                 /// @remarks the data series to merge with is cleared after the operation
                 void merge(IDataSeries *dataSeries) override
                 {
                     dataSeries->lockWrite();
                     lockWrite();
                     if (auto other = dynamic_cast<DataSeries<Dim> *>(dataSeries)) {
                         const auto &otherXAxisData = other->xAxisData()->cdata();
                         const auto &xAxisData = m_XAxisData->cdata();
                         // As data series are sorted, we can improve performances of merge, by call the sort
                         // method only if the two data series overlap.
                         if (!otherXAxisData.empty()) {
                             auto firstValue = otherXAxisData.front();
                             auto lastValue = otherXAxisData.back();
                             auto xAxisDataBegin = xAxisData.cbegin();
                             auto xAxisDataEnd = xAxisData.cend();
                             bool prepend;
                             bool sortNeeded;
                             if (std::lower_bound(xAxisDataBegin, xAxisDataEnd, firstValue) == xAxisDataEnd) {
                                 // Other data series if after data series
                                 prepend = false;
                                 sortNeeded = false;
                             }
                             else if (std::upper_bound(xAxisDataBegin, xAxisDataEnd, lastValue)
                                      == xAxisDataBegin) {
                                 // Other data series if before data series
                                 prepend = true;
                                 sortNeeded = false;
                             }
                             else {
                                 // The two data series overlap
                                 prepend = false;
                                 sortNeeded = true;
                             }
                             // Makes the merge
                             m_XAxisData->add(*other->xAxisData(), prepend);
                             m_ValuesData->add(*other->valuesData(), prepend);
                             if (sortNeeded) {
                                 sort();
                             }
                         }
                         // Clears the other data series
                         other->clear();
                     }
                     else {
                         qCWarning(LOG_DataSeries())
                             << QObject::tr("Detection of a type of IDataSeries we cannot merge with !");
                     }
                     unlock();
                     dataSeries->unlock();
                 }
                 virtual void lockRead() { m_Lock.lockForRead(); }
                 virtual void lockWrite() { m_Lock.lockForWrite(); }
                 virtual void unlock() { m_Lock.unlock(); }
             protected:
                 /// Protected ctor (DataSeries is abstract). The vectors must have the same size, otherwise a
                 /// DataSeries with no values will be created.
                 /// @remarks data series is automatically sorted on its x-axis data
                 explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, const Unit &xAxisUnit,
                                     std::shared_ptr<ArrayData<Dim> > valuesData, const Unit &valuesUnit)
                         : m_XAxisData{xAxisData},
                           m_XAxisUnit{xAxisUnit},
                           m_ValuesData{valuesData},
                           m_ValuesUnit{valuesUnit}
                 {
                     if (m_XAxisData->size() != m_ValuesData->size()) {
                         clear();
                     }
                     // Sorts data if it's not the case
                     const auto &xAxisCData = m_XAxisData->cdata();
                     if (!std::is_sorted(xAxisCData.cbegin(), xAxisCData.cend())) {
                         sort();
                     }
                 }
                 /// 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}
                 {
                     // Since a series is ordered from its construction and is always ordered, it is not
                     // necessary to call the sort method here ('other' is sorted)
                 }
                 /// 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:
                 /**
                  * Sorts data series on its x-axis data
                  */
                 void sort() noexcept
                 {
                     auto permutation = SortUtils::sortPermutation(*m_XAxisData, std::less<double>());
                     m_XAxisData = m_XAxisData->sort(permutation);
                     m_ValuesData = m_ValuesData->sort(permutation);
                 }
                 std::shared_ptr<ArrayData<1> > m_XAxisData;
                 Unit m_XAxisUnit;
                 std::shared_ptr<ArrayData<Dim> > m_ValuesData;
                 Unit m_ValuesUnit;
                 QReadWriteLock m_Lock;
             };
             #endif // SCIQLOP_DATASERIES_H

core/include/Data/IDataProvider.h +12 -10

             #ifndef SCIQLOP_IDATAPROVIDER_H
             #define SCIQLOP_IDATAPROVIDER_H
             #include "CoreGlobal.h"
             #include <memory>
             #include <QObject>
             #include <QUuid>
             #include <Common/MetaTypes.h>
             #include <Data/SqpRange.h>
             #include <functional>
             class DataProviderParameters;
             class IDataSeries;
             class QNetworkReply;
             class QNetworkRequest;
             /**
              * @brief The IDataProvider interface aims to declare a data provider.
              *
              * A data provider is an entity that generates data and returns it according to various parameters
              * (time interval, product to retrieve the data, etc.)
              *
              * @sa IDataSeries
              */
             class SCIQLOP_CORE_EXPORT IDataProvider : public QObject {
                 Q_OBJECT
             public:
                 virtual ~IDataProvider() noexcept = default;
                 /**
-                 * @brief requestDataLoading provide datas for the data identified by identifier and parameters
+                 * @brief requestDataLoading provide datas for the data identified by acqIdentifier and
+                 * parameters
                  */
-                virtual void requestDataLoading(QUuid identifier, const DataProviderParameters &parameters) = 0;
+                virtual void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters)
+                    = 0;
                 /**
-                 * @brief requestDataAborting stop data loading of the data identified by identifier
+                 * @brief requestDataAborting stop data loading of the data identified by acqIdentifier
                  */
-                virtual void requestDataAborting(QUuid identifier) = 0;
+                virtual void requestDataAborting(QUuid acqIdentifier) = 0;
             signals:
                 /**
                  * @brief dataProvided send dataSeries under dateTime and that corresponds of the data
-                 * identified by identifier
+                 * identified by acqIdentifier
                  */
-                void dataProvided(QUuid identifier, std::shared_ptr<IDataSeries> dateSerie,
+                void dataProvided(QUuid acqIdentifier, std::shared_ptr<IDataSeries> dateSeriesAcquired,
-                                  const SqpRange &dateTime);
+                                  const SqpRange &dataRangeAcquired);
                 /**
                     * @brief dataProvided send dataSeries under dateTime and that corresponds of the data
                     * identified by identifier
                     */
-                void dataProvidedProgress(QUuid identifier, double progress);
+                void dataProvidedProgress(QUuid acqIdentifier, double progress);
                 /**
-                 * @brief requestConstructed send a request for the data identified by identifier
+                 * @brief requestConstructed send a request for the data identified by acqIdentifier
                  * @callback is the methode call by the reply of the request when it is finished.
                  */
-                void requestConstructed(const QNetworkRequest &request, QUuid identifier,
+                void requestConstructed(const QNetworkRequest &request, QUuid acqIdentifier,
                                         std::function<void(QNetworkReply *, QUuid)> callback);
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_PTR_REGISTRY, std::shared_ptr<IDataProvider>)
             SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_FUNCTION_REGISTRY,
                                        std::function<void(QNetworkReply *, QUuid)>)
             #endif // SCIQLOP_IDATAPROVIDER_H

core/include/Data/IDataSeries.h +3 0

             #ifndef SCIQLOP_IDATASERIES_H
             #define SCIQLOP_IDATASERIES_H
             #include <Common/MetaTypes.h>
+            #include <Data/SqpRange.h>
             #include <memory>
             #include <QString>
             template <int Dim>
             class ArrayData;
             struct Unit {
                 explicit Unit(const QString &name = {}, bool timeUnit = false)
                         : m_Name{name}, m_TimeUnit{timeUnit}
                 {
                 }
                 inline bool operator==(const Unit &other) const
                 {
                     return std::tie(m_Name, m_TimeUnit) == std::tie(other.m_Name, other.m_TimeUnit);
                 }
                 inline bool operator!=(const Unit &other) const { return !(*this == other); }
                 QString m_Name;  ///< Unit name
                 bool m_TimeUnit; ///< The unit is a unit of time (UTC)
             };
             /**
              * @brief The IDataSeries aims to declare a data series.
              *
              * A data series is an entity that contains at least :
              * - one dataset representing the x-axis
              * - one dataset representing the values
              *
              * Each dataset is represented by an ArrayData, and is associated with a unit.
              *
              * An ArrayData can be unidimensional or two-dimensional, depending on the implementation of the
              * IDataSeries. The x-axis dataset is always unidimensional.
              *
              * @sa ArrayData
              */
             class IDataSeries {
             public:
                 virtual ~IDataSeries() noexcept = default;
                 /// 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::shared_ptr<IDataSeries> subData(const SqpRange &range) = 0;
                 virtual std::unique_ptr<IDataSeries> clone() const = 0;
+                virtual SqpRange range() const = 0;
                 virtual void lockRead() = 0;
                 virtual void lockWrite() = 0;
                 virtual void unlock() = 0;
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(IDATASERIES_PTR_REGISTRY, std::shared_ptr<IDataSeries>)
             #endif // SCIQLOP_IDATASERIES_H

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

             #ifndef SCIQLOP_SCALARSERIES_H
             #define SCIQLOP_SCALARSERIES_H
             #include "CoreGlobal.h"
             #include <Data/DataSeries.h>
             /**
              * @brief The ScalarSeries class is the implementation for a data series representing a scalar.
              */
             class SCIQLOP_CORE_EXPORT ScalarSeries : public DataSeries<1> {
             public:
                 /**
                  * Ctor with two vectors. The vectors must have the same size, otherwise a ScalarSeries with no
                  * values will be created.
                  * @param xAxisData x-axis data
                  * @param valuesData values data
                  */
                 explicit ScalarSeries(QVector<double> xAxisData, QVector<double> valuesData,
                                       const Unit &xAxisUnit, const Unit &valuesUnit);
-                std::unique_ptr<IDataSeries> clone() const;
+                std::unique_ptr<IDataSeries> clone() const override;
+                std::shared_ptr<IDataSeries> subData(const SqpRange &range) override;
             };
             #endif // SCIQLOP_SCALARSERIES_H

core/include/Settings/SqpSettingsDefs.h +4 0

             #ifndef SCIQLOP_SQPSETTINGSDEFS_H
             #define SCIQLOP_SQPSETTINGSDEFS_H
             #include "CoreGlobal.h"
             #include <QString>
             // //////////////// //
             // General settings //
             // //////////////// //
+            struct SCIQLOP_CORE_EXPORT SqpSettings {
+                static double toleranceValue(const QString &key, double defaultValue) noexcept;
+            };
             extern SCIQLOP_CORE_EXPORT const QString GENERAL_TOLERANCE_AT_INIT_KEY;
             extern SCIQLOP_CORE_EXPORT const double GENERAL_TOLERANCE_AT_INIT_DEFAULT_VALUE;
             extern SCIQLOP_CORE_EXPORT const QString GENERAL_TOLERANCE_AT_UPDATE_KEY;
             extern SCIQLOP_CORE_EXPORT const double GENERAL_TOLERANCE_AT_UPDATE_DEFAULT_VALUE;
             #endif // SCIQLOP_SQPSETTINGSDEFS_H

core/include/Variable/Variable.h +15 -7

             #ifndef SCIQLOP_VARIABLE_H
             #define SCIQLOP_VARIABLE_H
             #include "CoreGlobal.h"
             #include <Data/SqpRange.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/MetaTypes.h>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_Variable)
             class IDataSeries;
             class QString;
             /**
              * @brief The Variable class represents a variable in SciQlop.
              */
             class SCIQLOP_CORE_EXPORT Variable : public QObject {
                 Q_OBJECT
             public:
                 explicit Variable(const QString &name, const SqpRange &dateTime,
                                   const QVariantHash &metadata = {});
                 QString name() const noexcept;
-                SqpRange dateTime() const noexcept;
+                SqpRange range() const noexcept;
-                void setDateTime(const SqpRange &dateTime) noexcept;
+                void setRange(const SqpRange &range) noexcept;
+                SqpRange cacheRange() const noexcept;
+                void setCacheRange(const SqpRange &cacheRange) noexcept;
                 /// @return the data of the variable, nullptr if there is no data
-                IDataSeries *dataSeries() const noexcept;
+                std::shared_ptr<IDataSeries> dataSeries() const noexcept;
                 QVariantHash metadata() const noexcept;
-                bool contains(const SqpRange &dateTime) const noexcept;
+                bool contains(const SqpRange &range) const noexcept;
-                bool intersect(const SqpRange &dateTime) const noexcept;
+                bool intersect(const SqpRange &range) const noexcept;
-                bool isInside(const SqpRange &dateTime) const noexcept;
+                bool isInside(const SqpRange &range) const noexcept;
-            public slots:
+                bool cacheContains(const SqpRange &range) const noexcept;
+                bool cacheIntersect(const SqpRange &range) const noexcept;
+                bool cacheIsInside(const SqpRange &range) const noexcept;
+                QVector<SqpRange> provideNotInCacheRangeList(const SqpRange &range) const noexcept;
                 void setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
+                void mergeDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
             signals:
                 void updated();
             private:
                 class VariablePrivate;
                 spimpl::unique_impl_ptr<VariablePrivate> impl;
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(VARIABLE_PTR_REGISTRY, std::shared_ptr<Variable>)
+            SCIQLOP_REGISTER_META_TYPE(VARIABLE_PTR_VECTOR_REGISTRY, QVector<std::shared_ptr<Variable> >)
             #endif // SCIQLOP_VARIABLE_H

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

             #ifndef SCIQLOP_VARIABLECONTROLLER_H
             #define SCIQLOP_VARIABLECONTROLLER_H
             #include "CoreGlobal.h"
+            #include <Data/AcquisitionDataPacket.h>
             #include <Data/SqpRange.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
             class IDataProvider;
             class QItemSelectionModel;
             class TimeController;
             class Variable;
             class VariableModel;
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
+            /**
+             * Possible types of zoom operation
+             */
+            enum class AcquisitionZoomType { ZoomOut, ZoomIn, PanRight, PanLeft, Unknown };
             /**
              * @brief The VariableController class aims to handle the variables in SciQlop.
              */
             class SCIQLOP_CORE_EXPORT VariableController : public QObject {
                 Q_OBJECT
             public:
                 explicit VariableController(QObject *parent = 0);
                 virtual ~VariableController();
                 VariableModel *variableModel() noexcept;
                 QItemSelectionModel *variableSelectionModel() noexcept;
                 void setTimeController(TimeController *timeController) noexcept;
                 /**
                  * Deletes from the controller the variable passed in parameter.
                  *
                  * Delete a variable includes:
                  * - the deletion of the various references to the variable in SciQlop
                  * - the deletion of the model variable
                  * - the deletion of the provider associated with the variable
                  * - removing the cache associated with the variable
                  *
                  * @param variable the variable to delete from the controller.
                  */
                 void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
                 /**
                  * Deletes from the controller the variables passed in parameter.
                  * @param variables the variables to delete from the controller.
                  * @sa deleteVariable()
                  */
                 void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
                 /**
                  * @brief abort the variable retrieve data progression
                  */
                 void abortProgress(std::shared_ptr<Variable> variable);
+                static AcquisitionZoomType getZoomType(const SqpRange &range, const SqpRange &oldRange);
             signals:
                 /// Signal emitted when a variable is about to be deleted from the controller
                 void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
                 /// Signal emitted when a data acquisition is requested on a range for a variable
                 void rangeChanged(std::shared_ptr<Variable> variable, const SqpRange &range);
             public slots:
-                /// Request the data loading of the variable whithin dateTime
+                /// Request the data loading of the variable whithin range
-                void onRequestDataLoading(std::shared_ptr<Variable> variable, const SqpRange &dateTime);
+                void onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables, const SqpRange &range,
+                                          const SqpRange &oldRange, bool synchronise);
                 /**
                  * Creates a new variable and adds it to the model
                  * @param name the name of the new variable
                  * @param metadata the metadata of the new variable
                  * @param provider the data provider for the new variable
                  */
                 void createVariable(const QString &name, const QVariantHash &metadata,
                                     std::shared_ptr<IDataProvider> provider) noexcept;
                 /// Update the temporal parameters of every selected variable to dateTime
                 void onDateTimeOnSelection(const SqpRange &dateTime);
+                void onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
+                                    const SqpRange &cacheRangeRequested,
+                                    QVector<AcquisitionDataPacket> dataAcquired);
                 void onVariableRetrieveDataInProgress(QUuid identifier, double progress);
+                /// Cancel the current request for the variable
                 void onAbortProgressRequested(std::shared_ptr<Variable> variable);
+                /// synchronization group methods
+                void onAddSynchronizationGroupId(QUuid synchronizationGroupId);
+                void onRemoveSynchronizationGroupId(QUuid synchronizationGroupId);
+                void onAddSynchronized(std::shared_ptr<Variable> variable, QUuid synchronizationGroupId);
                 void initialize();
                 void finalize();
             private:
                 void waitForFinish();
                 class VariableControllerPrivate;
                 spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLECONTROLLER_H

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

@@ -1,13 +1,41
1	#include <Data/ScalarSeries.h>	1	#include <Data/ScalarSeries.h>
2		2
3	ScalarSeries::ScalarSeries(QVector<double> xAxisData, QVector<double> valuesData,	3	ScalarSeries::ScalarSeries(QVector<double> xAxisData, QVector<double> valuesData,
4	const Unit &xAxisUnit, const Unit &valuesUnit)	4	const Unit &xAxisUnit, const Unit &valuesUnit)
5	: DataSeries{std::make_shared<ArrayData<1> >(std::move(xAxisData)), xAxisUnit,	5	: DataSeries{std::make_shared<ArrayData<1> >(std::move(xAxisData)), xAxisUnit,
6	std::make_shared<ArrayData<1> >(std::move(valuesData)), valuesUnit}	6	std::make_shared<ArrayData<1> >(std::move(valuesData)), valuesUnit}
7	{	7	{
8	}	8	}
9		9
10	std::unique_ptr<IDataSeries> ScalarSeries::clone() const	10	std::unique_ptr<IDataSeries> ScalarSeries::clone() const
11	{	11	{
12	return std::make_unique<ScalarSeries>(*this);	12	return std::make_unique<ScalarSeries>(*this);
13	}	13	}
		14
		15	std::shared_ptr<IDataSeries> ScalarSeries::subData(const SqpRange &range)
		16	{
		17	auto subXAxisData = QVector<double>();
		18	auto subValuesData = QVector<double>();
		19	this->lockRead();
		20	{
		21	const auto &currentXData = this->xAxisData()->cdata();
		22	const auto &currentValuesData = this->valuesData()->cdata();
		23
		24	auto xDataBegin = currentXData.cbegin();
		25	auto xDataEnd = currentXData.cend();
		26
		27	auto lowerIt = std::lower_bound(xDataBegin, xDataEnd, range.m_TStart);
		28	auto upperIt = std::upper_bound(xDataBegin, xDataEnd, range.m_TEnd);
		29	auto distance = std::distance(xDataBegin, lowerIt);
		30
		31	auto valuesDataIt = currentValuesData.cbegin() + distance;
		32	for (auto xAxisDataIt = lowerIt; xAxisDataIt != upperIt; ++xAxisDataIt, ++valuesDataIt) {
		33	subXAxisData.append(*xAxisDataIt);
		34	subValuesData.append(*valuesDataIt);
		35	}
		36	}
		37	this->unlock();
		38
		39	return std::make_shared<ScalarSeries>(subXAxisData, subValuesData, this->xAxisUnit(),
		40	this->valuesUnit());
		41	}

core/src/Network/NetworkController.cpp +5 -4

             #include "Network/NetworkController.h"
             #include <QMutex>
             #include <QNetworkAccessManager>
             #include <QNetworkReply>
             #include <QNetworkRequest>
             #include <QReadWriteLock>
             #include <QThread>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_NetworkController, "NetworkController")
             struct NetworkController::NetworkControllerPrivate {
                 explicit NetworkControllerPrivate(NetworkController *parent) : m_WorkingMutex{} {}
+                void lockRead() { m_Lock.lockForRead(); }
+                void lockWrite() { m_Lock.lockForWrite(); }
+                void unlock() { m_Lock.unlock(); }
                 QMutex m_WorkingMutex;
                 QReadWriteLock m_Lock;
                 std::unordered_map<QNetworkReply *, QUuid> m_NetworkReplyToVariableId;
                 std::unique_ptr<QNetworkAccessManager> m_AccessManager{nullptr};
-                void lockRead() { m_Lock.lockForRead(); }
-                void lockWrite() { m_Lock.lockForWrite(); }
-                void unlock() { m_Lock.unlock(); }
             };
             NetworkController::NetworkController(QObject *parent)
                     : QObject(parent), impl{spimpl::make_unique_impl<NetworkControllerPrivate>(this)}
             {
             }
             void NetworkController::onProcessRequested(const QNetworkRequest &request, QUuid identifier,
                                                        std::function<void(QNetworkReply *, QUuid)> callback)
             {
                 qCDebug(LOG_NetworkController()) << tr("NetworkController registered")
                                                  << QThread::currentThread()->objectName();
                 auto reply = impl->m_AccessManager->get(request);
                 // Store the couple reply id
                 impl->lockWrite();
                 impl->m_NetworkReplyToVariableId[reply] = identifier;
                 impl->unlock();
                 auto onReplyFinished = [reply, this, identifier, callback]() {
                     qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished")
                                                      << QThread::currentThread() << reply;
                     impl->lockRead();
                     auto it = impl->m_NetworkReplyToVariableId.find(reply);
                     impl->unlock();
                     if (it != impl->m_NetworkReplyToVariableId.cend()) {
                         impl->lockWrite();
                         impl->m_NetworkReplyToVariableId.erase(reply);
                         impl->unlock();
                         // Deletes reply
                         callback(reply, identifier);
                         reply->deleteLater();
                         emit this->replyDownloadProgress(identifier, 0);
                     }
                     qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished END")
                                                      << QThread::currentThread() << reply;
                 };
                 auto onReplyProgress = [reply, this](qint64 bytesRead, qint64 totalBytes) {
                     double progress = (bytesRead * 100.0) / totalBytes;
                     qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyProgress") << progress
                                                      << QThread::currentThread() << reply;
                     impl->lockRead();
                     auto it = impl->m_NetworkReplyToVariableId.find(reply);
                     impl->unlock();
                     if (it != impl->m_NetworkReplyToVariableId.cend()) {
                         emit this->replyDownloadProgress(it->second, progress);
                     }
                     qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyProgress END")
                                                      << QThread::currentThread() << reply;
                 };
                 connect(reply, &QNetworkReply::finished, this, onReplyFinished);
                 connect(reply, &QNetworkReply::downloadProgress, this, onReplyProgress);
                 qCDebug(LOG_NetworkController()) << tr("NetworkController registered END")
                                                  << QThread::currentThread()->objectName() << reply;
             }
             void NetworkController::initialize()
             {
                 qCDebug(LOG_NetworkController()) << tr("NetworkController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 impl->m_AccessManager = std::make_unique<QNetworkAccessManager>();
                 auto onReplyErrors = [this](QNetworkReply *reply, const QList<QSslError> &errors) {
                     qCCritical(LOG_NetworkController()) << tr("NetworkAcessManager errors: ") << errors;
                 };
                 connect(impl->m_AccessManager.get(), &QNetworkAccessManager::sslErrors, this, onReplyErrors);
                 qCDebug(LOG_NetworkController()) << tr("NetworkController init END");
             }
             void NetworkController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void NetworkController::onReplyCanceled(QUuid identifier)
             {
                 auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
                 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyCanceled")
                                                  << QThread::currentThread();
                 impl->lockRead();
                 auto end = impl->m_NetworkReplyToVariableId.cend();
                 auto it = std::find_if(impl->m_NetworkReplyToVariableId.cbegin(), end, findReply);
                 impl->unlock();
                 if (it != end) {
                     it->first->abort();
                 }
                 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyCanceled END")
                                                  << QThread::currentThread();
             }
             void NetworkController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

core/src/Settings/SqpSettingsDefs.cpp +11 0

@@ -1,7 +1,18
1	#include "Settings/SqpSettingsDefs.h"	1	#include "Settings/SqpSettingsDefs.h"
2		2
		3	#include <QSettings>
		4
		5
		6	/// Gets a tolerance value from application settings. If the setting can't be found, the default
		7	/// value passed in parameter is returned
		8	double SqpSettings::toleranceValue(const QString &key, double defaultValue) noexcept
		9	{
		10	return QSettings{}.value(key, defaultValue).toDouble();
		11	}
		12
		13
3	const QString GENERAL_TOLERANCE_AT_INIT_KEY = QStringLiteral("toleranceInit");	14	const QString GENERAL_TOLERANCE_AT_INIT_KEY = QStringLiteral("toleranceInit");
4	const double GENERAL_TOLERANCE_AT_INIT_DEFAULT_VALUE = 0.2;	15	const double GENERAL_TOLERANCE_AT_INIT_DEFAULT_VALUE = 0.2;
5		16
6	const QString GENERAL_TOLERANCE_AT_UPDATE_KEY = QStringLiteral("toleranceUpdate");	17	const QString GENERAL_TOLERANCE_AT_UPDATE_KEY = QStringLiteral("toleranceUpdate");
7	const double GENERAL_TOLERANCE_AT_UPDATE_DEFAULT_VALUE = 0.2;	18	const double GENERAL_TOLERANCE_AT_UPDATE_DEFAULT_VALUE = 0.2;

core/src/Variable/Variable.cpp +144 -19

@@ -1,86 +1,211
1	#include "Variable/Variable.h"	1	#include "Variable/Variable.h"
2		2
3	#include <Data/IDataSeries.h>	3	#include <Data/IDataSeries.h>
4	#include <Data/SqpRange.h>	4	#include <Data/SqpRange.h>
5		5
		6	#include <QMutex>
6	#include <QReadWriteLock>	7	#include <QReadWriteLock>
7	#include <QThread>	8	#include <QThread>
8		9
9	Q_LOGGING_CATEGORY(LOG_Variable, "Variable")	10	Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
10		11
11	struct Variable::VariablePrivate {	12	struct Variable::VariablePrivate {
12	explicit VariablePrivate(const QString &name, const SqpRange &dateTime,	13	explicit VariablePrivate(const QString &name, const SqpRange &dateTime,
13	const QVariantHash &metadata)	14	const QVariantHash &metadata)
14	: m_Name{name}, m_~~DateTim~~e{dateTime}, m_Metadata{metadata}, m_DataSeries{nullptr}	15	: m_Name{name}, m_Range{dateTime}, m_Metadata{metadata}, m_DataSeries{nullptr}
15	{	16	{
16	}	17	}
17		18
		19	void lockRead() { m_Lock.lockForRead(); }
		20	void lockWrite() { m_Lock.lockForWrite(); }
		21	void unlock() { m_Lock.unlock(); }
		22
18	QString m_Name;	23	QString m_Name;
19		24
20	SqpRange m_DateTime; // The dateTime available in the view and loaded. not the cache.	25	SqpRange m_Range;
		26	SqpRange m_CacheRange;
21	QVariantHash m_Metadata;	27	QVariantHash m_Metadata;
22	std::~~unique~~_ptr<IDataSeries> m_DataSeries;	28	std::shared_ptr<IDataSeries> m_DataSeries;
		29
		30	QReadWriteLock m_Lock;
23	};	31	};
24		32
25	Variable::Variable(const QString &name, const SqpRange &dateTime, const QVariantHash &metadata)	33	Variable::Variable(const QString &name, const SqpRange &dateTime, const QVariantHash &metadata)
26	: impl{spimpl::make_unique_impl<VariablePrivate>(name, dateTime, metadata)}	34	: impl{spimpl::make_unique_impl<VariablePrivate>(name, dateTime, metadata)}
27	{	35	{
28	}	36	}
29		37
30	QString Variable::name() const noexcept	38	QString Variable::name() const noexcept
31	{	39	{
32	return impl->m_Name;	40	impl->lockRead();
		41	auto name = impl->m_Name;
		42	impl->unlock();
		43	return name;
		44	}
		45
		46	SqpRange Variable::range() const noexcept
		47	{
		48	impl->lockRead();
		49	auto range = impl->m_Range;
		50	impl->unlock();
		51	return range;
33	}	52	}
34		53
35	SqpRange Variable::dateTime() const noexcept	54	void Variable::setRange(const SqpRange &range) noexcept
36	{	55	{
37	return impl->m_DateTime;	56	impl->lockWrite();
		57	impl->m_Range = range;
		58	impl->unlock();
38	}	59	}
39		60
40	void Variable::setDateTime(const SqpRange &dateTime) noexcept	61	SqpRange Variable::cacheRange() const noexcept
41	{	62	{
42	impl->m_DateTime = dateTime;	63	impl->lockRead();
		64	auto cacheRange = impl->m_CacheRange;
		65	impl->unlock();
		66	return cacheRange;
		67	}
		68
		69	void Variable::setCacheRange(const SqpRange &cacheRange) noexcept
		70	{
		71	impl->lockWrite();
		72	impl->m_CacheRange = cacheRange;
		73	impl->unlock();
43	}	74	}
44		75
45	void Variable::setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept	76	void Variable::setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
46	{	77	{
47	qCDebug(LOG_Variable()) << "Variable::setDataSeries" << ~~QThread~~::~~currentThread~~()->~~objectName();~~	78	qCDebug(LOG_Variable()) << "TORM Variable::setDataSeries"
		79	<< QThread::currentThread()->objectName();
48	if (!dataSeries) {	80	if (!dataSeries) {
49	/// @todo ALX : log	81	/// @todo ALX : log
50	return;	82	return;
51	}	83	}
		84	impl->lockWrite();
		85	impl->m_DataSeries = dataSeries->clone();
		86	impl->unlock();
		87	}
52		88
		89	void Variable::mergeDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
		90	{
		91	qCDebug(LOG_Variable()) << "TORM Variable::mergeDataSeries"
		92	<< QThread::currentThread()->objectName();
		93	if (!dataSeries) {
		94	/// @todo ALX : log
		95	return;
		96	}
		97
		98	// Add or merge the data
53	// Inits the data series of the variable	99	// Inits the data series of the variable
		100	impl->lockWrite();
54	if (!impl->m_DataSeries) {	101	if (!impl->m_DataSeries) {
55	impl->m_DataSeries = dataSeries->clone();	102	impl->m_DataSeries = dataSeries->clone();
56	}	103	}
57	else {	104	else {
58	impl->m_DataSeries->merge(dataSeries.get());	105	impl->m_DataSeries->merge(dataSeries.get());
59	// emit updated();
60	}	106	}
		107	impl->unlock();
		108
		109	// sub the data
		110	auto subData = this->dataSeries()->subData(this->cacheRange());
		111	qCDebug(LOG_Variable()) << "TORM: Variable::mergeDataSeries sub" << subData->range();
		112	this->setDataSeries(subData);
		113	qCDebug(LOG_Variable()) << "TORM: Variable::mergeDataSeries set" << this->dataSeries()->range();
61	}	114	}
62		115
63	IDataSeries *Variable::dataSeries() const noexcept	116	std::shared_ptr<IDataSeries> Variable::dataSeries() const noexcept
64	{	117	{
65	return impl->m_DataSeries.get();	118	impl->lockRead();
		119	auto dataSeries = impl->m_DataSeries;
		120	impl->unlock();
		121
		122	return dataSeries;
66	}	123	}
67		124
68	QVariantHash Variable::metadata() const noexcept	125	QVariantHash Variable::metadata() const noexcept
69	{	126	{
70	return impl->m_Metadata;	127	impl->lockRead();
		128	auto metadata = impl->m_Metadata;
		129	impl->unlock();
		130	return metadata;
71	}	131	}
72		132
73	bool Variable::contains(const SqpRange &~~dateTim~~e) const noexcept	133	bool Variable::contains(const SqpRange &range) const noexcept
74	{	134	{
75	return impl->m_DateTime.contains(dateTime);	135	impl->lockRead();
		136	auto res = impl->m_Range.contains(range);
		137	impl->unlock();
		138	return res;
76	}	139	}
77		140
78	bool Variable::intersect(const SqpRange &~~dateTim~~e) const noexcept	141	bool Variable::intersect(const SqpRange &range) const noexcept
79	{	142	{
80	return impl->m_DateTime.intersect(dateTime);	143
		144	impl->lockRead();
		145	auto res = impl->m_Range.intersect(range);
		146	impl->unlock();
		147	return res;
		148	}
		149
		150	bool Variable::isInside(const SqpRange &range) const noexcept
		151	{
		152	impl->lockRead();
		153	auto res = range.contains(SqpRange{impl->m_Range.m_TStart, impl->m_Range.m_TEnd});
		154	impl->unlock();
		155	return res;
		156	}
		157
		158	bool Variable::cacheContains(const SqpRange &range) const noexcept
		159	{
		160	impl->lockRead();
		161	auto res = impl->m_CacheRange.contains(range);
		162	impl->unlock();
		163	return res;
		164	}
		165
		166	bool Variable::cacheIntersect(const SqpRange &range) const noexcept
		167	{
		168	impl->lockRead();
		169	auto res = impl->m_CacheRange.intersect(range);
		170	impl->unlock();
		171	return res;
		172	}
		173
		174	bool Variable::cacheIsInside(const SqpRange &range) const noexcept
		175	{
		176	impl->lockRead();
		177	auto res = range.contains(SqpRange{impl->m_CacheRange.m_TStart, impl->m_CacheRange.m_TEnd});
		178	impl->unlock();
		179	return res;
81	}	180	}
82		181
83	bool Variable::isInside(const SqpRange &dateTime) const noexcept	182
		183	QVector<SqpRange> Variable::provideNotInCacheRangeList(const SqpRange &range) const noexcept
84	{	184	{
85	return dateTime.contains(SqpRange{impl->m_DateTime.m_TStart, impl->m_DateTime.m_TEnd});	185	auto notInCache = QVector<SqpRange>{};
		186
		187	if (!this->cacheContains(range)) {
		188	if (range.m_TEnd <= impl->m_CacheRange.m_TStart
		189	\|\| range.m_TStart >= impl->m_CacheRange.m_TEnd) {
		190	notInCache << range;
		191	}
		192	else if (range.m_TStart < impl->m_CacheRange.m_TStart
		193	&& range.m_TEnd <= impl->m_CacheRange.m_TEnd) {
		194	notInCache << SqpRange{range.m_TStart, impl->m_CacheRange.m_TStart};
		195	}
		196	else if (range.m_TStart < impl->m_CacheRange.m_TStart
		197	&& range.m_TEnd > impl->m_CacheRange.m_TEnd) {
		198	notInCache << SqpRange{range.m_TStart, impl->m_CacheRange.m_TStart}
		199	<< SqpRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
		200	}
		201	else if (range.m_TStart < impl->m_CacheRange.m_TEnd) {
		202	notInCache << SqpRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
		203	}
		204	else {
		205	qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
		206	<< QThread::currentThread();
		207	}
		208	}
		209
		210	return notInCache;
86	}	211	}

core/src/Variable/VariableController.cpp +345 -45

@@ -1,243 +1,543
1	#include <Variable/Variable.h>	1	#include <Variable/Variable.h>
		2	#include <Variable/VariableAcquisitionWorker.h>
2	#include <Variable/VariableCacheController.h>	3	#include <Variable/VariableCacheController.h>
		4	#include <Variable/VariableCacheStrategy.h>
3	#include <Variable/VariableController.h>	5	#include <Variable/VariableController.h>
4	#include <Variable/VariableModel.h>	6	#include <Variable/VariableModel.h>
		7	#include <Variable/VariableSynchronizationGroup.h>
5		8
6	#include <Data/DataProviderParameters.h>	9	#include <Data/DataProviderParameters.h>
7	#include <Data/IDataProvider.h>	10	#include <Data/IDataProvider.h>
8	#include <Data/IDataSeries.h>	11	#include <Data/IDataSeries.h>
9	#include <Time/TimeController.h>	12	#include <Time/TimeController.h>
10		13
11	#include <QMutex>	14	#include <QMutex>
12	#include <QThread>	15	#include <QThread>
13	#include <QUuid>	16	#include <QUuid>
14	#include <QtCore/QItemSelectionModel>	17	#include <QtCore/QItemSelectionModel>
15		18
		19	#include <set>
16	#include <unordered_map>	20	#include <unordered_map>
17		21
18	Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")	22	Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
19		23
		24	namespace {
		25
		26	SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &grapheRange,
		27	const SqpRange &oldGraphRange)
		28	{
		29	auto zoomType = VariableController::getZoomType(grapheRange, oldGraphRange);
		30
		31	auto varRangeRequested = varRange;
		32	switch (zoomType) {
		33	case AcquisitionZoomType::ZoomIn: {
		34	auto deltaLeft = grapheRange.m_TStart - oldGraphRange.m_TStart;
		35	auto deltaRight = oldGraphRange.m_TEnd - grapheRange.m_TEnd;
		36	varRangeRequested.m_TStart += deltaLeft;
		37	varRangeRequested.m_TEnd -= deltaRight;
		38	break;
		39	}
		40
		41	case AcquisitionZoomType::ZoomOut: {
		42	auto deltaLeft = oldGraphRange.m_TStart - grapheRange.m_TStart;
		43	auto deltaRight = grapheRange.m_TEnd - oldGraphRange.m_TEnd;
		44	varRangeRequested.m_TStart -= deltaLeft;
		45	varRangeRequested.m_TEnd += deltaRight;
		46	break;
		47	}
		48	case AcquisitionZoomType::PanRight: {
		49	auto deltaRight = grapheRange.m_TEnd - oldGraphRange.m_TEnd;
		50	varRangeRequested.m_TStart += deltaRight;
		51	varRangeRequested.m_TEnd += deltaRight;
		52	break;
		53	}
		54	case AcquisitionZoomType::PanLeft: {
		55	auto deltaLeft = oldGraphRange.m_TStart - grapheRange.m_TStart;
		56	varRangeRequested.m_TStart -= deltaLeft;
		57	varRangeRequested.m_TEnd -= deltaLeft;
		58	break;
		59	}
		60	case AcquisitionZoomType::Unknown: {
		61	qCCritical(LOG_VariableController())
		62	<< VariableController::tr("Impossible to synchronize: zoom type unknown");
		63	break;
		64	}
		65	default:
		66	qCCritical(LOG_VariableController()) << VariableController::tr(
		67	"Impossible to synchronize: zoom type not take into account");
		68	// No action
		69	break;
		70	}
		71
		72	return varRangeRequested;
		73	}
		74	}
		75
20	struct VariableController::VariableControllerPrivate {	76	struct VariableController::VariableControllerPrivate {
21	explicit VariableControllerPrivate(VariableController *parent)	77	explicit VariableControllerPrivate(VariableController *parent)
22	: m_WorkingMutex{},	78	: m_WorkingMutex{},
23	m_VariableModel{new VariableModel{parent}},	79	m_VariableModel{new VariableModel{parent}},
24	m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},	80	m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
25	m_VariableCacheController{std::make_unique<VariableCacheController>()}	81	m_VariableCacheController{std::make_unique<VariableCacheController>()},
		82	m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},
		83	m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()}
		84	{
		85
		86	m_VariableAcquisitionWorker->moveToThread(&m_VariableAcquisitionWorkerThread);
		87	m_VariableAcquisitionWorkerThread.setObjectName("VariableAcquisitionWorkerThread");
		88	}
		89
		90
		91	virtual ~VariableControllerPrivate()
26	{	92	{
		93	qCDebug(LOG_VariableController()) << tr("VariableControllerPrivate destruction");
		94	m_VariableAcquisitionWorkerThread.quit();
		95	m_VariableAcquisitionWorkerThread.wait();
27	}	96	}
28		97
		98
		99	void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested);
		100
		101	QVector<SqpRange> provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
		102	const SqpRange &dateTime);
		103
		104	std::shared_ptr<Variable> findVariable(QUuid vIdentifier);
		105	std::shared_ptr<IDataSeries>
		106	retrieveDataSeries(const QVector<AcquisitionDataPacket> acqDataPacketVector);
		107
		108	void registerProvider(std::shared_ptr<IDataProvider> provider);
		109
29	QMutex m_WorkingMutex;	110	QMutex m_WorkingMutex;
30	/// Variable model. The VariableController has the ownership	111	/// Variable model. The VariableController has the ownership
31	VariableModel *m_VariableModel;	112	VariableModel *m_VariableModel;
32	QItemSelectionModel *m_VariableSelectionModel;	113	QItemSelectionModel *m_VariableSelectionModel;
33		114
34		115
35	TimeController *m_TimeController{nullptr};	116	TimeController *m_TimeController{nullptr};
36	std::unique_ptr<VariableCacheController> m_VariableCacheController;	117	std::unique_ptr<VariableCacheController> m_VariableCacheController;
		118	std::unique_ptr<VariableCacheStrategy> m_VariableCacheStrategy;
		119	std::unique_ptr<VariableAcquisitionWorker> m_VariableAcquisitionWorker;
		120	QThread m_VariableAcquisitionWorkerThread;
37		121
38	std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >	122	std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
39	m_VariableToProviderMap;	123	m_VariableToProviderMap;
40	std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;	124	std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
		125	std::map<QUuid, std::shared_ptr<VariableSynchronizationGroup> >
		126	m_GroupIdToVariableSynchronizationGroupMap;
		127	std::map<QUuid, QUuid> m_VariableIdGroupIdMap;
		128	std::set<std::shared_ptr<IDataProvider> > m_ProviderSet;
41	};	129	};
42		130
		131
43	VariableController::VariableController(QObject *parent)	132	VariableController::VariableController(QObject *parent)
44	: QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}	133	: QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
45	{	134	{
46	qCDebug(LOG_VariableController()) << tr("VariableController construction")	135	qCDebug(LOG_VariableController()) << tr("VariableController construction")
47	<< QThread::currentThread();	136	<< QThread::currentThread();
48		137
49	connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,	138	connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
50	&VariableController::onAbortProgressRequested);	139	&VariableController::onAbortProgressRequested);
		140
		141	connect(impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::dataProvided, this,
		142	&VariableController::onDataProvided);
		143	connect(impl->m_VariableAcquisitionWorker.get(),
		144	&VariableAcquisitionWorker::variableRequestInProgress, this,
		145	&VariableController::onVariableRetrieveDataInProgress);
		146
		147	connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::started,
		148	impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::initialize);
		149	connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::finished,
		150	impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::finalize);
		151
		152
		153	impl->m_VariableAcquisitionWorkerThread.start();
51	}	154	}
52		155
53	VariableController::~VariableController()	156	VariableController::~VariableController()
54	{	157	{
55	qCDebug(LOG_VariableController()) << tr("VariableController destruction")	158	qCDebug(LOG_VariableController()) << tr("VariableController destruction")
56	<< QThread::currentThread();	159	<< QThread::currentThread();
57	this->waitForFinish();	160	this->waitForFinish();
58	}	161	}
59		162
60	VariableModel *VariableController::variableModel() noexcept	163	VariableModel *VariableController::variableModel() noexcept
61	{	164	{
62	return impl->m_VariableModel;	165	return impl->m_VariableModel;
63	}	166	}
64		167
65	QItemSelectionModel *VariableController::variableSelectionModel() noexcept	168	QItemSelectionModel *VariableController::variableSelectionModel() noexcept
66	{	169	{
67	return impl->m_VariableSelectionModel;	170	return impl->m_VariableSelectionModel;
68	}	171	}
69		172
70	void VariableController::setTimeController(TimeController *timeController) noexcept	173	void VariableController::setTimeController(TimeController *timeController) noexcept
71	{	174	{
72	impl->m_TimeController = timeController;	175	impl->m_TimeController = timeController;
73	}	176	}
74		177
75	void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept	178	void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
76	{	179	{
77	if (!variable) {	180	if (!variable) {
78	qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";	181	qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
79	return;	182	return;
80	}	183	}
81		184
82	// Spreads in SciQlop that the variable will be deleted, so that potential receivers can	185	// Spreads in SciQlop that the variable will be deleted, so that potential receivers can
83	// make some treatments before the deletion	186	// make some treatments before the deletion
84	emit variableAboutToBeDeleted(variable);	187	emit variableAboutToBeDeleted(variable);
85		188
86	// Deletes identifier	189	// Deletes identifier
87	impl->m_VariableToIdentifierMap.erase(variable);	190	impl->m_VariableToIdentifierMap.erase(variable);
88		191
89	// Deletes provider	192	// Deletes provider
90	auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);	193	auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
91	qCDebug(LOG_VariableController())	194	qCDebug(LOG_VariableController())
92	<< tr("Number of providers deleted for variable %1: %2")	195	<< tr("Number of providers deleted for variable %1: %2")
93	.arg(variable->name(), QString::number(nbProvidersDeleted));	196	.arg(variable->name(), QString::number(nbProvidersDeleted));
94		197
95	// Clears cache	198	// Clears cache
96	impl->m_VariableCacheController->clear(variable);	199	impl->m_VariableCacheController->clear(variable);
97		200
98	// Deletes from model	201	// Deletes from model
99	impl->m_VariableModel->deleteVariable(variable);	202	impl->m_VariableModel->deleteVariable(variable);
100	}	203	}
101		204
102	void VariableController::deleteVariables(	205	void VariableController::deleteVariables(
103	const QVector<std::shared_ptr<Variable> > &variables) noexcept	206	const QVector<std::shared_ptr<Variable> > &variables) noexcept
104	{	207	{
105	for (auto variable : qAsConst(variables)) {	208	for (auto variable : qAsConst(variables)) {
106	deleteVariable(variable);	209	deleteVariable(variable);
107	}	210	}
108	}	211	}
109		212
110	void VariableController::abortProgress(std::shared_ptr<Variable> variable)	213	void VariableController::abortProgress(std::shared_ptr<Variable> variable)
111	{	214	{
112	}	215	}
113		216
114	void VariableController::createVariable(const QString &name, const QVariantHash &metadata,	217	void VariableController::createVariable(const QString &name, const QVariantHash &metadata,
115	std::shared_ptr<IDataProvider> provider) noexcept	218	std::shared_ptr<IDataProvider> provider) noexcept
116	{	219	{
117		220
118	if (!impl->m_TimeController) {	221	if (!impl->m_TimeController) {
119	qCCritical(LOG_VariableController())	222	qCCritical(LOG_VariableController())
120	<< tr("Impossible to create variable: The time controller is null");	223	<< tr("Impossible to create variable: The time controller is null");
121	return;	224	return;
122	}	225	}
123		226
124	auto ~~dateTim~~e = impl->m_TimeController->dateTime();	227	auto range = impl->m_TimeController->dateTime();
125		228
126	if (auto newVariable = impl->m_VariableModel->createVariable(name, ~~dateTim~~e, metadata)) {	229	if (auto newVariable = impl->m_VariableModel->createVariable(name, range, metadata)) {
127	auto identifier = QUuid::createUuid();	230	auto identifier = QUuid::createUuid();
128		231
129	// store the provider	232	// store the provider
		233	impl->registerProvider(provider);
		234
		235	// Associate the provider
130	impl->m_VariableToProviderMap[newVariable] = provider;	236	impl->m_VariableToProviderMap[newVariable] = provider;
131	impl->m_VariableToIdentifierMap[newVariable] = identifier;	237	impl->m_VariableToIdentifierMap[newVariable] = identifier;
132		238
133	auto addDateTimeAcquired = [ this, varW = std::weak_ptr<Variable>{newVariable} ](
134	QUuid identifier, auto dataSeriesAcquired, auto dateTimeToPutInCache)
135	{
136	if (auto variable = varW.lock()) {
137	auto varIdentifier = impl->m_VariableToIdentifierMap.at(variable);
138	if (varIdentifier == identifier) {
139	impl->m_VariableCacheController->addDateTime(variable, dateTimeToPutInCache);
140	variable->setDataSeries(dataSeriesAcquired);
141	emit variable->updated();
142	}
143	}
144	};
145		239
146	connect(provider.get(), &IDataProvider::dataProvided, addDateTimeAcquired);	240	impl->processRequest(newVariable, range);
147	connect(provider.get(), &IDataProvider::dataProvidedProgress, this,
148	&VariableController::onVariableRetrieveDataInProgress);
149	this->onRequestDataLoading(newVariable, dateTime);
150	}	241	}
151	}	242	}
152		243
153	void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)	244	void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
154	{	245	{
		246	// TODO check synchronisation
155	qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"	247	qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
156	<< QThread::currentThread()->objectName();	248	<< QThread::currentThread()->objectName();
157	auto selectedRows = impl->m_VariableSelectionModel->selectedRows();	249	auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
158		250
159	for (const auto &selectedRow : qAsConst(selectedRows)) {	251	for (const auto &selectedRow : qAsConst(selectedRows)) {
160	if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {	252	if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
161	selectedVariable->set~~DateTim~~e(dateTime);	253	selectedVariable->setRange(dateTime);
162	~~this~~->onRequest~~DataLoading~~(selectedVariable, dateTime);	254	impl->processRequest(selectedVariable, dateTime);
163		255
164	// notify that rescale operation has to be done	256	// notify that rescale operation has to be done
165	emit rangeChanged(selectedVariable, dateTime);	257	emit rangeChanged(selectedVariable, dateTime);
166	}	258	}
167	}	259	}
168	}	260	}
169		261
170	void VariableController::on~~VariableRetrieveDataInProgress~~(QUuid identifier, ~~double~~ ~~progress~~)	262	void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
		263	const SqpRange &cacheRangeRequested,
		264	QVector<AcquisitionDataPacket> dataAcquired)
171	{	265	{
172	auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };	266	auto var = impl->findVariable(vIdentifier);
		267	if (var != nullptr) {
		268	var->setRange(rangeRequested);
		269	var->setCacheRange(cacheRangeRequested);
		270	qCDebug(LOG_VariableController()) << tr("1: onDataProvided") << rangeRequested;
		271	qCDebug(LOG_VariableController()) << tr("2: onDataProvided") << cacheRangeRequested;
		272
		273	auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
		274	qCDebug(LOG_VariableController()) << tr("3: onDataProvided")
		275	<< retrievedDataSeries->range();
		276	var->mergeDataSeries(retrievedDataSeries);
		277	qCDebug(LOG_VariableController()) << tr("4: onDataProvided");
		278	emit var->updated();
		279	}
		280	else {
		281	qCCritical(LOG_VariableController()) << tr("Impossible to provide data to a null variable");
		282	}
		283	}
173		284
174	auto end = impl->m_VariableToIdentifierMap.cend();	285	void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
175	auto it = std::find_if(impl->m_VariableToIdentifierMap.cbegin(), end, findReply);	286	{
176	if (it != end) {	287	auto var = impl->findVariable(identifier);
177	impl->m_VariableModel->setDataProgress(it->first, progress);	288	if (var != nullptr) {
		289	impl->m_VariableModel->setDataProgress(var, progress);
		290	}
		291	else {
		292	qCCritical(LOG_VariableController())
		293	<< tr("Impossible to notify progression of a null variable");
178	}	294	}
179	}	295	}
180		296
181	void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)	297	void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
182	{	298	{
183	qCDebug(LOG_VariableController()) << "TORM: VariableController::onAbortProgressRequested"	299	qCDebug(LOG_VariableController()) << "TORM: VariableController::onAbortProgressRequested"
184	<< QThread::currentThread()->objectName();	300	<< QThread::currentThread()->objectName();
185		301
186	auto it = impl->m_VariableToIdentifierMap.find(variable);	302	auto it = impl->m_VariableToIdentifierMap.find(variable);
187	if (it != impl->m_VariableToIdentifierMap.cend()) {	303	if (it != impl->m_VariableToIdentifierMap.cend()) {
188	impl->m_VariableToProviderMap.at(variable)->requestDataAborting(it->second);	304	impl->m_VariableToProviderMap.at(variable)->requestDataAborting(it->second);
189	}	305	}
190	else {	306	else {
191	qCWarning(LOG_VariableController())	307	qCWarning(LOG_VariableController())
192	<< tr("Aborting progression of inexistant variable detected !!!")	308	<< tr("Aborting progression of inexistant variable detected !!!")
193	<< QThread::currentThread()->objectName();	309	<< QThread::currentThread()->objectName();
194	}	310	}
195	}	311	}
196		312
		313	void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
		314	{
		315	qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"
		316	<< QThread::currentThread()->objectName()
		317	<< synchronizationGroupId;
		318	auto vSynchroGroup = std::make_shared<VariableSynchronizationGroup>();
		319	impl->m_GroupIdToVariableSynchronizationGroupMap.insert(
		320	std::make_pair(synchronizationGroupId, vSynchroGroup));
		321	}
197		322
198	void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,	323	void VariableController::onRemoveSynchronizationGroupId(QUuid synchronizationGroupId)
199	const SqpRange &dateTime)
200	{	324	{
201	qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"	325	impl->m_GroupIdToVariableSynchronizationGroupMap.erase(synchronizationGroupId);
202	<< QThread::currentThread()->objectName();	326	}
203	// we want to load data of the variable for the dateTime.
204	// First we check if the cache contains some of them.
205	// For the other, we ask the provider to give them.
206	if (variable) {
207		327
208	auto dateTimeListNotInCache	328	void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,
209	= impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);	329	QUuid synchronizationGroupId)
210		330
211	if (!dateTimeListNotInCache.empty()) {	331	{
212	// Ask the provider for each data on the dateTimeListNotInCache	332	qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"
213	auto identifier = impl->m_VariableToIdentifierMap.at(variable);	333	<< synchronizationGroupId;
214	impl->m_VariableToProviderMap.at(variable)->requestDataLoading(	334	auto vToVIdit = impl->m_VariableToIdentifierMap.find(variable);
215	identifier,	335	if (vToVIdit != impl->m_VariableToIdentifierMap.cend()) {
216	DataProviderParameters{std::move(dateTimeListNotInCache), variable->metadata()});	336	auto itSynchroGroup
		337	= impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
		338	if (itSynchroGroup != impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
		339	impl->m_VariableIdGroupIdMap.insert(
		340	std::make_pair(vToVIdit->second, synchronizationGroupId));
		341	itSynchroGroup->second->addVariableId(vToVIdit->second);
217	}	342	}
218	else {	343	else {
219	emit variable->updated();	344	qCCritical(LOG_VariableController())
		345	<< tr("Impossible to synchronize a variable with an unknown sycnhronization group")
		346	<< variable->name();
220	}	347	}
221	}	348	}
222	else {	349	else {
223	qCCritical(LOG_VariableController()) << tr(~~"Impossible to load data of a variable null"~~);	350	qCCritical(LOG_VariableController())
		351	<< tr("Impossible to synchronize a variable with no identifier") << variable->name();
		352	}
		353	}
		354
		355
		356	void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,
		357	const SqpRange &range, const SqpRange &oldRange,
		358	bool synchronise)
		359	{
		360	// NOTE: oldRange isn't really necessary since oldRange == variable->range().
		361
		362	qCInfo(LOG_VariableController()) << "VariableController::onRequestDataLoading"
		363	<< QThread::currentThread()->objectName();
		364	// we want to load data of the variable for the dateTime.
		365	// First we check if the cache contains some of them.
		366	// For the other, we ask the provider to give them.
		367
		368	foreach (auto var, variables) {
		369	qCDebug(LOG_VariableController()) << "processRequest for" << var->name();
		370	impl->processRequest(var, range);
		371	}
		372
		373	if (synchronise) {
		374	// Get the group ids
		375	qCDebug(LOG_VariableController())
		376	<< "VariableController::onRequestDataLoading for synchro var ENABLE";
		377	auto groupIds = std::set<QUuid>();
		378	foreach (auto var, variables) {
		379	auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(var);
		380	if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
		381	auto vId = varToVarIdIt->second;
		382	auto varIdToGroupIdIt = impl->m_VariableIdGroupIdMap.find(vId);
		383	if (varIdToGroupIdIt != impl->m_VariableIdGroupIdMap.cend()) {
		384	auto gId = varIdToGroupIdIt->second;
		385	if (groupIds.find(gId) == groupIds.cend()) {
		386	qCDebug(LOG_VariableController()) << "Synchro detect group " << gId;
		387	groupIds.insert(gId);
		388	}
		389	}
		390	}
		391	}
		392
		393	// We assume here all group ids exist
		394	foreach (auto gId, groupIds) {
		395	auto vSynchronizationGroup = impl->m_GroupIdToVariableSynchronizationGroupMap.at(gId);
		396	auto vSyncIds = vSynchronizationGroup->getIds();
		397	qCDebug(LOG_VariableController()) << "Var in synchro group ";
		398	for (auto vId : vSyncIds) {
		399	auto var = impl->findVariable(vId);
		400
		401	// Don't process already processed var
		402	if (!variables.contains(var)) {
		403	if (var != nullptr) {
		404	qCDebug(LOG_VariableController()) << "processRequest synchro for"
		405	<< var->name();
		406	auto vSyncRangeRequested
		407	= computeSynchroRangeRequested(var->range(), range, oldRange);
		408	impl->processRequest(var, vSyncRangeRequested);
		409	}
		410	else {
		411	qCCritical(LOG_VariableController())
		412
		413	<< tr("Impossible to synchronize a null variable");
		414	}
		415	}
		416	}
		417	}
224	}	418	}
225	}	419	}
226		420
227		421
228	void VariableController::initialize()	422	void VariableController::initialize()
229	{	423	{
230	qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();	424	qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
231	impl->m_WorkingMutex.lock();	425	impl->m_WorkingMutex.lock();
232	qCDebug(LOG_VariableController()) << tr("VariableController init END");	426	qCDebug(LOG_VariableController()) << tr("VariableController init END");
233	}	427	}
234		428
235	void VariableController::finalize()	429	void VariableController::finalize()
236	{	430	{
237	impl->m_WorkingMutex.unlock();	431	impl->m_WorkingMutex.unlock();
238	}	432	}
239		433
240	void VariableController::waitForFinish()	434	void VariableController::waitForFinish()
241	{	435	{
242	QMutexLocker locker{&impl->m_WorkingMutex};	436	QMutexLocker locker{&impl->m_WorkingMutex};
243	}	437	}
		438
		439	AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const SqpRange &oldRange)
		440	{
		441	// t1.m_TStart <= t2.m_TStart && t2.m_TEnd <= t1.m_TEnd
		442	auto zoomType = AcquisitionZoomType::Unknown;
		443	if (range.m_TStart <= oldRange.m_TStart && oldRange.m_TEnd <= range.m_TEnd) {
		444	zoomType = AcquisitionZoomType::ZoomOut;
		445	}
		446	else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {
		447	zoomType = AcquisitionZoomType::PanRight;
		448	}
		449	else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {
		450	zoomType = AcquisitionZoomType::PanLeft;
		451	}
		452	else if (range.m_TStart > oldRange.m_TStart && oldRange.m_TEnd > range.m_TEnd) {
		453	zoomType = AcquisitionZoomType::ZoomIn;
		454	}
		455	else {
		456	qCCritical(LOG_VariableController()) << "getZoomType: Unknown type detected";
		457	}
		458	return zoomType;
		459	}
		460
		461	void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,
		462	const SqpRange &rangeRequested)
		463	{
		464
		465	auto varRangesRequested
		466	= m_VariableCacheStrategy->computeCacheRange(var->range(), rangeRequested);
		467	auto notInCacheRangeList = var->provideNotInCacheRangeList(varRangesRequested.second);
		468
		469	if (!notInCacheRangeList.empty()) {
		470	auto identifier = m_VariableToIdentifierMap.at(var);
		471	auto varProvider = m_VariableToProviderMap.at(var);
		472	if (varProvider != nullptr) {
		473	m_VariableAcquisitionWorker->pushVariableRequest(
		474	identifier, varRangesRequested.first, varRangesRequested.second,
		475	DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},
		476	varProvider);
		477	}
		478	else {
		479	qCCritical(LOG_VariableController())
		480	<< "Impossible to provide data with a null provider";
		481	}
		482	}
		483	else {
		484	var->setRange(rangeRequested);
		485	var->setCacheRange(varRangesRequested.second);
		486	var->setDataSeries(var->dataSeries()->subData(varRangesRequested.second));
		487	emit var->updated();
		488	}
		489	}
		490
		491	std::shared_ptr<Variable>
		492	VariableController::VariableControllerPrivate::findVariable(QUuid vIdentifier)
		493	{
		494	std::shared_ptr<Variable> var;
		495	auto findReply = [vIdentifier](const auto &entry) { return vIdentifier == entry.second; };
		496
		497	auto end = m_VariableToIdentifierMap.cend();
		498	auto it = std::find_if(m_VariableToIdentifierMap.cbegin(), end, findReply);
		499	if (it != end) {
		500	var = it->first;
		501	}
		502	else {
		503	qCCritical(LOG_VariableController())
		504	<< tr("Impossible to find the variable with the identifier: ") << vIdentifier;
		505	}
		506
		507	return var;
		508	}
		509
		510	std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(
		511	const QVector<AcquisitionDataPacket> acqDataPacketVector)
		512	{
		513	qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
		514	<< acqDataPacketVector.size();
		515	std::shared_ptr<IDataSeries> dataSeries;
		516	if (!acqDataPacketVector.isEmpty()) {
		517	dataSeries = acqDataPacketVector[0].m_DateSeries;
		518	for (int i = 1; i < acqDataPacketVector.size(); ++i) {
		519	dataSeries->merge(acqDataPacketVector[i].m_DateSeries.get());
		520	}
		521	}
		522	qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size END")
		523	<< acqDataPacketVector.size();
		524	return dataSeries;
		525	}
		526
		527	void VariableController::VariableControllerPrivate::registerProvider(
		528	std::shared_ptr<IDataProvider> provider)
		529	{
		530	if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {
		531	qCDebug(LOG_VariableController()) << tr("Registering of a new provider")
		532	<< provider->objectName();
		533	m_ProviderSet.insert(provider);
		534	connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
		535	&VariableAcquisitionWorker::onVariableDataAcquired);
		536	connect(provider.get(), &IDataProvider::dataProvidedProgress,
		537	m_VariableAcquisitionWorker.get(),
		538	&VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
		539	}
		540	else {
		541	qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
		542	}
		543	}

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

             #include <Variable/Variable.h>
             #include <Variable/VariableModel.h>
             #include <Common/DateUtils.h>
             #include <Data/IDataSeries.h>
             #include <QSize>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
             namespace {
             // Column indexes
             const auto NAME_COLUMN = 0;
             const auto TSTART_COLUMN = 1;
             const auto TEND_COLUMN = 2;
             const auto NB_COLUMNS = 3;
             // Column properties
             const auto DEFAULT_HEIGHT = 25;
             const auto DEFAULT_WIDTH = 100;
             struct ColumnProperties {
                 ColumnProperties(const QString &name = {}, int width = DEFAULT_WIDTH,
                                  int height = DEFAULT_HEIGHT)
                         : m_Name{name}, m_Width{width}, m_Height{height}
                 {
                 }
                 QString m_Name;
                 int m_Width;
                 int m_Height;
             };
             const auto COLUMN_PROPERTIES
                 = QHash<int, ColumnProperties>{{NAME_COLUMN, {QObject::tr("Name")}},
                                                {TSTART_COLUMN, {QObject::tr("tStart"), 180}},
                                                {TEND_COLUMN, {QObject::tr("tEnd"), 180}}};
             /// Format for datetimes
             const auto DATETIME_FORMAT = QStringLiteral("dd/MM/yyyy \nhh:mm:ss:zzz");
             } // namespace
             struct VariableModel::VariableModelPrivate {
                 /// Variables created in SciQlop
                 std::vector<std::shared_ptr<Variable> > m_Variables;
                 std::unordered_map<std::shared_ptr<Variable>, double> m_VariableToProgress;
                 /// Return the row index of the variable. -1 if it's not found
                 int indexOfVariable(Variable *variable) const noexcept;
             };
             VariableModel::VariableModel(QObject *parent)
                     : QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
             {
             }
             std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
                                                                     const SqpRange &dateTime,
                                                                     const QVariantHash &metadata) noexcept
             {
                 auto insertIndex = rowCount();
                 beginInsertRows({}, insertIndex, insertIndex);
                 auto variable = std::make_shared<Variable>(name, dateTime, metadata);
                 impl->m_Variables.push_back(variable);
                 connect(variable.get(), &Variable::updated, this, &VariableModel::onVariableUpdated);
                 endInsertRows();
                 return variable;
             }
             void VariableModel::deleteVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (!variable) {
                     qCCritical(LOG_Variable()) << "Can't delete a null variable from the model";
                     return;
                 }
                 // Finds variable in the model
                 auto begin = impl->m_Variables.cbegin();
                 auto end = impl->m_Variables.cend();
                 auto it = std::find(begin, end, variable);
                 if (it != end) {
                     auto removeIndex = std::distance(begin, it);
                     // Deletes variable
                     beginRemoveRows({}, removeIndex, removeIndex);
                     impl->m_Variables.erase(it);
                     endRemoveRows();
                 }
                 else {
                     qCritical(LOG_VariableModel())
                         << tr("Can't delete variable %1 from the model: the variable is not in the model")
                                .arg(variable->name());
                 }
                 // Removes variable from progress map
                 impl->m_VariableToProgress.erase(variable);
             }
             std::shared_ptr<Variable> VariableModel::variable(int index) const
             {
                 return (index >= 0 && index < impl->m_Variables.size()) ? impl->m_Variables[index] : nullptr;
             }
             void VariableModel::setDataProgress(std::shared_ptr<Variable> variable, double progress)
             {
                 if (progress > 0.0) {
                     impl->m_VariableToProgress[variable] = progress;
                 }
                 else {
                     impl->m_VariableToProgress.erase(variable);
                 }
                 auto modelIndex = createIndex(impl->indexOfVariable(variable.get()), NAME_COLUMN);
                 emit dataChanged(modelIndex, modelIndex);
             }
             int VariableModel::columnCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return NB_COLUMNS;
             }
             int VariableModel::rowCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return impl->m_Variables.size();
             }
             QVariant VariableModel::data(const QModelIndex &index, int role) const
             {
                 if (!index.isValid()) {
                     return QVariant{};
                 }
                 if (index.row() < 0 || index.row() >= rowCount()) {
                     return QVariant{};
                 }
                 if (role == Qt::DisplayRole) {
                     if (auto variable = impl->m_Variables.at(index.row()).get()) {
                         /// Lambda function that builds the variant to return for a time value
                         auto dateTimeVariant = [](double secs) {
                             auto dateTime = DateUtils::dateTime(secs);
                             return dateTime.toString(DATETIME_FORMAT);
                         };
                         switch (index.column()) {
                             case NAME_COLUMN:
                                 return variable->name();
                             case TSTART_COLUMN:
-                                return dateTimeVariant(variable->dateTime().m_TStart);
+                                return dateTimeVariant(variable->range().m_TStart);
                             case TEND_COLUMN:
-                                return dateTimeVariant(variable->dateTime().m_TEnd);
+                                return dateTimeVariant(variable->range().m_TEnd);
                             default:
                                 // No action
                                 break;
                         }
                         qWarning(LOG_VariableModel())
                             << tr("Can't get data (unknown column %1)").arg(index.column());
                     }
                     else {
                         qWarning(LOG_VariableModel()) << tr("Can't get data (no variable)");
                     }
                 }
                 else if (role == VariableRoles::ProgressRole) {
                     if (auto variable = impl->m_Variables.at(index.row())) {
                         auto it = impl->m_VariableToProgress.find(variable);
                         if (it != impl->m_VariableToProgress.cend()) {
                             return it->second;
                         }
                     }
                 }
                 return QVariant{};
             }
             QVariant VariableModel::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (role != Qt::DisplayRole && role != Qt::SizeHintRole) {
                     return QVariant{};
                 }
                 if (orientation == Qt::Horizontal) {
                     auto propertiesIt = COLUMN_PROPERTIES.find(section);
                     if (propertiesIt != COLUMN_PROPERTIES.cend()) {
                         // Role is either DisplayRole or SizeHintRole
                         return (role == Qt::DisplayRole)
                                    ? QVariant{propertiesIt->m_Name}
                                    : QVariant{QSize{propertiesIt->m_Width, propertiesIt->m_Height}};
                     }
                     else {
                         qWarning(LOG_VariableModel())
                             << tr("Can't get header data (unknown column %1)").arg(section);
                     }
                 }
                 return QVariant{};
             }
             void VariableModel::abortProgress(const QModelIndex &index)
             {
                 if (auto variable = impl->m_Variables.at(index.row())) {
                     emit abortProgessRequested(variable);
                 }
             }
             void VariableModel::onVariableUpdated() noexcept
             {
                 // Finds variable that has been updated in the model
                 if (auto updatedVariable = dynamic_cast<Variable *>(sender())) {
                     auto updatedVariableIndex = impl->indexOfVariable(updatedVariable);
                     if (updatedVariableIndex > -1) {
                         emit dataChanged(createIndex(updatedVariableIndex, 0),
                                          createIndex(updatedVariableIndex, columnCount() - 1));
                     }
                 }
             }
             int VariableModel::VariableModelPrivate::indexOfVariable(Variable *variable) const noexcept
             {
                 auto begin = std::cbegin(m_Variables);
                 auto end = std::cend(m_Variables);
                 auto it
                     = std::find_if(begin, end, [variable](const auto &var) { return var.get() == variable; });
                 if (it != end) {
                     // Gets the index of the variable in the model: we assume here that views have the same
                     // order as the model
                     return std::distance(begin, it);
                 }
                 else {
                     return -1;
                 }
             }

core/tests/Data/TestOneDimArrayData.cpp +2 -2

             #include "Data/ArrayData.h"
             #include <QObject>
             #include <QtTest>
             class TestOneDimArrayData : public QObject {
                 Q_OBJECT
             private slots:
                 /// Tests @sa ArrayData::data()
                 void testData_data();
                 void testData();
                 /// Tests @sa ArrayData::data(int componentIndex)
                 void testDataByComponentIndex_data();
                 void testDataByComponentIndex();
                 /// Tests @sa ArrayData::add()
                 void testAdd_data();
                 void testAdd();
                 /// Tests @sa ArrayData::at(int index)
                 void testAt_data();
                 void testAt();
                 /// Tests @sa ArrayData::clear()
                 void testClear_data();
                 void testClear();
                 /// Tests @sa ArrayData::size()
                 void testSize_data();
                 void testSize();
                 /// Tests @sa ArrayData::sort()
                 void testSort_data();
                 void testSort();
             };
             void TestOneDimArrayData::testData_data()
             {
                 // Test structure
                 QTest::addColumn<QVector<double> >("inputData");    // array's data input
                 QTest::addColumn<QVector<double> >("expectedData"); // expected data
                 // Test cases
                 QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.}
                                        << QVector<double>{1., 2., 3., 4., 5.};
             }
             void TestOneDimArrayData::testData()
             {
                 QFETCH(QVector<double>, inputData);
                 QFETCH(QVector<double>, expectedData);
                 ArrayData<1> arrayData{inputData};
                 QVERIFY(arrayData.data() == expectedData);
             }
             void TestOneDimArrayData::testDataByComponentIndex_data()
             {
                 // Test structure
                 QTest::addColumn<QVector<double> >("inputData");    // array data's input
                 QTest::addColumn<int>("componentIndex");            // component index to test
                 QTest::addColumn<QVector<double> >("expectedData"); // expected data
                 // Test cases
                 QTest::newRow("validIndex") << QVector<double>{1., 2., 3., 4., 5.} << 0
                                             << QVector<double>{1., 2., 3., 4., 5.};
-                QTest::newRow("invalidIndex1")
+                QTest::newRow("invalidIndex1") << QVector<double>{1., 2., 3., 4., 5.} << -1
-                    << QVector<double>{1., 2., 3., 4., 5.} << -1 << QVector<double>{};
+                                               << QVector<double>{};
                 QTest::newRow("invalidIndex2") << QVector<double>{1., 2., 3., 4., 5.} << 1 << QVector<double>{};
             }
             void TestOneDimArrayData::testDataByComponentIndex()
             {
                 QFETCH(QVector<double>, inputData);
                 QFETCH(int, componentIndex);
                 QFETCH(QVector<double>, expectedData);
                 ArrayData<1> arrayData{inputData};
                 QVERIFY(arrayData.data(componentIndex) == expectedData);
             }
             void TestOneDimArrayData::testAdd_data()
             {
                 // Test structure
                 QTest::addColumn<QVector<double> >("inputData");    // array's data input
                 QTest::addColumn<QVector<double> >("otherData");    // array data's input to merge with
                 QTest::addColumn<bool>("prepend");                  // prepend or append merge
                 QTest::addColumn<QVector<double> >("expectedData"); // expected data after merge
                 // Test cases
                 QTest::newRow("appendMerge") << QVector<double>{1., 2., 3., 4., 5.}
                                              << QVector<double>{6., 7., 8.} << false
                                              << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8.};
                 QTest::newRow("prependMerge") << QVector<double>{1., 2., 3., 4., 5.}
                                               << QVector<double>{6., 7., 8.} << true
                                               << QVector<double>{6., 7., 8., 1., 2., 3., 4., 5.};
             }
             void TestOneDimArrayData::testAdd()
             {
                 QFETCH(QVector<double>, inputData);
                 QFETCH(QVector<double>, otherData);
                 QFETCH(bool, prepend);
                 QFETCH(QVector<double>, expectedData);
                 ArrayData<1> arrayData{inputData};
                 ArrayData<1> other{otherData};
                 arrayData.add(other, prepend);
                 QVERIFY(arrayData.data() == expectedData);
             }
             void TestOneDimArrayData::testAt_data()
             {
                 // Test structure
                 QTest::addColumn<QVector<double> >("inputData"); // array data's input
                 QTest::addColumn<int>("index");                  // index to retrieve data
                 QTest::addColumn<double>("expectedData");        // expected data at index
                 // Test cases
                 QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << 0 << 1.;
                 QTest::newRow("data2") << QVector<double>{1., 2., 3., 4., 5.} << 3 << 4.;
             }
             void TestOneDimArrayData::testAt()
             {
                 QFETCH(QVector<double>, inputData);
                 QFETCH(int, index);
                 QFETCH(double, expectedData);
                 ArrayData<1> arrayData{inputData};
                 QVERIFY(arrayData.at(index) == expectedData);
             }
             void TestOneDimArrayData::testClear_data()
             {
                 // Test structure
                 QTest::addColumn<QVector<double> >("inputData"); // array data's input
                 // Test cases
                 QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.};
             }
             void TestOneDimArrayData::testClear()
             {
                 QFETCH(QVector<double>, inputData);
                 ArrayData<1> arrayData{inputData};
                 arrayData.clear();
                 QVERIFY(arrayData.data() == QVector<double>{});
             }
             void TestOneDimArrayData::testSize_data()
             {
                 // Test structure
                 QTest::addColumn<QVector<double> >("inputData"); // array data's input
                 QTest::addColumn<int>("expectedSize");           // expected array data size
                 // Test cases
                 QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << 5;
             }
             void TestOneDimArrayData::testSize()
             {
                 QFETCH(QVector<double>, inputData);
                 QFETCH(int, expectedSize);
                 ArrayData<1> arrayData{inputData};
                 QVERIFY(arrayData.size() == expectedSize);
             }
             void TestOneDimArrayData::testSort_data()
             {
                 // Test structure
                 QTest::addColumn<QVector<double> >("inputData");        // array data's input
                 QTest::addColumn<std::vector<int> >("sortPermutation"); // permutation used to sort data
                 QTest::addColumn<QVector<double> >("expectedData");     // expected data after sorting
                 // Test cases
                 QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << std::vector<int>{0, 2, 3, 1, 4}
                                        << QVector<double>{1., 3., 4., 2., 5.};
                 QTest::newRow("data2") << QVector<double>{1., 2., 3., 4., 5.} << std::vector<int>{4, 1, 2, 3, 0}
                                        << QVector<double>{5., 2., 3., 4., 1.};
             }
             void TestOneDimArrayData::testSort()
             {
                 QFETCH(QVector<double>, inputData);
                 QFETCH(std::vector<int>, sortPermutation);
                 QFETCH(QVector<double>, expectedData);
                 ArrayData<1> arrayData{inputData};
                 auto sortedArrayData = arrayData.sort(sortPermutation);
                 QVERIFY(sortedArrayData != nullptr);
                 QVERIFY(sortedArrayData->data() == expectedData);
             }
             QTEST_MAIN(TestOneDimArrayData)
             #include "TestOneDimArrayData.moc"

core/tests/Data/TestTwoDimArrayData.cpp +2 -2

             #include "Data/ArrayData.h"
             #include <QObject>
             #include <QtTest>
             using DataContainer = QVector<QVector<double> >;
             class TestTwoDimArrayData : public QObject {
                 Q_OBJECT
             private slots:
                 /// Tests @sa ArrayData::data(int componentIndex)
                 void testDataByComponentIndex_data();
                 void testDataByComponentIndex();
                 /// Tests @sa ArrayData ctor
                 void testCtor_data();
                 void testCtor();
                 /// Tests @sa ArrayData::add()
                 void testAdd_data();
                 void testAdd();
                 /// Tests @sa ArrayData::clear()
                 void testClear_data();
                 void testClear();
                 /// Tests @sa ArrayData::size()
                 void testSize_data();
                 void testSize();
                 /// Tests @sa ArrayData::sort()
                 void testSort_data();
                 void testSort();
             };
             void TestTwoDimArrayData::testDataByComponentIndex_data()
             {
                 // Test structure
                 QTest::addColumn<DataContainer>("inputData");       // array data's input
                 QTest::addColumn<int>("componentIndex");            // component index to test
                 QTest::addColumn<QVector<double> >("expectedData"); // expected data
                 // Test cases
                 auto inputData
                     = DataContainer{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}};
                 QTest::newRow("validIndex1") << inputData << 0 << QVector<double>{1., 2., 3., 4., 5.};
                 QTest::newRow("validIndex2") << inputData << 1 << QVector<double>{6., 7., 8., 9., 10.};
                 QTest::newRow("validIndex3") << inputData << 2 << QVector<double>{11., 12., 13., 14., 15.};
                 QTest::newRow("invalidIndex1") << inputData << -1 << QVector<double>{};
                 QTest::newRow("invalidIndex2") << inputData << 3 << QVector<double>{};
             }
             void TestTwoDimArrayData::testDataByComponentIndex()
             {
                 QFETCH(DataContainer, inputData);
                 QFETCH(int, componentIndex);
                 QFETCH(QVector<double>, expectedData);
                 ArrayData<2> arrayData{inputData};
                 QVERIFY(arrayData.data(componentIndex) == expectedData);
             }
             void TestTwoDimArrayData::testCtor_data()
             {
                 // Test structure
                 QTest::addColumn<DataContainer>("inputData");    // array data's input
                 QTest::addColumn<bool>("success");               // array data has been successfully constructed
                 QTest::addColumn<DataContainer>("expectedData"); // expected array data (when success)
                 // Test cases
                 QTest::newRow("validInput")
                     << DataContainer{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}}
                     << true
                     << DataContainer{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}};
                 QTest::newRow("malformedInput (components of the array data haven't the same size")
                     << DataContainer{{1., 2., 3., 4., 5.}, {6., 7., 8.}, {11., 12.}} << true
                     << DataContainer{{}, {}, {}};
-                QTest::newRow("invalidInput (less than tow components")
+                QTest::newRow("invalidInput (less than tow components") << DataContainer{{1., 2., 3., 4., 5.}}
-                    << DataContainer{{1., 2., 3., 4., 5.}} << false << DataContainer{{}, {}, {}};
+                                                                        << false << DataContainer{{}, {}, {}};
             }
             void TestTwoDimArrayData::testCtor()
             {
                 QFETCH(DataContainer, inputData);
                 QFETCH(bool, success);
                 if (success) {
                     QFETCH(DataContainer, expectedData);
                     ArrayData<2> arrayData{inputData};
                     for (auto i = 0; i < expectedData.size(); ++i) {
                         QVERIFY(arrayData.data(i) == expectedData.at(i));
                     }
                 }
                 else {
                     QVERIFY_EXCEPTION_THROWN(ArrayData<2> arrayData{inputData}, std::invalid_argument);
                 }
             }
             void TestTwoDimArrayData::testAdd_data()
             {
                 // Test structure
                 QTest::addColumn<DataContainer>("inputData");    // array's data input
                 QTest::addColumn<DataContainer>("otherData");    // array data's input to merge with
                 QTest::addColumn<bool>("prepend");               // prepend or append merge
                 QTest::addColumn<DataContainer>("expectedData"); // expected data after merge
                 // Test cases
                 auto inputData
                     = DataContainer{{1., 2., 3., 4., 5.}, {11., 12., 13., 14., 15.}, {21., 22., 23., 24., 25.}};
                 auto vectorContainer = DataContainer{{6., 7., 8.}, {16., 17., 18.}, {26., 27., 28}};
                 auto tensorContainer = DataContainer{{6., 7., 8.},    {16., 17., 18.}, {26., 27., 28},
                                                      {36., 37., 38.}, {46., 47., 48.}, {56., 57., 58}};
                 QTest::newRow("appendMerge") << inputData << vectorContainer << false
                                              << DataContainer{{1., 2., 3., 4., 5., 6., 7., 8.},
                                                               {11., 12., 13., 14., 15., 16., 17., 18.},
                                                               {21., 22., 23., 24., 25., 26., 27., 28}};
                 QTest::newRow("prependMerge") << inputData << vectorContainer << true
                                               << DataContainer{{6., 7., 8., 1., 2., 3., 4., 5.},
                                                                {16., 17., 18., 11., 12., 13., 14., 15.},
                                                                {26., 27., 28, 21., 22., 23., 24., 25.}};
                 QTest::newRow("invalidMerge") << inputData << tensorContainer << false << inputData;
             }
             void TestTwoDimArrayData::testAdd()
             {
                 QFETCH(DataContainer, inputData);
                 QFETCH(DataContainer, otherData);
                 QFETCH(bool, prepend);
                 QFETCH(DataContainer, expectedData);
                 ArrayData<2> arrayData{inputData};
                 ArrayData<2> other{otherData};
                 arrayData.add(other, prepend);
                 for (auto i = 0; i < expectedData.size(); ++i) {
                     QVERIFY(arrayData.data(i) == expectedData.at(i));
                 }
             }
             void TestTwoDimArrayData::testClear_data()
             {
                 // Test structure
                 QTest::addColumn<DataContainer>("inputData"); // array data's input
                 // Test cases
                 QTest::newRow("data1") << DataContainer{
                     {1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}};
             }
             void TestTwoDimArrayData::testClear()
             {
                 QFETCH(DataContainer, inputData);
                 ArrayData<2> arrayData{inputData};
                 arrayData.clear();
                 for (auto i = 0; i < inputData.size(); ++i) {
                     QVERIFY(arrayData.data(i) == QVector<double>{});
                 }
             }
             void TestTwoDimArrayData::testSize_data()
             {
                 // Test structure
                 QTest::addColumn<QVector<QVector<double> > >("inputData"); // array data's input
                 QTest::addColumn<int>("expectedSize");                     // expected array data size
                 // Test cases
                 QTest::newRow("data1") << DataContainer{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}} << 5;
                 QTest::newRow("data2") << DataContainer{{1., 2., 3., 4., 5.},
                                                         {6., 7., 8., 9., 10.},
                                                         {11., 12., 13., 14., 15.}}
                                        << 5;
             }
             void TestTwoDimArrayData::testSize()
             {
                 QFETCH(DataContainer, inputData);
                 QFETCH(int, expectedSize);
                 ArrayData<2> arrayData{inputData};
                 QVERIFY(arrayData.size() == expectedSize);
             }
             void TestTwoDimArrayData::testSort_data()
             {
                 // Test structure
                 QTest::addColumn<DataContainer>("inputData");           // array data's input
                 QTest::addColumn<std::vector<int> >("sortPermutation"); // permutation used to sort data
                 QTest::addColumn<DataContainer>("expectedData");        // expected data after sorting
                 // Test cases
                 QTest::newRow("data1")
                     << DataContainer{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}}
                     << std::vector<int>{0, 2, 3, 1, 4}
                     << DataContainer{{1., 3., 4., 2., 5.}, {6., 8., 9., 7., 10.}, {11., 13., 14., 12., 15.}};
                 QTest::newRow("data2")
                     << DataContainer{{1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, {11., 12., 13., 14., 15.}}
                     << std::vector<int>{2, 4, 3, 0, 1}
                     << DataContainer{{3., 5., 4., 1., 2.}, {8., 10., 9., 6., 7.}, {13., 15., 14., 11., 12.}};
             }
             void TestTwoDimArrayData::testSort()
             {
                 QFETCH(DataContainer, inputData);
                 QFETCH(std::vector<int>, sortPermutation);
                 QFETCH(DataContainer, expectedData);
                 ArrayData<2> arrayData{inputData};
                 auto sortedArrayData = arrayData.sort(sortPermutation);
                 QVERIFY(sortedArrayData != nullptr);
                 for (auto i = 0; i < expectedData.size(); ++i) {
                     QVERIFY(sortedArrayData->data(i) == expectedData.at(i));
                 }
             }
             QTEST_MAIN(TestTwoDimArrayData)
             #include "TestTwoDimArrayData.moc"

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

             #ifndef SCIQLOP_VISUALIZATIONGRAPHHELPER_H
             #define SCIQLOP_VISUALIZATIONGRAPHHELPER_H
             #include <Data/SqpRange.h>
             #include <QLoggingCategory>
             #include <QVector>
             #include <memory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphHelper)
             class IDataSeries;
             class QCPAbstractPlottable;
             class QCustomPlot;
             class Variable;
             /**
              * @brief The VisualizationGraphHelper class aims to create the QCustomPlot components relative to a
              * variable, depending on the data series of this variable
              */
             struct VisualizationGraphHelper {
                 /**
                  * Creates (if possible) the QCustomPlot components relative to the variable passed in
                  * parameter, and adds these to the plot passed in parameter.
                  * @param variable the variable for which to create the components
                  * @param plot the plot in which to add the created components. It takes ownership of these
                  * components.
                  * @return the list of the components created
                  */
                 static QVector<QCPAbstractPlottable *> create(std::shared_ptr<Variable> variable,
                                                               QCustomPlot &plot) noexcept;
-                static void updateData(QVector<QCPAbstractPlottable *> plotableVect, IDataSeries *dataSeries,
+                static void updateData(QVector<QCPAbstractPlottable *> plotableVect,
-                                       const SqpRange &dateTime);
+                                       std::shared_ptr<IDataSeries> dataSeries, const SqpRange &dateTime);
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHHELPER_H

gui/include/Visualization/VisualizationGraphWidget.h +8 -9

             #ifndef SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
             #include <memory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphWidget)
             class QCPRange;
             class SqpRange;
             class Variable;
-            /**
-             * Possible types of zoom operation
-             */
-            enum class VisualizationGraphWidgetZoomType { ZoomOut, ZoomIn, PanRight, PanLeft, Unknown };
             namespace Ui {
             class VisualizationGraphWidget;
             } // namespace Ui
             class VisualizationGraphWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationGraphWidget();
-                void enableSynchronize(bool enable);
+                /// If acquisition isn't enable, requestDataLoading signal cannot be emit
+                void enableAcquisition(bool enable);
                 void addVariable(std::shared_ptr<Variable> variable);
                 void addVariableUsingGraph(std::shared_ptr<Variable> variable);
                 /// Removes a variable from the graph
                 void removeVariable(std::shared_ptr<Variable> variable) noexcept;
                 void setRange(std::shared_ptr<Variable> variable, const SqpRange &range);
                 SqpRange graphRange() const noexcept;
                 void setGraphRange(const SqpRange &range);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
                 bool contains(const Variable &variable) const override;
                 QString name() const override;
             signals:
-                void requestDataLoading(std::shared_ptr<Variable> variable, const SqpRange &dateTime);
+                void synchronize(const SqpRange &range, const SqpRange &oldRange);
-                void synchronize(const SqpRange &dateTime, const SqpRange &oldDateTime,
+                void requestDataLoading(QVector<std::shared_ptr<Variable> > variable, const SqpRange &range,
-                                 VisualizationGraphWidgetZoomType zoomType);
+                                        const SqpRange &oldRange, bool synchronise);
+                void variableAdded(std::shared_ptr<Variable> var);
             private:
                 Ui::VisualizationGraphWidget *ui;
                 class VisualizationGraphWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
             private slots:
                 /// Slot called when right clicking on the graph (displays a menu)
                 void onGraphMenuRequested(const QPoint &pos) noexcept;
                 /// Rescale the X axe to range parameter
                 void onRangeChanged(const QCPRange &t1, const QCPRange &t2);
                 /// Slot called when a mouse move was made
                 void onMouseMove(QMouseEvent *event) noexcept;
                 /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
                 void onMouseWheel(QWheelEvent *event) noexcept;
                 /// Slot called when a mouse press was made, to activate the calibration of a graph
                 void onMousePress(QMouseEvent *event) noexcept;
                 /// Slot called when a mouse release was made, to deactivate the calibration of a graph
                 void onMouseRelease(QMouseEvent *event) noexcept;
                 void onDataCacheVariableUpdated();
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H

gui/include/Visualization/VisualizationZoneWidget.h +11 0

             #ifndef SCIQLOP_VISUALIZATIONZONEWIDGET_H
             #define SCIQLOP_VISUALIZATIONZONEWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
+            #include <memory>
+            #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationZoneWidget)
             namespace Ui {
             class VisualizationZoneWidget;
             } // Ui
             class Variable;
             class VisualizationGraphWidget;
             class VisualizationZoneWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationZoneWidget();
                 /// Add a graph widget
                 void addGraph(VisualizationGraphWidget *graphWidget);
                 /**
                  * Creates a graph using a variable. The variable will be displayed in the new graph.
                  * @param variable the variable for which to create the graph
                  * @return the pointer to the created graph
                  */
                 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
                 bool contains(const Variable &variable) const override;
                 QString name() const override;
+            private slots:
+                void onVariableAdded(std::shared_ptr<Variable> variable);
             private:
                 Ui::VisualizationZoneWidget *ui;
+                class VisualizationZoneWidgetPrivate;
+                spimpl::unique_impl_ptr<VisualizationZoneWidgetPrivate> impl;
             };
             #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H

gui/src/SqpApplication.cpp +1 -1

             #include "SqpApplication.h"
             #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
             #include <Network/NetworkController.h>
             #include <QThread>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/VisualizationController.h>
             Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
             class SqpApplication::SqpApplicationPrivate {
             public:
                 SqpApplicationPrivate()
                         : m_DataSourceController{std::make_unique<DataSourceController>()},
                           m_NetworkController{std::make_unique<NetworkController>()},
                           m_TimeController{std::make_unique<TimeController>()},
                           m_VariableController{std::make_unique<VariableController>()},
                           m_VisualizationController{std::make_unique<VisualizationController>()}
                 {
                     // /////////////////////////////// //
                     // Connections between controllers //
                     // /////////////////////////////// //
                     // VariableController <-> DataSourceController
                     connect(m_DataSourceController.get(),
                             SIGNAL(variableCreationRequested(const QString &, const QVariantHash &,
                                                              std::shared_ptr<IDataProvider>)),
                             m_VariableController.get(),
                             SLOT(createVariable(const QString &, const QVariantHash &,
                                                 std::shared_ptr<IDataProvider>)));
                     // VariableController <-> VisualizationController
                     connect(m_VariableController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
                             m_VisualizationController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
                     connect(m_VariableController.get(),
                             SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)),
                             m_VisualizationController.get(),
                             SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)));
                     m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
                     m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
                     m_NetworkController->moveToThread(&m_NetworkControllerThread);
                     m_NetworkControllerThread.setObjectName("NetworkControllerThread");
                     m_VariableController->moveToThread(&m_VariableControllerThread);
                     m_VariableControllerThread.setObjectName("VariableControllerThread");
                     m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
                     m_VisualizationControllerThread.setObjectName("VsualizationControllerThread");
                     // Additionnal init
                     m_VariableController->setTimeController(m_TimeController.get());
                 }
                 virtual ~SqpApplicationPrivate()
                 {
-                    qCInfo(LOG_SqpApplication()) << tr("SqpApplicationPrivate destruction");
+                    qCDebug(LOG_SqpApplication()) << tr("SqpApplicationPrivate destruction");
                     m_DataSourceControllerThread.quit();
                     m_DataSourceControllerThread.wait();
                     m_NetworkControllerThread.quit();
                     m_NetworkControllerThread.wait();
                     m_VariableControllerThread.quit();
                     m_VariableControllerThread.wait();
                     m_VisualizationControllerThread.quit();
                     m_VisualizationControllerThread.wait();
                 }
                 std::unique_ptr<DataSourceController> m_DataSourceController;
                 std::unique_ptr<VariableController> m_VariableController;
                 std::unique_ptr<TimeController> m_TimeController;
                 std::unique_ptr<NetworkController> m_NetworkController;
                 std::unique_ptr<VisualizationController> m_VisualizationController;
                 QThread m_DataSourceControllerThread;
                 QThread m_NetworkControllerThread;
                 QThread m_VariableControllerThread;
                 QThread m_VisualizationControllerThread;
             };
             SqpApplication::SqpApplication(int &argc, char **argv)
                     : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
             {
                 qCDebug(LOG_SqpApplication()) << tr("SqpApplication construction") << QThread::currentThread();
                 connect(&impl->m_DataSourceControllerThread, &QThread::started,
                         impl->m_DataSourceController.get(), &DataSourceController::initialize);
                 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
                         impl->m_DataSourceController.get(), &DataSourceController::finalize);
                 connect(&impl->m_NetworkControllerThread, &QThread::started, impl->m_NetworkController.get(),
                         &NetworkController::initialize);
                 connect(&impl->m_NetworkControllerThread, &QThread::finished, impl->m_NetworkController.get(),
                         &NetworkController::finalize);
                 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
                         &VariableController::initialize);
                 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
                         &VariableController::finalize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::started,
                         impl->m_VisualizationController.get(), &VisualizationController::initialize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
                         impl->m_VisualizationController.get(), &VisualizationController::finalize);
                 impl->m_DataSourceControllerThread.start();
                 impl->m_NetworkControllerThread.start();
                 impl->m_VariableControllerThread.start();
                 impl->m_VisualizationControllerThread.start();
             }
             SqpApplication::~SqpApplication()
             {
             }
             void SqpApplication::initialize()
             {
             }
             DataSourceController &SqpApplication::dataSourceController() noexcept
             {
                 return *impl->m_DataSourceController;
             }
             NetworkController &SqpApplication::networkController() noexcept
             {
                 return *impl->m_NetworkController;
             }
             TimeController &SqpApplication::timeController() noexcept
             {
                 return *impl->m_TimeController;
             }
             VariableController &SqpApplication::variableController() noexcept
             {
                 return *impl->m_VariableController;
             }
             VisualizationController &SqpApplication::visualizationController() noexcept
             {
                 return *impl->m_VisualizationController;
             }

gui/src/Visualization/VisualizationGraphHelper.cpp +18 -17

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
             #include <Data/ScalarSeries.h>
             #include <Variable/Variable.h>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
             namespace {
             class SqpDataContainer : public QCPGraphDataContainer {
             public:
                 void appendGraphData(const QCPGraphData &data) { mData.append(data); }
             };
             /// Format for datetimes on a axis
             const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
             /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
             /// non-time data
             QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
             {
                 if (isTimeAxis) {
                     auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
                     dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
                     dateTicker->setDateTimeSpec(Qt::UTC);
                     return dateTicker;
                 }
                 else {
                     // default ticker
                     return QSharedPointer<QCPAxisTicker>::create();
                 }
             }
-            void updateScalarData(QCPAbstractPlottable *component, ScalarSeries &scalarSeries,
+            void updateScalarData(QCPAbstractPlottable *component, std::shared_ptr<ScalarSeries> scalarSeries,
                                   const SqpRange &dateTime)
             {
                 qCDebug(LOG_VisualizationGraphHelper()) << "TORM: updateScalarData"
                                                         << QThread::currentThread()->objectName();
                 if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
-                    scalarSeries.lockRead();
+                    scalarSeries->lockRead();
                     {
-                        const auto &xData = scalarSeries.xAxisData()->cdata();
+                        const auto &xData = scalarSeries->xAxisData()->cdata();
-                        const auto &valuesData = scalarSeries.valuesData()->cdata();
+                        const auto &valuesData = scalarSeries->valuesData()->cdata();
                         auto xDataBegin = xData.cbegin();
                         auto xDataEnd = xData.cend();
-                        qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points in cache"
+                        qCInfo(LOG_VisualizationGraphHelper()) << "TODEBUG: Current points in cache"
                                                                << xData.count();
                         auto sqpDataContainer = QSharedPointer<SqpDataContainer>::create();
                         qcpGraph->setData(sqpDataContainer);
                         auto lowerIt = std::lower_bound(xDataBegin, xDataEnd, dateTime.m_TStart);
                         auto upperIt = std::upper_bound(xDataBegin, xDataEnd, dateTime.m_TEnd);
                         auto distance = std::distance(xDataBegin, lowerIt);
                         auto valuesDataIt = valuesData.cbegin() + distance;
                         for (auto xAxisDataIt = lowerIt; xAxisDataIt != upperIt;
                              ++xAxisDataIt, ++valuesDataIt) {
                             sqpDataContainer->appendGraphData(QCPGraphData(*xAxisDataIt, *valuesDataIt));
                         }
-                        qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points displayed"
+                        qCInfo(LOG_VisualizationGraphHelper()) << "TODEBUG: Current points displayed"
                                                                << sqpDataContainer->size();
                     }
-                    scalarSeries.unlock();
+                    scalarSeries->unlock();
                     // Display all data
                     component->parentPlot()->replot();
                 }
                 else {
                     /// @todo DEBUG
                 }
             }
-            QCPAbstractPlottable *createScalarSeriesComponent(ScalarSeries &scalarSeries, QCustomPlot &plot,
+            QCPAbstractPlottable *createScalarSeriesComponent(std::shared_ptr<ScalarSeries> scalarSeries,
-                                                              const SqpRange &dateTime)
+                                                              QCustomPlot &plot, const SqpRange &dateTime)
             {
                 auto component = plot.addGraph();
                 if (component) {
                     //        // Graph data
-                    component->setData(scalarSeries.xAxisData()->data(), scalarSeries.valuesData()->data(),
+                    component->setData(scalarSeries->xAxisData()->data(), scalarSeries->valuesData()->data(),
                                        true);
                     updateScalarData(component, scalarSeries, dateTime);
                     // Axes properties
                     /// @todo : for the moment, no control is performed on the axes: the units and the tickers
                     /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
                     auto setAxisProperties = [](auto axis, const auto &unit) {
                         // label (unit name)
                         axis->setLabel(unit.m_Name);
                         // ticker (depending on the type of unit)
                         axis->setTicker(axisTicker(unit.m_TimeUnit));
                     };
-                    setAxisProperties(plot.xAxis, scalarSeries.xAxisUnit());
+                    setAxisProperties(plot.xAxis, scalarSeries->xAxisUnit());
-                    setAxisProperties(plot.yAxis, scalarSeries.valuesUnit());
+                    setAxisProperties(plot.yAxis, scalarSeries->valuesUnit());
                     // Display all data
                     component->rescaleAxes();
                     plot.replot();
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph for the scalar series");
                 }
                 return component;
             }
             } // namespace
             QVector<QCPAbstractPlottable *> VisualizationGraphHelper::create(std::shared_ptr<Variable> variable,
                                                                              QCustomPlot &plot) noexcept
             {
                 auto result = QVector<QCPAbstractPlottable *>{};
                 if (variable) {
                     // Gets the data series of the variable to call the creation of the right components
                     // according to its type
-                    if (auto scalarSeries = dynamic_cast<ScalarSeries *>(variable->dataSeries())) {
+                    if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(variable->dataSeries())) {
-                        result.append(createScalarSeriesComponent(*scalarSeries, plot, variable->dateTime()));
+                        result.append(createScalarSeriesComponent(scalarSeries, plot, variable->range()));
                     }
                     else {
                         qCDebug(LOG_VisualizationGraphHelper())
                             << QObject::tr("Can't create graph plottables : unmanaged data series type");
                     }
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                 }
                 return result;
             }
             void VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *> plotableVect,
-                                                      IDataSeries *dataSeries, const SqpRange &dateTime)
+                                                      std::shared_ptr<IDataSeries> dataSeries,
+                                                      const SqpRange &dateTime)
             {
-                if (auto scalarSeries = dynamic_cast<ScalarSeries *>(dataSeries)) {
+                if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
                     if (plotableVect.size() == 1) {
-                        updateScalarData(plotableVect.at(0), *scalarSeries, dateTime);
+                        updateScalarData(plotableVect.at(0), scalarSeries, dateTime);
                     }
                     else {
                         qCCritical(LOG_VisualizationGraphHelper()) << QObject::tr(
                             "Can't update Data of a scalarSeries because there is not only one component "
                             "associated");
                     }
                 }
                 else {
                     /// @todo DEBUG
                 }
             }

gui/src/Visualization/VisualizationGraphWidget.cpp +36 -156

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
             namespace {
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
-            /// Gets a tolerance value from application settings. If the setting can't be found, the default
-            /// value passed in parameter is returned
-            double toleranceValue(const QString &key, double defaultValue) noexcept
-                return QSettings{}.value(key, defaultValue).toDouble();
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                 explicit VisualizationGraphWidgetPrivate()
-                        : m_DoSynchronize{true}, m_IsCalibration{false}, m_RenderingDelegate{nullptr}
+                        : m_DoAcquisition{true}, m_IsCalibration{false}, m_RenderingDelegate{nullptr}
                 {
                 }
-                // Return the operation when range changed
-                VisualizationGraphWidgetZoomType getZoomType(const QCPRange &t1, const QCPRange &t2);
                 // 1 variable -> n qcpplot
                 std::multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMultiMap;
-                bool m_DoSynchronize;
+                bool m_DoAcquisition;
                 bool m_IsCalibration;
                 QCPItemTracer *m_TextTracer;
                 /// Delegate used to attach rendering features to the plot
                 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 // The delegate must be initialized after the ui as it uses the plot
                 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*ui->widget);
                 ui->graphNameLabel->setText(name);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationGraphWidget::close);
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                 // Set qcpplot properties :
                 // - Drag (on x-axis) and zoom are enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
                 connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
                 connect(ui->widget, &QCustomPlot::mouseRelease, this,
                         &VisualizationGraphWidget::onMouseRelease);
                 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
                 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
                 connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
                                                &QCPAxis::rangeChanged),
                         this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
                 // Activates menu when right clicking on the graph
                 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
                         &VisualizationGraphWidget::onGraphMenuRequested);
                 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
                         &VariableController::onRequestDataLoading);
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
-            void VisualizationGraphWidget::enableSynchronize(bool enable)
+            void VisualizationGraphWidget::enableAcquisition(bool enable)
             {
-                impl->m_DoSynchronize = enable;
+                impl->m_DoAcquisition = enable;
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
             {
+                auto calibrationState = impl->m_IsCalibration;
+                impl->m_IsCalibration = true;
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
+                impl->m_IsCalibration = calibrationState;
                 for (auto createdPlottable : qAsConst(createdPlottables)) {
                     impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
                 }
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
+                emit variableAdded(variable);
             }
             void VisualizationGraphWidget::addVariableUsingGraph(std::shared_ptr<Variable> variable)
             {
-                // when adding a variable, we need to set its time range to the current graph range
-                auto grapheRange = ui->widget->xAxis->range();
-                auto dateTime = SqpRange{grapheRange.lower, grapheRange.upper};
-                variable->setDateTime(dateTime);
-                auto variableDateTimeWithTolerance = dateTime;
-                // add tolerance for each side
-                auto toleranceFactor
-                    = toleranceValue(GENERAL_TOLERANCE_AT_INIT_KEY, GENERAL_TOLERANCE_AT_INIT_DEFAULT_VALUE);
-                auto tolerance = toleranceFactor * (dateTime.m_TEnd - dateTime.m_TStart);
-                variableDateTimeWithTolerance.m_TStart -= tolerance;
-                variableDateTimeWithTolerance.m_TEnd += tolerance;
                 // Uses delegate to create the qcpplot components according to the variable
-                auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
+                this->addVariable(variable);
-                for (auto createdPlottable : qAsConst(createdPlottables)) {
-                    impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
-                connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
+                // Request range for the variable
+                auto graphRange = ui->widget->xAxis->range();
-                // CHangement detected, we need to ask controller to request data loading
+                emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable,
-                emit requestDataLoading(variable, variableDateTimeWithTolerance);
+                                        SqpRange{graphRange.lower, graphRange.upper}, variable->range(), false);
             }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 // Each component associated to the variable :
                 // - is removed from qcpplot (which deletes it)
                 // - is no longer referenced in the map
                 auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
                 for (auto it = componentsIt.first; it != componentsIt.second;) {
                     ui->widget->removePlottable(it->second);
                     it = impl->m_VariableToPlotMultiMap.erase(it);
                 }
                 // Updates graph
                 ui->widget->replot();
             }
             void VisualizationGraphWidget::setRange(std::shared_ptr<Variable> variable, const SqpRange &range)
             {
                 // Note: in case of different axes that depends on variable, we could start with a code like
                 // that:
                 //    auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
                 //    for (auto it = componentsIt.first; it != componentsIt.second;) {
                 //    }
                 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                 ui->widget->replot();
             }
             SqpRange VisualizationGraphWidget::graphRange() const noexcept
             {
                 auto grapheRange = ui->widget->xAxis->range();
                 return SqpRange{grapheRange.lower, grapheRange.upper};
             }
             void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
                 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                 ui->widget->replot();
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
             }
             void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visit(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationGraphWidget())
                         << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationGraphWidget::canDrop(const Variable &variable) const
             {
                 /// @todo : for the moment, a graph can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationGraphWidget::contains(const Variable &variable) const
             {
                 // Finds the variable among the keys of the map
                 auto variablePtr = &variable;
                 auto findVariable
                     = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
                 auto end = impl->m_VariableToPlotMultiMap.cend();
                 auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
                 return it != end;
             }
             QString VisualizationGraphWidget::name() const
             {
                 return ui->graphNameLabel->text();
             }
             void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
             {
                 QMenu graphMenu{};
                 // Iterates on variables (unique keys)
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
                           end = impl->m_VariableToPlotMultiMap.cend();
                      it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                     // 'Remove variable' action
                     graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
                                         [ this, var = it->first ]() { removeVariable(var); });
                 }
                 if (!graphMenu.isEmpty()) {
                     graphMenu.exec(mapToGlobal(pos));
                 }
             }
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
             {
-                qCInfo(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::onRangeChanged")
+                qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
-                                                       << QThread::currentThread()->objectName();
+                                                        << QThread::currentThread()->objectName() << "DoAcqui"
+                                                        << impl->m_DoAcquisition;
-                auto dateTimeRange = SqpRange{t1.lower, t1.upper};
+                auto graphRange = SqpRange{t1.lower, t1.upper};
+                auto oldGraphRange = SqpRange{t2.lower, t2.upper};
-                auto zoomType = impl->getZoomType(t1, t2);
+                if (impl->m_DoAcquisition) {
-                for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
+                    QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
-                     it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
-                    auto variable = it->first;
+                    for (auto it = impl->m_VariableToPlotMultiMap.begin(),
-                    auto currentDateTime = dateTimeRange;
+                              end = impl->m_VariableToPlotMultiMap.end();
+                         it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
-                    auto toleranceFactor = toleranceValue(GENERAL_TOLERANCE_AT_UPDATE_KEY,
+                        variableUnderGraphVector.push_back(it->first);
-                                                          GENERAL_TOLERANCE_AT_UPDATE_DEFAULT_VALUE);
-                    auto tolerance = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
-                    auto variableDateTimeWithTolerance = currentDateTime;
-                    variableDateTimeWithTolerance.m_TStart -= tolerance;
-                    variableDateTimeWithTolerance.m_TEnd += tolerance;
-                    qCDebug(LOG_VisualizationGraphWidget()) << "r" << currentDateTime;
-                    qCDebug(LOG_VisualizationGraphWidget()) << "t" << variableDateTimeWithTolerance;
-                    qCDebug(LOG_VisualizationGraphWidget()) << "v" << variable->dateTime();
-                    // If new range with tol is upper than variable datetime parameters. we need to request new
-                    // data
-                    if (!variable->contains(variableDateTimeWithTolerance)) {
-                        auto variableDateTimeWithTolerance = currentDateTime;
-                        if (!variable->isInside(currentDateTime)) {
-                            auto variableDateTime = variable->dateTime();
-                            if (variable->contains(variableDateTimeWithTolerance)) {
-                                qCDebug(LOG_VisualizationGraphWidget())
-                                    << tr("TORM: Detection zoom in that need request:");
-                                // add tolerance for each side
-                                tolerance
-                                    = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
-                                variableDateTimeWithTolerance.m_TStart -= tolerance;
-                                variableDateTimeWithTolerance.m_TEnd += tolerance;
-                            else if (variableDateTime.m_TStart < currentDateTime.m_TStart) {
-                                qCInfo(LOG_VisualizationGraphWidget()) << tr("TORM: Detection pan to right:");
-                                auto diffEndToKeepDelta = currentDateTime.m_TEnd - variableDateTime.m_TEnd;
-                                currentDateTime.m_TStart = variableDateTime.m_TStart + diffEndToKeepDelta;
-                                // Tolerance have to be added to the right
-                                // add tolerance for right (end) side
-                                tolerance
-                                    = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
-                                variableDateTimeWithTolerance.m_TEnd += tolerance;
-                            else if (variableDateTime.m_TEnd > currentDateTime.m_TEnd) {
-                                qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: Detection pan to left: ");
-                                auto diffStartToKeepDelta
-                                    = variableDateTime.m_TStart - currentDateTime.m_TStart;
-                                currentDateTime.m_TEnd = variableDateTime.m_TEnd - diffStartToKeepDelta;
-                                // Tolerance have to be added to the left
-                                // add tolerance for left (start) side
-                                tolerance
-                                    = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
-                                variableDateTimeWithTolerance.m_TStart -= tolerance;
-                            else {
-                                qCCritical(LOG_VisualizationGraphWidget())
-                                    << tr("Detection anormal zoom detection: ");
-                        else {
-                            qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: Detection zoom out: ");
-                            // add tolerance for each side
-                            tolerance = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
-                            variableDateTimeWithTolerance.m_TStart -= tolerance;
-                            variableDateTimeWithTolerance.m_TEnd += tolerance;
-                            zoomType = VisualizationGraphWidgetZoomType::ZoomOut;
-                        if (!variable->contains(dateTimeRange)) {
-                            qCDebug(LOG_VisualizationGraphWidget())
-                                << "TORM: Modif on variable datetime detected" << currentDateTime;
-                            variable->setDateTime(currentDateTime);
-                        qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: Request data detection: ");
-                        // CHangement detected, we need to ask controller to request data loading
-                        emit requestDataLoading(variable, variableDateTimeWithTolerance);
                     }
-                    else {
+                    emit requestDataLoading(std::move(variableUnderGraphVector), graphRange, oldGraphRange,
-                        qCInfo(LOG_VisualizationGraphWidget())
+                                            !impl->m_IsCalibration);
-                            << tr("TORM: Detection zoom in that doesn't need request: ");
-                        zoomType = VisualizationGraphWidgetZoomType::ZoomIn;
+                    if (!impl->m_IsCalibration) {
+                        qCDebug(LOG_VisualizationGraphWidget())
+                            << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
+                            << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
+                        emit synchronize(graphRange, oldGraphRange);
                     }
                 }
-                if (impl->m_DoSynchronize && !impl->m_IsCalibration) {
-                    auto oldDateTime = SqpRange{t2.lower, t2.upper};
-                    qCDebug(LOG_VisualizationGraphWidget())
-                        << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
-                        << QThread::currentThread()->objectName();
-                    emit synchronize(dateTimeRange, oldDateTime, zoomType);
             }
             void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
             {
                 // Handles plot rendering when mouse is moving
                 impl->m_RenderingDelegate->onMouseMove(event);
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto zoomOrientations = QFlags<Qt::Orientation>{};
                 // Lambda that enables a zoom orientation if the key modifier related to this orientation
                 // has
                 // been pressed
                 auto enableOrientation
                     = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
                           auto orientationEnabled = event->modifiers().testFlag(modifier);
                           zoomOrientations.setFlag(orientation, orientationEnabled);
                       };
                 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
                 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
                 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
             }
             void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
             {
                 impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
             }
             void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
             {
                 impl->m_IsCalibration = false;
             }
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
                 // NOTE:
                 //    We don't want to call the method for each component of a variable unitarily, but for
                 //    all
                 //    its components at once (eg its three components in the case of a vector).
                 //    The unordered_multimap does not do this easily, so the question is whether to:
                 //    - use an ordered_multimap and the algos of std to group the values by key
                 //    - use a map (unique keys) and store as values directly the list of components
                 auto grapheRange = ui->widget->xAxis->range();
                 auto dateTime = SqpRange{grapheRange.lower, grapheRange.upper};
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                      it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                     auto variable = it->first;
                     qCDebug(LOG_VisualizationGraphWidget())
-                        << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S"
+                        << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
-                        << variable->dateTime();
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
-                    if (dateTime.contains(variable->dateTime()) || dateTime.intersect(variable->dateTime())) {
+                    if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
                         VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
-                                                             variable->dataSeries(), variable->dateTime());
+                                                             variable->dataSeries(), variable->range());
                     }
                 }
             }
-            VisualizationGraphWidgetZoomType
-            VisualizationGraphWidget::VisualizationGraphWidgetPrivate::getZoomType(const QCPRange &t1,
-                                                                                   const QCPRange &t2)
-                // t1.lower <= t2.lower && t2.upper <= t1.upper
-                auto zoomType = VisualizationGraphWidgetZoomType::Unknown;
-                if (t1.lower <= t2.lower && t2.upper <= t1.upper) {
-                    zoomType = VisualizationGraphWidgetZoomType::ZoomOut;
-                else if (t1.lower > t2.lower && t1.upper > t2.upper) {
-                    zoomType = VisualizationGraphWidgetZoomType::PanRight;
-                else if (t1.lower < t2.lower && t1.upper < t2.upper) {
-                    zoomType = VisualizationGraphWidgetZoomType::PanLeft;
-                else if (t1.lower > t2.lower && t2.upper > t1.upper) {
-                    zoomType = VisualizationGraphWidgetZoomType::ZoomIn;
-                else {
-                    qCCritical(LOG_VisualizationGraphWidget()) << "getZoomType: Unknown type detected";
-                return zoomType;

gui/src/Visualization/VisualizationZoneWidget.cpp +49 -24

             #include "Visualization/VisualizationZoneWidget.h"
-            #include "Data/SqpRange.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "ui_VisualizationZoneWidget.h"
+            #include <Data/SqpRange.h>
+            #include <Variable/VariableController.h>
+            #include <QUuid>
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
             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 count = 0;
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
                         count++;
                     }
                 }
                 return QObject::tr("Graph %1").arg(count + 1);
             }
             } // namespace
+            struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
+                explicit VisualizationZoneWidgetPrivate() : m_SynchronisationGroupId{QUuid::createUuid()} {}
+                QUuid m_SynchronisationGroupId;
+            };
             VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
-                    : QWidget{parent}, ui{new Ui::VisualizationZoneWidget}
+                    : QWidget{parent},
+                      ui{new Ui::VisualizationZoneWidget},
+                      impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 ui->zoneNameLabel->setText(name);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
+                // Synchronisation id
+                QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
+                                          Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             VisualizationZoneWidget::~VisualizationZoneWidget()
             {
                 delete ui;
             }
             void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
             {
                 ui->visualizationZoneFrame->layout()->addWidget(graphWidget);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
             {
                 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);
                 // Lambda to synchronize zone widget
-                auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &dateTime,
+                auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &grapheRange,
-                                                                 const SqpRange &oldDateTime,
+                                                                 const SqpRange &oldGraphRange) {
-                                                                 VisualizationGraphWidgetZoomType zoomType) {
+                    auto zoomType = VariableController::getZoomType(grapheRange, oldGraphRange);
                     auto frameLayout = ui->visualizationZoneFrame->layout();
                     for (auto i = 0; i < frameLayout->count(); ++i) {
                         auto graphChild
                             = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
                         if (graphChild && (graphChild != graphWidget)) {
                             auto graphChildRange = graphChild->graphRange();
                             switch (zoomType) {
-                                case VisualizationGraphWidgetZoomType::ZoomIn: {
+                                case AcquisitionZoomType::ZoomIn: {
-                                    auto deltaLeft = dateTime.m_TStart - oldDateTime.m_TStart;
+                                    auto deltaLeft = grapheRange.m_TStart - oldGraphRange.m_TStart;
-                                    auto deltaRight = oldDateTime.m_TEnd - dateTime.m_TEnd;
+                                    auto deltaRight = oldGraphRange.m_TEnd - grapheRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
                                     qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                               << deltaLeft;
                                     qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                               << deltaRight;
                                     qCCritical(LOG_VisualizationZoneWidget())
-                                        << tr("TORM: dt") << dateTime.m_TEnd - dateTime.m_TStart;
+                                        << tr("TORM: dt") << grapheRange.m_TEnd - grapheRange.m_TStart;
                                     break;
                                 }
-                                case VisualizationGraphWidgetZoomType::ZoomOut: {
+                                case AcquisitionZoomType::ZoomOut: {
                                     qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
-                                    auto deltaLeft = oldDateTime.m_TStart - dateTime.m_TStart;
+                                    auto deltaLeft = oldGraphRange.m_TStart - grapheRange.m_TStart;
-                                    auto deltaRight = dateTime.m_TEnd - oldDateTime.m_TEnd;
+                                    auto deltaRight = grapheRange.m_TEnd - oldGraphRange.m_TEnd;
                                     qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                               << deltaLeft;
                                     qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                               << deltaRight;
                                     qCCritical(LOG_VisualizationZoneWidget())
-                                        << tr("TORM: dt") << dateTime.m_TEnd - dateTime.m_TStart;
+                                        << tr("TORM: dt") << grapheRange.m_TEnd - grapheRange.m_TStart;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     break;
                                 }
-                                case VisualizationGraphWidgetZoomType::PanRight: {
+                                case AcquisitionZoomType::PanRight: {
                                     qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
-                                    auto deltaRight = dateTime.m_TEnd - oldDateTime.m_TEnd;
+                                    auto deltaRight = grapheRange.m_TEnd - oldGraphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaRight;
                                     graphChildRange.m_TEnd += deltaRight;
                                     qCCritical(LOG_VisualizationZoneWidget())
-                                        << tr("TORM: dt") << dateTime.m_TEnd - dateTime.m_TStart;
+                                        << tr("TORM: dt") << grapheRange.m_TEnd - grapheRange.m_TStart;
                                     break;
                                 }
-                                case VisualizationGraphWidgetZoomType::PanLeft: {
+                                case AcquisitionZoomType::PanLeft: {
                                     qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
-                                    auto deltaLeft = oldDateTime.m_TStart - dateTime.m_TStart;
+                                    auto deltaLeft = oldGraphRange.m_TStart - grapheRange.m_TStart;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd -= deltaLeft;
                                     break;
                                 }
-                                case VisualizationGraphWidgetZoomType::Unknown: {
+                                case AcquisitionZoomType::Unknown: {
                                     qCCritical(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type unknown");
                                     break;
                                 }
                                 default:
                                     qCCritical(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type not take into account");
                                     // No action
                                     break;
                             }
-                            graphChild->enableSynchronize(false);
+                            graphChild->enableAcquisition(false);
                             qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
                                                                       << graphChild->graphRange();
                             qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
                                                                       << graphChildRange;
                             qCCritical(LOG_VisualizationZoneWidget())
                                 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                             graphChild->setGraphRange(graphChildRange);
-                            graphChild->enableSynchronize(true);
+                            graphChild->enableAcquisition(true);
                         }
                     }
                 };
                 // connection for synchronization
                 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
+                connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
+                        &VisualizationZoneWidget::onVariableAdded);
+                this->addGraph(graphWidget);
+                graphWidget->addVariable(variable);
                 return graphWidget;
             }
             void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to graph children
                     auto layout = ui->visualizationZoneFrame->layout();
                     for (auto i = 0; i < layout->count(); ++i) {
                         if (auto item = layout->itemAt(i)) {
                             // Widgets different from graphs are not visited (no action)
                             if (auto visualizationGraphWidget
                                 = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
                                 visualizationGraphWidget->accept(visitor);
                             }
                         }
                     }
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationZoneWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationZoneWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationZoneWidget::name() const
             {
                 return ui->zoneNameLabel->text();
             }
+            void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
+            {
+                QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
+                                          Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
+                                          Q_ARG(QUuid, impl->m_SynchronisationGroupId));
+            }

gui/ui/Visualization/VisualizationTabWidget.ui 0 -3

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>VisualizationTabWidget</class>
              <widget class="QWidget" name="VisualizationTabWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>400</width>
                 <height>300</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QVBoxLayout" name="verticalLayout">
                <property name="leftMargin">
                 <number>0</number>
                </property>
                <property name="topMargin">
                 <number>0</number>
                </property>
                <property name="rightMargin">
                 <number>0</number>
                </property>
                <property name="bottomMargin">
                 <number>0</number>
                </property>
                <item>
                 <widget class="QScrollArea" name="scrollArea">
-                 <property name="styleSheet">
-                  <string notr="true">background-color: transparent;</string>
-                 </property>
                  <property name="frameShape">
                   <enum>QFrame::NoFrame</enum>
                  </property>
                  <property name="frameShadow">
                   <enum>QFrame::Sunken</enum>
                  </property>
                  <property name="widgetResizable">
                   <bool>true</bool>
                  </property>
                  <widget class="QWidget" name="scrollAreaWidgetContents">
                   <property name="geometry">
                    <rect>
                     <x>0</x>
                     <y>0</y>
                     <width>400</width>
                     <height>300</height>
                    </rect>
                   </property>
                   <layout class="QVBoxLayout" name="verticalLayout_3"/>
                  </widget>
                 </widget>
                </item>
               </layout>
              </widget>
              <resources/>
              <connections/>
             </ui>

plugins/amda/include/AmdaProvider.h +2 -2

             #ifndef SCIQLOP_AMDAPROVIDER_H
             #define SCIQLOP_AMDAPROVIDER_H
             #include "AmdaGlobal.h"
             #include <Data/IDataProvider.h>
             #include <QLoggingCategory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaProvider)
             class QNetworkReply;
             /**
              * @brief The AmdaProvider class is an example of how a data provider can generate data
              */
             class SCIQLOP_AMDA_EXPORT AmdaProvider : public IDataProvider {
             public:
                 explicit AmdaProvider();
-                void requestDataLoading(QUuid token, const DataProviderParameters &parameters) override;
+                void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters) override;
-                void requestDataAborting(QUuid identifier) override;
+                void requestDataAborting(QUuid acqIdentifier) override;
             private:
                 void retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data);
             };
             #endif // SCIQLOP_AMDAPROVIDER_H

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

             #include "AmdaProvider.h"
             #include "AmdaDefs.h"
             #include "AmdaResultParser.h"
             #include <Common/DateUtils.h>
             #include <Data/DataProviderParameters.h>
             #include <Network/NetworkController.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <QNetworkAccessManager>
             #include <QNetworkReply>
             #include <QTemporaryFile>
             #include <QThread>
             Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")
             namespace {
             /// URL format for a request on AMDA server. The parameters are as follows:
             /// - %1: start date
             /// - %2: end date
             /// - %3: parameter id
             const auto AMDA_URL_FORMAT = QStringLiteral(
                 "http://amda.irap.omp.eu/php/rest/"
                 "getParameter.php?startTime=%1&stopTime=%2&parameterID=%3&outputFormat=ASCII&"
                 "timeFormat=ISO8601&gzip=0");
             /// Dates format passed in the URL (e.g 2013-09-23T09:00)
             const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss");
             /// Formats a time to a date that can be passed in URL
             QString dateFormat(double sqpRange) noexcept
             {
                 auto dateTime = DateUtils::dateTime(sqpRange);
                 return dateTime.toString(AMDA_TIME_FORMAT);
             }
             } // namespace
             AmdaProvider::AmdaProvider()
             {
                 qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
                     connect(this, SIGNAL(requestConstructed(QNetworkRequest, QUuid,
                                                             std::function<void(QNetworkReply *, QUuid)>)),
                             &networkController,
                             SLOT(onProcessRequested(QNetworkRequest, QUuid,
                                                     std::function<void(QNetworkReply *, QUuid)>)));
                     connect(&sqpApp->networkController(), SIGNAL(replyDownloadProgress(QUuid, double)), this,
                             SIGNAL(dataProvidedProgress(QUuid, double)));
                 }
             }
-            void AmdaProvider::requestDataLoading(QUuid token, const DataProviderParameters &parameters)
+            void AmdaProvider::requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters)
             {
                 // NOTE: Try to use multithread if possible
                 const auto times = parameters.m_Times;
                 const auto data = parameters.m_Data;
                 for (const auto &dateTime : qAsConst(times)) {
-                    retrieveData(token, dateTime, data);
+                    this->retrieveData(acqIdentifier, dateTime, data);
+                    QThread::msleep(200);
                 }
             }
-            void AmdaProvider::requestDataAborting(QUuid identifier)
+            void AmdaProvider::requestDataAborting(QUuid acqIdentifier)
             {
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
-                    networkController.onReplyCanceled(identifier);
+                    networkController.onReplyCanceled(acqIdentifier);
                 }
             }
             void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data)
             {
                 // Retrieves product ID from data: if the value is invalid, no request is made
                 auto productId = data.value(AMDA_XML_ID_KEY).toString();
                 if (productId.isNull()) {
                     qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve data: unknown product id");
                     return;
                 }
-                qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData") << dateTime;
+                qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData") << dateTime;
                 // /////////// //
                 // Creates URL //
                 // /////////// //
                 auto startDate = dateFormat(dateTime.m_TStart);
                 auto endDate = dateFormat(dateTime.m_TEnd);
                 auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};
                 qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData url:") << url;
                 auto tempFile = std::make_shared<QTemporaryFile>();
                 // LAMBDA
                 auto httpDownloadFinished
-                    = [this, dateTime, tempFile, token](QNetworkReply *reply, QUuid dataId) noexcept {
+                    = [this, dateTime, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {
-                          Q_UNUSED(dataId);
                           // Don't do anything if the reply was abort
                           if (reply->error() != QNetworkReply::OperationCanceledError) {
                               if (tempFile) {
                                   auto replyReadAll = reply->readAll();
                                   if (!replyReadAll.isEmpty()) {
                                       tempFile->write(replyReadAll);
                                   }
                                   tempFile->close();
                                   // Parse results file
                                   if (auto dataSeries = AmdaResultParser::readTxt(tempFile->fileName())) {
-                                      emit dataProvided(token, dataSeries, dateTime);
+                                      emit dataProvided(dataId, dataSeries, dateTime);
                                   }
                                   else {
                                       /// @todo ALX : debug
                                   }
                               }
                           }
                       };
                 auto httpFinishedLambda
                     = [this, httpDownloadFinished, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {
                           // Don't do anything if the reply was abort
                           if (reply->error() != QNetworkReply::OperationCanceledError) {
                               auto downloadFileUrl = QUrl{QString{reply->readAll()}};
                               qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData downloadFileUrl:")
                                                          << downloadFileUrl;
                               // Executes request for downloading file //
                               // Creates destination file
                               if (tempFile->open()) {
                                   // Executes request
                                   emit requestConstructed(QNetworkRequest{downloadFileUrl}, dataId,
                                                           httpDownloadFinished);
                               }
                           }
                       };
                 // //////////////// //
                 // Executes request //
                 // //////////////// //
                 emit requestConstructed(QNetworkRequest{url}, token, httpFinishedLambda);
             }

plugins/mockplugin/include/CosinusProvider.h +4 -3

             #ifndef SCIQLOP_COSINUSPROVIDER_H
             #define SCIQLOP_COSINUSPROVIDER_H
             #include "MockPluginGlobal.h"
             #include <Data/IDataProvider.h>
             #include <QLoggingCategory>
             #include <QUuid>
             #include <QHash>
             Q_DECLARE_LOGGING_CATEGORY(LOG_CosinusProvider)
             /**
              * @brief The CosinusProvider class is an example of how a data provider can generate data
              */
             class SCIQLOP_MOCKPLUGIN_EXPORT CosinusProvider : public IDataProvider {
             public:
                 /// @sa IDataProvider::requestDataLoading(). The current impl isn't thread safe.
-                void requestDataLoading(QUuid token, const DataProviderParameters &parameters) override;
+                void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters) override;
                 /// @sa IDataProvider::requestDataAborting(). The current impl isn't thread safe.
-                void requestDataAborting(QUuid identifier) override;
+                void requestDataAborting(QUuid acqIdentifier) override;
             private:
-                std::shared_ptr<IDataSeries> retrieveData(QUuid token, const SqpRange &dateTime);
+                std::shared_ptr<IDataSeries> retrieveData(QUuid acqIdentifier,
+                                                          const SqpRange &dataRangeRequested);
                 QHash<QUuid, bool> m_VariableToEnableProvider;
             };
             #endif // SCIQLOP_COSINUSPROVIDER_H

plugins/mockplugin/src/CosinusProvider.cpp +17 -14

             #include "CosinusProvider.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <cmath>
             #include <QFuture>
             #include <QThread>
             #include <QtConcurrent/QtConcurrent>
             Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
-            std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid token, const SqpRange &dateTime)
+            std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid acqIdentifier,
+                                                                       const SqpRange &dataRangeRequested)
             {
                 // TODO: Add Mutex
                 auto dataIndex = 0;
                 // Gets the timerange from the parameters
                 double freq = 100.0;
-                double start = std::ceil(dateTime.m_TStart * freq); // 100 htz
+                double start = std::ceil(dataRangeRequested.m_TStart * freq); // 100 htz
-                double end = std::floor(dateTime.m_TEnd * freq);    // 100 htz
+                double end = std::floor(dataRangeRequested.m_TEnd * freq);    // 100 htz
                 // We assure that timerange is valid
                 if (end < start) {
                     std::swap(start, end);
                 }
                 // Generates scalar series containing cosinus values (one value per second)
                 auto dataCount = end - start;
                 auto xAxisData = QVector<double>{};
                 xAxisData.resize(dataCount);
                 auto valuesData = QVector<double>{};
                 valuesData.resize(dataCount);
                 int progress = 0;
                 auto progressEnd = dataCount;
                 for (auto time = start; time < end; ++time, ++dataIndex) {
-                    auto it = m_VariableToEnableProvider.find(token);
+                    auto it = m_VariableToEnableProvider.find(acqIdentifier);
                     if (it != m_VariableToEnableProvider.end() && it.value()) {
                         const auto timeOnFreq = time / freq;
                         xAxisData.replace(dataIndex, timeOnFreq);
                         valuesData.replace(dataIndex, std::cos(timeOnFreq));
                         // progression
                         int currentProgress = (time - start) * 100.0 / progressEnd;
                         if (currentProgress != progress) {
                             progress = currentProgress;
-                            emit dataProvidedProgress(token, progress);
+                            emit dataProvidedProgress(acqIdentifier, progress);
                         }
                     }
                     else {
                         if (!it.value()) {
                             qCDebug(LOG_CosinusProvider())
                                 << "CosinusProvider::retrieveData: ARRET De l'acquisition detecté"
                                 << end - time;
                         }
                     }
                 }
-                emit dataProvidedProgress(token, 0.0);
+                emit dataProvidedProgress(acqIdentifier, 0.0);
                 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
                                                       Unit{QStringLiteral("t"), true}, Unit{});
             }
-            void CosinusProvider::requestDataLoading(QUuid token, const DataProviderParameters &parameters)
+            void CosinusProvider::requestDataLoading(QUuid acqIdentifier,
+                                                     const DataProviderParameters &parameters)
             {
                 // TODO: Add Mutex
-                m_VariableToEnableProvider[token] = true;
+                m_VariableToEnableProvider[acqIdentifier] = true;
                 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataLoading"
                                                << QThread::currentThread()->objectName();
                 // NOTE: Try to use multithread if possible
                 const auto times = parameters.m_Times;
                 for (const auto &dateTime : qAsConst(times)) {
-                    if (m_VariableToEnableProvider[token]) {
+                    if (m_VariableToEnableProvider[acqIdentifier]) {
-                        auto scalarSeries = this->retrieveData(token, dateTime);
+                        auto scalarSeries = this->retrieveData(acqIdentifier, dateTime);
-                        emit dataProvided(token, scalarSeries, dateTime);
+                        qCCritical(LOG_CosinusProvider()) << "CosinusProvider::dataProvided";
+                        emit dataProvided(acqIdentifier, scalarSeries, dateTime);
                     }
                 }
             }
-            void CosinusProvider::requestDataAborting(QUuid identifier)
+            void CosinusProvider::requestDataAborting(QUuid acqIdentifier)
             {
                 // TODO: Add Mutex
-                qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << identifier
+                qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << acqIdentifier
                                                << QThread::currentThread()->objectName();
-                auto it = m_VariableToEnableProvider.find(identifier);
+                auto it = m_VariableToEnableProvider.find(acqIdentifier);
                 if (it != m_VariableToEnableProvider.end()) {
                     it.value() = false;
                 }
                 else {
                     qCWarning(LOG_CosinusProvider())
                         << tr("Aborting progression of inexistant identifier detected !!!");
                 }
             }

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