GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r206:373baac343d6

Merge pull request from SCIQLOP-Initialisation develop...

leroux -

r206:373baac343d6

parent child

Context file:

r206:373baac343d6

Expand all files

core/include/Data/SqpDateTime.h created 644 +14 0

@@ -0,0 +1,14
	1	#ifndef SCIQLOP_SQPDATETIME_H
	2	#define SCIQLOP_SQPDATETIME_H
	3
	4	/**
	5	* @brief The SqpDateTime struct holds the information of time parameters
	6	*/
	7	struct SqpDateTime {
	8	/// Start time
	9	double m_TStart;
	10	/// End time
	11	double m_TEnd;
	12	};
	13
	14	#endif // SCIQLOP_SQPDATETIME_H

core/include/Time/TimeController.h created 644 +37 0

@@ -0,0 +1,37
	1	#ifndef SCIQLOP_TIMECONTROLLER_H
	2	#define SCIQLOP_TIMECONTROLLER_H
	3
	4	#include <Data/SqpDateTime.h>
	5
	6	#include <QLoggingCategory>
	7	#include <QObject>
	8
	9	#include <Common/spimpl.h>
	10
	11
	12	Q_DECLARE_LOGGING_CATEGORY(LOG_TimeController)
	13
	14	/**
	15	* @brief The TimeController class aims to handle the Time parameters notification in SciQlop.
	16	*/
	17	class TimeController : public QObject {
	18	Q_OBJECT
	19	public:
	20	explicit TimeController(QObject *parent = 0);
	21
	22	SqpDateTime dateTime() const noexcept;
	23
	24	signals:
	25	/// Signal emitted to notify that time parameters has beed updated
	26	void timeUpdated(SqpDateTime time);
	27
	28	public slots:
	29	/// Slot called when a new dateTime has been defined. Call timeUpdated signal
	30	void onTimeToUpdate(SqpDateTime dateTime);
	31
	32	private:
	33	class TimeControllerPrivate;
	34	spimpl::unique_impl_ptr<TimeControllerPrivate> impl;
	35	};
	36
	37	#endif // SCIQLOP_TIMECONTROLLER_H

core/src/Time/TimeController.cpp created 644 +26 0

@@ -0,0 +1,26
	1	#include "Time/TimeController.h"
	2
	3	Q_LOGGING_CATEGORY(LOG_TimeController, "TimeController")
	4
	5	struct TimeController::TimeControllerPrivate {
	6
	7	SqpDateTime m_DateTime;
	8	};
	9
	10	TimeController::TimeController(QObject *parent)
	11	: QObject{parent}, impl{spimpl::make_unique_impl<TimeControllerPrivate>()}
	12	{
	13	qCDebug(LOG_TimeController()) << tr("TimeController construction");
	14	}
	15
	16	SqpDateTime TimeController::dateTime() const noexcept
	17	{
	18	return impl->m_DateTime;
	19	}
	20
	21	void TimeController::onTimeToUpdate(SqpDateTime dateTime)
	22	{
	23	impl->m_DateTime = dateTime;
	24
	25	emit timeUpdated(dateTime);
	26	}

app/src/MainWindow.cpp +10 -1

             #include <DataSource/DataSourceWidget.h>
             #include <SidePane/SqpSidePane.h>
             #include <SqpApplication.h>
+            #include <Time/TimeController.h>
             #include <TimeWidget/TimeWidget.h>
             #include <Variable/Variable.h>
             #include <Visualization/VisualizationController.h>
                 this->menuBar()->addAction(tr("File"));
                 auto mainToolBar = this->addToolBar(QStringLiteral("MainToolBar"));
-                mainToolBar->addWidget(new TimeWidget{});
+                auto timeWidget = new TimeWidget{};
+                mainToolBar->addWidget(timeWidget);
                 // Widgets / controllers connections
+                // DataSource
                 connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem *)),
                         m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem *)));
+                // Time
+                connect(timeWidget, SIGNAL(timeUpdated(SqpDateTime)), &sqpApp->timeController(),
+                        SLOT(onTimeToUpdate(SqpDateTime)));
+                // Variable
                 qRegisterMetaType<std::shared_ptr<Variable> >();
                 connect(&sqpApp->visualizationController(), SIGNAL(variableCreated(std::shared_ptr<Variable>)),
                         m_Ui->view, SLOT(displayVariable(std::shared_ptr<Variable>)));

core/include/Data/DataProviderParameters.h +3 -4

             #ifndef SCIQLOP_DATAPROVIDERPARAMETERS_H
             #define SCIQLOP_DATAPROVIDERPARAMETERS_H
+            #include "SqpDateTime.h"
             /**
              * @brief The DataProviderParameters struct holds the information needed to retrieve data from a
              * data provider
              * @sa IDataProvider
              */
             struct DataProviderParameters {
-                /// Start time
+                SqpDateTime m_Time;
-                double m_TStart;
-                /// End time
-                double m_TEnd;
             };
             #endif // SCIQLOP_DATAPROVIDERPARAMETERS_H

core/include/Variable/VariableController.h +3 0

             #include <Common/spimpl.h>
             class IDataProvider;
+            class TimeController;
             class Variable;
             class VariableModel;
                 VariableModel *variableModel() noexcept;
+                void setTimeController(TimeController *timeController) noexcept;
             signals:
                 /// Signal emitted when a variable has been created
                 void variableCreated(std::shared_ptr<Variable> variable);

core/src/Variable/VariableController.cpp +28 -9

             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
+            #include <Time/TimeController.h>
             #include <QDateTime>
             #include <QMutex>
             /// @todo Generates default dataseries, according to the provider passed in parameter. This method
             /// will be deleted when the timerange is recovered from SciQlop
-            std::unique_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider) noexcept
+            std::unique_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider,
+                                                                   const SqpDateTime &dateTime) noexcept
             {
-                auto parameters = DataProviderParameters{
+                auto parameters = DataProviderParameters{dateTime};
-                    // Remarks : we don't use toSecsSinceEpoch() here (method is for Qt 5.8 or above)
-                    static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 00}}.toMSecsSinceEpoch()
-                                        / 1000.),
-                    static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 01}}.toMSecsSinceEpoch())
-                        / 1000.};
                 return provider.retrieveData(parameters);
             }
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
+                TimeController *m_TimeController{nullptr};
             };
             VariableController::VariableController(QObject *parent)
                 return impl->m_VariableModel;
             }
+            void VariableController::setTimeController(TimeController *timeController) noexcept
+            {
+                impl->m_TimeController = timeController;
+            }
             void VariableController::createVariable(const QString &name,
                                                     std::shared_ptr<IDataProvider> provider) noexcept
             {
+                // TORM
+                //    auto dateTime = SqpDateTime{
+                //        // Remarks : we don't use toSecsSinceEpoch() here (method is for Qt 5.8 or above)
+                //        static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 00}}.toMSecsSinceEpoch()
+                //                            / 1000.),
+                //        static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 01}}.toMSecsSinceEpoch())
+                //            / 1000.};
+                if (!impl->m_TimeController) {
+                    qCCritical(LOG_VariableController())
+                        << tr("Impossible to create variable: The time controller is null");
+                    return;
+                }
                 /// @todo : for the moment :
                 /// - the provider is only used to retrieve data from the variable for its initialization, but
                 /// it will be retained later
                 /// - default data are generated for the variable, without taking into account the timerange set
                 /// in sciqlop
-                if (auto newVariable
+                if (auto newVariable = impl->m_VariableModel->createVariable(
-                    = impl->m_VariableModel->createVariable(name, generateDefaultDataSeries(*provider))) {
+                        name, generateDefaultDataSeries(*provider, impl->m_TimeController->dateTime()))) {
                     emit variableCreated(newVariable);
                 }
             }

gui/include/SqpApplication.h +2 0

             #define sqpApp (static_cast<SqpApplication *>(QCoreApplication::instance()))
             class DataSourceController;
+            class TimeController;
             class VariableController;
             class VisualizationController;
                 /// Accessors for the differents sciqlop controllers
                 DataSourceController &dataSourceController() noexcept;
+                TimeController &timeController() noexcept;
                 VariableController &variableController() noexcept;
                 VisualizationController &visualizationController() noexcept;

gui/include/TimeWidget/TimeWidget.h +11 0

             #include <QWidget>
+            #include <Data/SqpDateTime.h>
             namespace Ui {
             class TimeWidget;
             } // Ui
                 explicit TimeWidget(QWidget *parent = 0);
                 virtual ~TimeWidget();
+            signals:
+                /// Signal emitted when the time parameters has beed updated
+                void timeUpdated(SqpDateTime time);
+            public slots:
+                /// slot called when time parameters update has ben requested
+                void onTimeUpdateRequested();
             private:
                 Ui::TimeWidget *ui;
             };

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

                 Q_OBJECT
             public:
-                explicit VisualizationGraphWidget(QWidget *parent = 0);
+                explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationGraphWidget();
                 void addVariable(std::shared_ptr<Variable> variable);

gui/include/Visualization/VisualizationTabWidget.h +14 -3

             #include "Visualization/IVisualizationWidget.h"
+            #include <Common/spimpl.h>
             #include <QWidget>
+            class Variable;
             class VisualizationZoneWidget;
             namespace Ui {
                 Q_OBJECT
             public:
-                explicit VisualizationTabWidget(QWidget *parent = 0);
+                explicit VisualizationTabWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationTabWidget();
                 /// Add a zone widget
                 void addZone(VisualizationZoneWidget *zoneWidget);
-                /// Create a zone using a Variable
+                /**
-                VisualizationZoneWidget *createZone();
+                 * Creates a zone using a variable. The variable will be displayed in a new graph of the new
+                 * zone.
+                 * @param variable the variable for which to create the zone
+                 * @return the pointer to the created zone
+                 */
+                VisualizationZoneWidget *createZone(std::shared_ptr<Variable> variable);
                 /// Remove a zone
                 void removeZone(VisualizationZoneWidget *zone);
             private:
                 Ui::VisualizationTabWidget *ui;
+                class VisualizationTabWidgetPrivate;
+                spimpl::unique_impl_ptr<VisualizationTabWidgetPrivate> impl;
             };
             #endif // SCIQLOP_VISUALIZATIONTABWIDGET_H

gui/include/Visualization/VisualizationZoneWidget.h +10 -5

             #include "Visualization/IVisualizationWidget.h"
-            class VisualizationGraphWidget;
             #include <QWidget>
             namespace Ui {
             class VisualizationZoneWidget;
             } // Ui
+            class Variable;
+            class VisualizationGraphWidget;
             class VisualizationZoneWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
-                explicit VisualizationZoneWidget(QWidget *parent = 0);
+                explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationZoneWidget();
                 /// Add a graph widget
                 void addGraph(VisualizationGraphWidget *graphWidget);
-                /// Create a graph using a Variable
+                /**
-                VisualizationGraphWidget *createGraph();
+                 * 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);
                 /// Remove a graph
                 void removeGraph(VisualizationGraphWidget *graph);

gui/src/SqpApplication.cpp +11 0

             #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
             #include <QThread>
+            #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/VisualizationController.h>
             public:
                 SqpApplicationPrivate()
                         : m_DataSourceController{std::make_unique<DataSourceController>()},
+                          m_TimeController{std::make_unique<TimeController>()},
                           m_VariableController{std::make_unique<VariableController>()},
                           m_VisualizationController{std::make_unique<VisualizationController>()}
                 {
                     m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
                     m_VariableController->moveToThread(&m_VariableControllerThread);
                     m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
+                    // Additionnal init
+                    m_VariableController->setTimeController(m_TimeController.get());
                 }
                 virtual ~SqpApplicationPrivate()
                 std::unique_ptr<DataSourceController> m_DataSourceController;
                 std::unique_ptr<VariableController> m_VariableController;
+                std::unique_ptr<TimeController> m_TimeController;
                 std::unique_ptr<VisualizationController> m_VisualizationController;
                 QThread m_DataSourceControllerThread;
                 QThread m_VariableControllerThread;
                 return *impl->m_DataSourceController;
             }
+            TimeController &SqpApplication::timeController() noexcept
+            {
+                return *impl->m_TimeController;
+            }
             VariableController &SqpApplication::variableController() noexcept
             {
                 return *impl->m_VariableController;

gui/src/TimeWidget/TimeWidget.cpp +17 0

             #include "TimeWidget/TimeWidget.h"
             #include "ui_TimeWidget.h"
             TimeWidget::TimeWidget(QWidget *parent) : QWidget{parent}, ui{new Ui::TimeWidget}
             {
                 ui->setupUi(this);
+                // Connection
+                connect(ui->startDateTimeEdit, &QDateTimeEdit::dateTimeChanged, this,
+                        &TimeWidget::onTimeUpdateRequested);
+                connect(ui->endDateTimeEdit, &QDateTimeEdit::dateTimeChanged, this,
+                        &TimeWidget::onTimeUpdateRequested);
             }
             TimeWidget::~TimeWidget()
             {
                 delete ui;
             }
+            void TimeWidget::onTimeUpdateRequested()
+            {
+                auto dateTime = SqpDateTime{
+                    static_cast<double>(ui->startDateTimeEdit->dateTime().toMSecsSinceEpoch() / 1000.),
+                    static_cast<double>(ui->endDateTimeEdit->dateTime().toMSecsSinceEpoch()) / 1000.};
+                emit timeUpdated(std::move(dateTime));
+            }

gui/src/Visualization/VisualizationGraphWidget.cpp +11 -2

                 std::unordered_map<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMap;
             };
-            VisualizationGraphWidget::VisualizationGraphWidget(QWidget *parent)
+            VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
             {
                 ui->setupUi(this);
+                // qcpplot title
+                ui->widget->plotLayout()->insertRow(0);
+                ui->widget->plotLayout()->addElement(0, 0, new QCPTextElement{ui->widget, name});
                 // Set qcpplot properties :
                 // - Drag (on x-axis) and zoom are enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
             QString VisualizationGraphWidget::name() const
             {
-                return QStringLiteral("MainView");
+                if (auto title = dynamic_cast<QCPTextElement *>(ui->widget->plotLayout()->elementAt(0))) {
+                    return title->text();
+                }
+                else {
+                    return QString{};
+                }
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept

gui/src/Visualization/VisualizationTabWidget.cpp +33 -5

@@ -3,9 +3,34
3		3
4	#include "Visualization/VisualizationZoneWidget.h"	4	#include "Visualization/VisualizationZoneWidget.h"
5		5
		6	namespace {
6		7
7	VisualizationTabWidget::VisualizationTabWidget(QWidget *parent)	8	/// Generates a default name for a new zone, according to the number of zones already displayed in
8	: QWidget{parent}, ui{new Ui::VisualizationTabWidget}	9	/// the tab
		10	QString defaultZoneName(const QLayout &layout)
		11	{
		12	auto count = 0;
		13	for (auto i = 0; i < layout.count(); ++i) {
		14	if (dynamic_cast<VisualizationZoneWidget *>(layout.itemAt(i)->widget())) {
		15	count++;
		16	}
		17	}
		18
		19	return QObject::tr("Zone %1").arg(count + 1);
		20	}
		21
		22	} // namespace
		23
		24	struct VisualizationTabWidget::VisualizationTabWidgetPrivate {
		25	explicit VisualizationTabWidgetPrivate(const QString &name) : m_Name{name} {}
		26
		27	QString m_Name;
		28	};
		29
		30	VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *parent)
		31	: QWidget{parent},
		32	ui{new Ui::VisualizationTabWidget},
		33	impl{spimpl::make_unique_impl<VisualizationTabWidgetPrivate>(name)}
9	{	34	{
10	ui->setupUi(this);	35	ui->setupUi(this);
11	}	36	}
@@ -20,11 +45,14 void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
20	this->layout()->addWidget(zoneWidget);	45	this->layout()->addWidget(zoneWidget);
21	}	46	}
22		47
23	VisualizationZoneWidget *VisualizationTabWidget::createZone()	48	VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
24	{	49	{
25	auto zoneWidget = new VisualizationZoneWidget{this};	50	auto zoneWidget = new VisualizationZoneWidget{defaultZoneName(*layout()), this};
26	this->addZone(zoneWidget);	51	this->addZone(zoneWidget);
27		52
		53	// Creates a new graph into the zone
		54	zoneWidget->createGraph(variable);
		55
28	return zoneWidget;	56	return zoneWidget;
29	}	57	}
30		58
@@ -45,5 +73,5 void VisualizationTabWidget::close()
45		73
46	QString VisualizationTabWidget::name() const	74	QString VisualizationTabWidget::name() const
47	{	75	{
48	return QStringLiteral("MainView");	76	return impl->m_Name;
49	}	77	}

gui/src/Visualization/VisualizationWidget.cpp +7 -12

                 };
                 auto addTabView = [this, enableMinimumCornerWidgetSize]() {
-                    auto index = ui->tabWidget->addTab(new VisualizationTabWidget(ui->tabWidget),
+                    auto widget = new VisualizationTabWidget{QString{"View %1"}.arg(ui->tabWidget->count() + 1),
-                                                       QString("View %1").arg(ui->tabWidget->count() + 1));
+                                                             ui->tabWidget};
+                    auto index = ui->tabWidget->addTab(widget, widget->name());
                     if (ui->tabWidget->count() > 0) {
                         enableMinimumCornerWidgetSize(false);
                     }
                 connect(addTabViewButton, &QToolButton::clicked, addTabView);
                 connect(ui->tabWidget, &QTabWidget::tabCloseRequested, removeTabView);
+                // Adds default tab
+                addTabView();
             }
             VisualizationWidget::~VisualizationWidget()
             void VisualizationWidget::displayVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (auto currentTab = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->currentWidget())) {
-                    if (auto newZone = currentTab->createZone()) {
+                    if (!currentTab->createZone(variable)) {
-                        if (auto newGraph = newZone->createGraph()) {
-                            newGraph->addVariable(variable);
-                        else {
-                            qCCritical(LOG_VisualizationWidget())
-                                << tr("Can't display the variable : can't create the graph");
-                    else {
                         qCCritical(LOG_VisualizationWidget())
                             << tr("Can't display the variable : can't create a new zone in the current tab");
                     }

gui/src/Visualization/VisualizationZoneWidget.cpp +27 -4

             #include "Visualization/VisualizationGraphWidget.h"
-            VisualizationZoneWidget::VisualizationZoneWidget(QWidget *parent)
+            namespace {
+            /// 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
+            VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
                     : QWidget{parent}, ui{new Ui::VisualizationZoneWidget}
             {
                 ui->setupUi(this);
+                ui->zoneNameLabel->setText(name);
             }
             VisualizationZoneWidget::~VisualizationZoneWidget()
                 ui->visualizationZoneFrame->layout()->addWidget(graphWidget);
             }
-            VisualizationGraphWidget *VisualizationZoneWidget::createGraph()
+            VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
             {
-                auto graphWidget = new VisualizationGraphWidget{this};
+                auto graphWidget = new VisualizationGraphWidget{
+                    defaultGraphName(*ui->visualizationZoneFrame->layout()), this};
                 this->addGraph(graphWidget);
+                graphWidget->addVariable(variable);
                 return graphWidget;
             }
             QString VisualizationZoneWidget::name() const
             {
-                return QStringLiteral("MainView");
+                return ui->zoneNameLabel->text();
             }

gui/ui/Visualization/VisualizationWidget.ui +1 -14

                <item>
                 <widget class="QTabWidget" name="tabWidget">
                  <property name="currentIndex">
-                  <number>0</number>
+                  <number>-1</number>
                  </property>
-                 <widget class="VisualizationTabWidget" name="firstView">
-                  <attribute name="title">
-                   <string>View 1</string>
-                  </attribute>
-                 </widget>
                 </widget>
                </item>
               </layout>
              </widget>
-             <customwidgets>
-              <customwidget>
-               <class>VisualizationTabWidget</class>
-               <extends>QWidget</extends>
-               <header location="global">Visualization/VisualizationTabWidget.h</header>
-               <container>1</container>
-              </customwidget>
-             </customwidgets>
              <resources/>
              <connections/>
             </ui>

gui/ui/Visualization/VisualizationZoneWidget.ui +28 -2

@@ -14,9 +14,15
14	<string>Form</string>	14	<string>Form</string>
15	</property>	15	</property>
16	<layout class="QVBoxLayout" name="verticalLayout_2">	16	<layout class="QVBoxLayout" name="verticalLayout_2">
17	<property name="spacing">	17	<item>
18	<number>3</number>	18	<widget class="QWidget" name="infobar" native="true">
		19	<property name="sizePolicy">
		20	<sizepolicy hsizetype="Preferred" vsizetype="Minimum">
		21	<horstretch>0</horstretch>
		22	<verstretch>0</verstretch>
		23	</sizepolicy>
19	</property>	24	</property>
		25	<layout class="QHBoxLayout" name="horizontalLayout">
20	<property name="leftMargin">	26	<property name="leftMargin">
21	<number>0</number>	27	<number>0</number>
22	</property>	28	</property>
@@ -30,7 +36,27
30	<number>0</number>	36	<number>0</number>
31	</property>	37	</property>
32	<item>	38	<item>
		39	<widget class="QLabel" name="zoneNameLabel">
		40	<property name="styleSheet">
		41	<string notr="true">color: rgb(127, 127, 127);
		42	</string>
		43	</property>
		44	<property name="text">
		45	<string>TextLabel</string>
		46	</property>
		47	</widget>
		48	</item>
		49	</layout>
		50	</widget>
		51	</item>
		52	<item>
33	<widget class="QFrame" name="visualizationZoneFrame">	53	<widget class="QFrame" name="visualizationZoneFrame">
		54	<property name="sizePolicy">
		55	<sizepolicy hsizetype="Preferred" vsizetype="Expanding">
		56	<horstretch>0</horstretch>
		57	<verstretch>0</verstretch>
		58	</sizepolicy>
		59	</property>
34	<property name="frameShape">	60	<property name="frameShape">
35	<enum>QFrame::Box</enum>	61	<enum>QFrame::Box</enum>
36	</property>	62	</property>

gui/vera-exclusions/exclusions.txt +2 0

             # Ignore false positive relative to unnamed namespace
             DataSourceTreeWidgetItem\.cpp:\d+:.*IPSIS_F13.*
+            VisualizationTabWidget\.cpp:\d+:.*IPSIS_F13.*
+            VisualizationZoneWidget\.cpp:\d+:.*IPSIS_F13.*

plugins/mockplugin/src/CosinusProvider.cpp +4 -2

             std::unique_ptr<IDataSeries>
             CosinusProvider::retrieveData(const DataProviderParameters &parameters) const
             {
+                auto dateTime = parameters.m_Time;
                 // Gets the timerange from the parameters
-                auto start = parameters.m_TStart;
+                auto start = dateTime.m_TStart;
-                auto end = parameters.m_TEnd;
+                auto end = dateTime.m_TEnd;
                 // We assure that timerange is valid
                 if (end < start) {

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