HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Pull Request !138

Closed

Pull request !138 Created on by

perrinel

- Merge branch 'feature/InitPlugin' into develop
- Unit tests for plugin loading (2)
- Unit tests for plugin loading (1)
- Implements method to get the number of plugins loaded
- Adds logs in plugin loading method

Commit flow:

branch:develop of GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation → branch:develop of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Versions:

Pull request versions not available.

Expand 22 commits

ver	Time	Author	Commit	Description
`latest`	Wed, 07 Jun 2017 14:57:08	perrinel	`r74:325ad50ffecd`	Remove coverage from windows build
`v2`	Wed, 07 Jun 2017 14:51:52	Alexandre Leroux	`r73:51df0df4d852`	Remove unit tests of plugin manager They were only compatible with Windows
`v1`	Wed, 07 Jun 2017 13:54:49	Alexandre Leroux	`r72:538f97c38e97`	Merge branch 'feature/InitPlugin' into develop
`v1`	Wed, 07 Jun 2017 13:51:50	Alexandre Leroux	`r71:fa55a3b11979`	Unit tests for plugin loading (2) Tests implementation
`v1`	Wed, 07 Jun 2017 13:51:50	Alexandre Leroux	`r70:b8e5d4af3bed`	Unit tests for plugin loading (1) Initializes resources path
`v1`	Wed, 07 Jun 2017 13:51:50	Alexandre Leroux	`r69:0c771d009214`	Implements method to get the number of plugins loaded
`v1`	Wed, 07 Jun 2017 13:51:50	Alexandre Leroux	`r68:b0fc434fbc92`	Adds logs in plugin loading method
`v1`	Wed, 07 Jun 2017 13:51:50	Alexandre Leroux	`r67:e206357a6486`	Implements plugin loading method
`v1`	Wed, 07 Jun 2017 13:51:50	Alexandre Leroux	`r66:5cbeec46f38d`	Initializes plugin manager Plugin manager is used to load plugins into SciQlop
`v1`	Wed, 07 Jun 2017 13:51:50	Alexandre Leroux	`r65:75b3ca8ef471`	Define main plugin interface
`v1`	Wed, 07 Jun 2017 13:51:50	Alexandre Leroux	`r64:64b6a9e1cea3`	CMakeLists for "plugin" module Plugin module is used to store all .h files that define a plugin
`v1`	Wed, 07 Jun 2017 13:30:02	perrinel	`r63:7c34f5dd9e63`	Merge pull request 137 from SCIQLOP-Initialisation feature/VisualisationInit Feature/VisualisationInit
`v1`	Wed, 07 Jun 2017 13:26:12	perrinel	`r62:ceb48355d52b`	add qt cmake file for cpack. (forgotten from cpackforwindows commit)
`v1`	Wed, 07 Jun 2017 13:24:46	perrinel	`r61:396fde467fc9`	add spimpl formatting (from windows)
`v1`	Wed, 07 Jun 2017 13:23:49	perrinel	`r60:0e638b9fa18c`	add vera-exclusion rules
`v1`	Wed, 07 Jun 2017 13:23:20	perrinel	`r59:3f621ff980c4`	add qcustomplot
`v1`	Wed, 07 Jun 2017 13:22:58	perrinel	`r58:7592cb7f14bd`	Creation of VisualizationWidget, VizualizationTabWidget, VisualizationZoneWidget, VisualizationGraphWidget
`v1`	Wed, 07 Jun 2017 13:22:04	perrinel	`r57:e3d0d86d21a2`	Creation and styling SidePaneWidget
`v1`	Wed, 07 Jun 2017 08:36:26	perrinel	`r56:244ada855935`	Add skelleton of the gui
`v1`	Wed, 07 Jun 2017 08:36:00	perrinel	`r55:c67812913ba9`	add missing visualization thread call
`v1`	Tue, 06 Jun 2017 14:16:11	perrinel	`r54:7bf435c144fc`	Refactoring of app module to avoir vera++ warning and to dispatch sources files in the corrects paths
`v1`	Tue, 06 Jun 2017 13:14:11	perrinel	`r53:289a78f309b1`	Add the visualization controller
22 commits hidden, click expand to show them.

Expand all files

LICENSE created 644 +1 0

	@@ -0,0 +1,1
				1	TODO

gui/include/visualization/VisualizationGraphWidget.h created 644 +21 0

@@ -0,0 +1,21
	1	#ifndef SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
	2	#define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
	3
	4	#include <QWidget>
	5
	6	namespace Ui {
	7	class VisualizationGraphWidget;
	8	} // namespace Ui
	9
	10	class VisualizationGraphWidget : public QWidget {
	11	Q_OBJECT
	12
	13	public:
	14	explicit VisualizationGraphWidget(QWidget *parent = 0);
	15	virtual ~VisualizationGraphWidget();
	16
	17	private:
	18	Ui::VisualizationGraphWidget *ui;
	19	};
	20
	21	#endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H

gui/include/visualization/VisualizationTabWidget.h created 644 +21 0

@@ -0,0 +1,21
	1	#ifndef SCIQLOP_VISUALIZATIONTABWIDGET_H
	2	#define SCIQLOP_VISUALIZATIONTABWIDGET_H
	3
	4	#include <QWidget>
	5
	6	namespace Ui {
	7	class VisualizationTabWidget;
	8	} // namespace Ui
	9
	10	class VisualizationTabWidget : public QWidget {
	11	Q_OBJECT
	12
	13	public:
	14	explicit VisualizationTabWidget(QWidget *parent = 0);
	15	virtual ~VisualizationTabWidget();
	16
	17	private:
	18	Ui::VisualizationTabWidget *ui;
	19	};
	20
	21	#endif // SCIQLOP_VISUALIZATIONTABWIDGET_H

gui/include/visualization/VisualizationZoneWidget.h created 644 +21 0

@@ -0,0 +1,21
	1	#ifndef SCIQLOP_VISUALIZATIONZONEWIDGET_H
	2	#define SCIQLOP_VISUALIZATIONZONEWIDGET_H
	3
	4	#include <QWidget>
	5
	6	namespace Ui {
	7	class VisualizationZoneWidget;
	8	} // Ui
	9
	10	class VisualizationZoneWidget : public QWidget {
	11	Q_OBJECT
	12
	13	public:
	14	explicit VisualizationZoneWidget(QWidget *parent = 0);
	15	virtual ~VisualizationZoneWidget();
	16
	17	private:
	18	Ui::VisualizationZoneWidget *ui;
	19	};
	20
	21	#endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H

gui/src/visualization/VisualizationGraphWidget.cpp created 644 +13 0

@@ -0,0 +1,13
	1	#include "visualization\VisualizationGraphWidget.h"
	2	#include "ui_VisualizationGraphWidget.h"
	3
	4	VisualizationGraphWidget::VisualizationGraphWidget(QWidget *parent)
	5	: QWidget(parent), ui(new Ui::VisualizationGraphWidget)
	6	{
	7	ui->setupUi(this);
	8	}
	9
	10	VisualizationGraphWidget::~VisualizationGraphWidget()
	11	{
	12	delete ui;
	13	}

gui/src/visualization/VisualizationTabWidget.cpp created 644 +13 0

@@ -0,0 +1,13
	1	#include "visualization\VisualizationTabWidget.h"
	2	#include "ui_VisualizationTabWidget.h"
	3
	4	VisualizationTabWidget::VisualizationTabWidget(QWidget *parent)
	5	: QWidget(parent), ui(new Ui::VisualizationTabWidget)
	6	{
	7	ui->setupUi(this);
	8	}
	9
	10	VisualizationTabWidget::~VisualizationTabWidget()
	11	{
	12	delete ui;
	13	}

gui/src/visualization/VisualizationWidget.cpp created 644 +13 0

@@ -0,0 +1,13
	1	#include "visualization\VisualizationWidget.h"
	2	#include "ui_VisualizationWidget.h"
	3
	4	VisualizationWidget::VisualizationWidget(QWidget *parent)
	5	: QWidget(parent), ui(new Ui::VisualizationWidget)
	6	{
	7	ui->setupUi(this);
	8	}
	9
	10	VisualizationWidget::~VisualizationWidget()
	11	{
	12	delete ui;
	13	}

gui/src/visualization/VisualizationZoneWidget.cpp created 644 +13 0

@@ -0,0 +1,13
	1	#include "visualization\VisualizationZoneWidget.h"
	2	#include "ui_VisualizationZoneWidget.h"
	3
	4	VisualizationZoneWidget::VisualizationZoneWidget(QWidget *parent)
	5	: QWidget(parent), ui(new Ui::VisualizationZoneWidget)
	6	{
	7	ui->setupUi(this);
	8	}
	9
	10	VisualizationZoneWidget::~VisualizationZoneWidget()
	11	{
	12	delete ui;
	13	}

gui/ui/visualization/VisualizationGraphWidget.ui created 644 +21 0

@@ -0,0 +1,21
	1	<ui version="4.0">
	2	<author/>
	3	<comment/>
	4	<exportmacro/>
	5	<class>VisualizationGraphWidget</class>
	6	<widget name="VisualizationGraphWidget" class="QWidget">
	7	<property name="geometry">
	8	<rect>
	9	<x>0</x>
	10	<y>0</y>
	11	<width>400</width>
	12	<height>300</height>
	13	</rect>
	14	</property>
	15	<property name="windowTitle">
	16	<string>Form</string>
	17	</property>
	18	</widget>
	19	<pixmapfunction/>
	20	<connections/>
	21	</ui>

gui/ui/visualization/VisualizationTabWidget.ui created 644 +21 0

@@ -0,0 +1,21
	1	<ui version="4.0">
	2	<author/>
	3	<comment/>
	4	<exportmacro/>
	5	<class>VisualizationTabWidget</class>
	6	<widget name="VisualizationTabWidget" class="QWidget">
	7	<property name="geometry">
	8	<rect>
	9	<x>0</x>
	10	<y>0</y>
	11	<width>400</width>
	12	<height>300</height>
	13	</rect>
	14	</property>
	15	<property name="windowTitle">
	16	<string>Form</string>
	17	</property>
	18	</widget>
	19	<pixmapfunction/>
	20	<connections/>
	21	</ui>

README.md +1 -31

@@ -1,31 +1,1
1	![](gui/resources/icones/sciqlop2PNG_1024.png){:.some-css-class style="width: 20%"}	1	TODO No newline at end of file
2
3
4	# Overview
5
6	SciQLOP (SCIentific Qt application for Learning from Observations of Plasmas) aims to be an ergonomic
7	and powerful tool enabling visualization and analysis of in-situ space plasma data. This goal rises some
8	challenges either technical and in the conception and the design.
9	The time resolution allowed by nowadays measurements imply the ability to plot millions of points just for
10	one sensor with no compromise on interactivity. Plots may stay responsive even with millions of points.
11	Being able to scroll, zoom, move and export the plots with the mouse are the minimal interactions expected by the user.
12	SciQLOP may also abstract the manipulation of physic data while providing contextual features such as
13	coordinate transform, physical quantity extraction from data.
14	That said increasing graphical features usually lead to slower software and more complex GUI. Keeping
15	SciQLOP lightweight and intuitive is one of the priorities to make it usable and competitive.
16
17
18	## How to build
19
20	```
21	git clone https://hephaistos.lpp.polytechnique.fr/rhodecode/HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop
22	cd SciQLop
23	mkdir build && cd build
24	cmake ../
25	make
26
27	```
28
29	## How to contribute
30
31	Contact sciqlop@lpp.polytechnique.fr

app/CMakeLists.txt +1 -11

             # Find Qt modules
             #
             SCIQLOP_FIND_QT(Core Widgets)
             #
             # Find dependent libraries
             set_property(TARGET ${EXECUTABLE_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
             target_link_libraries(${EXECUTABLE_NAME}
                 ${LIBRARIES})
-            INSTALL(TARGETS ${EXECUTABLE_NAME}
-              RUNTIME DESTINATION ${INSTALL_BINARY_DIR}
-              LIBRARY DESTINATION ${INSTALL_BINARY_DIR}
-              ARCHIVE DESTINATION ${INSTALL_BINARY_DIR}
             # Link with Qt5 modules
             qt5_use_modules(${EXECUTABLE_NAME} Core Widgets)
-            add_dependencies(${EXECUTABLE_NAME} ${SQPGUI_LIBRARY_NAME} ${SQPCORE_LIBRARY_NAME})
             # Add the files to the list of files to be analyzed

app/include/MainWindow.h +2 -7

             #define SCIQLOP_MAINWINDOW_H
             #include <QListWidgetItem>
-            #include <QLoggingCategory>
             #include <QMainWindow>
             #include <QProgressBar>
             #include <QProgressDialog>
             #include <QThread>
             #include <QVBoxLayout>
             #include <QWidget>
+            //#include "../Core/qlopservice.h"
-            #include <Common/spimpl.h>
+            //#include "../Core/qlopgui.h"
             #include <memory>
-            Q_DECLARE_LOGGING_CATEGORY(LOG_MainWindow)
             namespace Ui {
             class MainWindow;
             } // namespace Ui
                 //    QWidget *m_progressWidget;
                 //    QVBoxLayout *m_progressLayout;
                 // QList<QLopService*> m_qlopServices;
-                class MainWindowPrivate;
-                spimpl::unique_impl_ptr<MainWindowPrivate> impl;
             };
             #endif // SCIQLOP_MAINWINDOW_H

app/src/MainWindow.cpp +65 -201

@@ -21,226 +21,90
21	----------------------------------------------------------------------------*/	21	----------------------------------------------------------------------------*/
22	#include "MainWindow.h"	22	#include "MainWindow.h"
23	#include "ui_MainWindow.h"	23	#include "ui_MainWindow.h"
24
25	#include <DataSource/DataSourceController.h>
26	#include <DataSource/DataSourceWidget.h>
27	#include <Settings/SqpSettingsDialog.h>
28	#include <Settings/SqpSettingsGeneralWidget.h>
29	#include <SidePane/SqpSidePane.h>
30	#include <SqpApplication.h>
31	#include <Time/TimeController.h>
32	#include <TimeWidget/TimeWidget.h>
33	#include <Variable/Variable.h>
34	#include <Variable/VariableController.h>
35	#include <Visualization/VisualizationController.h>
36
37	#include <QAction>	24	#include <QAction>
38	#include <QDate>	25	#include <QDate>
		26	#include <QDateTime>
39	#include <QDir>	27	#include <QDir>
40	#include <QFileDialog>	28	#include <QFileDialog>
		29	//#include <omp.h>
		30	//#include <network/filedownloader.h>
		31	//#include <qlopdatabase.h>
		32	//#include <qlopsettings.h>
		33	//#include <qlopgui.h>
		34	//#include <spacedata.h>
		35	//#include "qlopcore.h"
		36	//#include "qlopcodecmanager.h"
		37	//#include "cdfcodec.h"
		38	//#include "amdatxtcodec.h"
		39	//#include <qlopplotmanager.h>
		40	#include <QAction>
41	#include <QToolBar>	41	#include <QToolBar>
42	#include <QToolButton>
43	#include <memory.h>	42	#include <memory.h>
44		43	MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), m_Ui(new Ui::MainWindow)
45	#include "iostream"
46
47	Q_LOGGING_CATEGORY(LOG_MainWindow, "MainWindow")
48
49	namespace {
50	const auto LEFTMAININSPECTORWIDGETSPLITTERINDEX = 0;
51	const auto LEFTINSPECTORSIDEPANESPLITTERINDEX = 1;
52	const auto VIEWPLITTERINDEX = 2;
53	const auto RIGHTINSPECTORSIDEPANESPLITTERINDEX = 3;
54	const auto RIGHTMAININSPECTORWIDGETSPLITTERINDEX = 4;
55	}
56
57	class MainWindow::MainWindowPrivate {
58	public:
59	explicit MainWindowPrivate(MainWindow *mainWindow)
60	: m_LastOpenLeftInspectorSize{},
61	m_LastOpenRightInspectorSize{},
62	m_GeneralSettingsWidget{new SqpSettingsGeneralWidget{mainWindow}},
63	m_SettingsDialog{new SqpSettingsDialog{mainWindow}}
64	{
65	}
66
67	QSize m_LastOpenLeftInspectorSize;
68	QSize m_LastOpenRightInspectorSize;
69	/// General settings widget. MainWindow has the ownership
70	SqpSettingsGeneralWidget *m_GeneralSettingsWidget;
71	/// Settings dialog. MainWindow has the ownership
72	SqpSettingsDialog *m_SettingsDialog;
73	};
74
75	MainWindow::MainWindow(QWidget *parent)
76	: QMainWindow{parent},
77	m_Ui{new Ui::MainWindow},
78	impl{spimpl::make_unique_impl<MainWindowPrivate>(this)}
79	{	44	{
80	m_Ui->setupUi(this);	45	m_Ui->setupUi(this);
81		46
82	m_Ui->splitter->setCollapsible(LEFTINSPECTORSIDEPANESPLITTERINDEX, false);
83	m_Ui->splitter->setCollapsible(RIGHTINSPECTORSIDEPANESPLITTERINDEX, false);
84
85
86	auto leftSidePane = m_Ui->leftInspectorSidePane->sidePane();	47	auto leftSidePane = m_Ui->leftInspectorSidePane->sidePane();
87	auto openLeftInspectorAction = new QAction{QIcon{	48	leftSidePane->addAction("ACTION L1");
88	":/icones/previous.png",	49	leftSidePane->addAction("ACTION L2");
89	},	50	leftSidePane->addAction("ACTION L3");
90	tr("Show/hide the left inspector"), this};
91
92
93	auto spacerLeftTop = new QWidget{};
94	spacerLeftTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
95
96	auto spacerLeftBottom = new QWidget{};
97	spacerLeftBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
98
99	leftSidePane->addWidget(spacerLeftTop);
100	leftSidePane->addAction(openLeftInspectorAction);
101	leftSidePane->addWidget(spacerLeftBottom);
102
103		51
104	auto rightSidePane = m_Ui->rightInspectorSidePane->sidePane();	52	auto rightSidePane = m_Ui->rightInspectorSidePane->sidePane();
105	auto openRightInspectorAction = new QAction{QIcon{	53	rightSidePane->addAction("ACTION R1");
106	":/icones/next.png",	54	rightSidePane->addAction("ACTION R2");
107	},	55	rightSidePane->addAction("ACTION R3");
108	tr("Show/hide the right inspector"), this};	56
109		57	this->menuBar()->addAction("File");
110	auto spacerRightTop = new QWidget{};	58	auto mainToolBar = this->addToolBar("MainToolBar");
111	spacerRightTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);	59	mainToolBar->addAction("A1");
112		60	/* QLopGUI::registerMenuBar(menuBar());
113	auto spacerRightBottom = new QWidget{};	61	this->setWindowIcon(QIcon(":/sciqlopLOGO.svg"));
114	spacerRightBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);	62	this->m_progressWidget = new QWidget();
115		63	this->m_progressLayout = new QVBoxLayout(this->m_progressWidget);
116	rightSidePane->addWidget(spacerRightTop);	64	this->m_progressWidget->setLayout(this->m_progressLayout);
117	rightSidePane->addAction(openRightInspectorAction);	65	this->m_progressWidget->setWindowModality(Qt::WindowModal);
118	rightSidePane->addWidget(spacerRightBottom);	66	m_progressThreadIds = (int) malloc(OMP_THREADSsizeof(int));
119		67	for(int i=0;i<OMP_THREADS;i++)
120	openLeftInspectorAction->setCheckable(true);	68	{
121	openRightInspectorAction->setCheckable(true);	69	this->m_progress.append(new QProgressBar(this->m_progressWidget));
122		70	this->m_progress.last()->setMinimum(0);
123	auto openInspector = [this](bool checked, bool right, auto action) {	71	this->m_progress.last()->setMaximum(100);
124		72	this->m_progressLayout->addWidget(this->m_progress.last());
125	action->setIcon(QIcon{(checked xor right) ? ":/icones/next.png" : ":/icones/previous.png"});	73	this->m_progressWidget->hide();
126		74	this->m_progressThreadIds[i] = -1;
127	auto &lastInspectorSize
128	= right ? impl->m_LastOpenRightInspectorSize : impl->m_LastOpenLeftInspectorSize;
129
130	auto nextInspectorSize = right ? m_Ui->rightMainInspectorWidget->size()
131	: m_Ui->leftMainInspectorWidget->size();
132
133	// Update of the last opened geometry
134	if (checked) {
135	lastInspectorSize = nextInspectorSize;
136	}	75	}
137		76	this->m_progressWidget->setWindowTitle("Loading File");
138	auto startSize = lastInspectorSize;	77	const QList<QLopService>ServicesToLoad=QList<QLopService>()
139	auto endSize = startSize;	78	<< QLopCore::self()
140	endSize.setWidth(0);	79	<< QLopPlotManager::self()
141		80	<< QLopCodecManager::self()
142	auto splitterInspectorIndex	81	<< FileDownloader::self()
143	= right ? RIGHTMAININSPECTORWIDGETSPLITTERINDEX : LEFTMAININSPECTORWIDGETSPLITTERINDEX;	82	<< QLopDataBase::self()
144		83	<< SpaceData::self();
145	auto currentSizes = m_Ui->splitter->sizes();	84
146	if (checked) {	85	CDFCodec::registerToManager();
147	// adjust sizes individually here, e.g.	86	AMDATXTCodec::registerToManager();
148	currentSizes[splitterInspectorIndex] -= lastInspectorSize.width();	87
149	currentSizes[VIEWPLITTERINDEX] += lastInspectorSize.width();	88
150	m_Ui->splitter->setSizes(currentSizes);	89	for(int i=0;i<ServicesToLoad.count();i++)
151	}	90	{
152	else {	91	qDebug()<<ServicesToLoad.at(i)->serviceName();
153	// adjust sizes individually here, e.g.	92	ServicesToLoad.at(i)->initialize(); //must be called before getGUI
154	currentSizes[splitterInspectorIndex] += lastInspectorSize.width();	93	QDockWidget* wdgt=ServicesToLoad.at(i)->getGUI();
155	currentSizes[VIEWPLITTERINDEX] -= lastInspectorSize.width();	94	if(wdgt)
156	m_Ui->splitter->setSizes(currentSizes);	95	{
157	}	96	wdgt->setAllowedAreas(Qt::AllDockWidgetAreas);
158		97	this->addDockWidget(Qt::TopDockWidgetArea,wdgt);
159	};	98	}
160		99	PythonQt::self()->getMainModule().addObject(ServicesToLoad.at(i)->serviceName(),(QObject*)ServicesToLoad.at(i));
161		100	}*/
162	connect(openLeftInspectorAction, &QAction::triggered,
163	[openInspector, openLeftInspectorAction](bool checked) {
164	openInspector(checked, false, openLeftInspectorAction);
165	});
166	connect(openRightInspectorAction, &QAction::triggered,
167	[openInspector, openRightInspectorAction](bool checked) {
168	openInspector(checked, true, openRightInspectorAction);
169	});
170
171	// //// //
172	// Menu //
173	// //// //
174	this->menuBar()->addAction(tr("File"));
175	auto toolsMenu = this->menuBar()->addMenu(tr("Tools"));
176	toolsMenu->addAction(tr("Settings..."), [this]() {
177	// Loads settings
178	impl->m_SettingsDialog->loadSettings();
179
180	// Open settings dialog and save settings if the dialog is accepted
181	if (impl->m_SettingsDialog->exec() == QDialog::Accepted) {
182	impl->m_SettingsDialog->saveSettings();
183	}
184
185	});
186
187	auto mainToolBar = this->addToolBar(QStringLiteral("MainToolBar"));
188
189	auto timeWidget = new TimeWidget{};
190	mainToolBar->addWidget(timeWidget);
191
192	// //////// //
193	// Settings //
194	// //////// //
195
196	// Registers "general settings" widget to the settings dialog
197	impl->m_SettingsDialog->registerWidget(QStringLiteral("General"),
198	impl->m_GeneralSettingsWidget);
199
200	// /////////// //
201	// Connections //
202	// /////////// //
203
204	// Controllers / controllers connections
205	connect(&sqpApp->timeController(), SIGNAL(timeUpdated(SqpRange)), &sqpApp->variableController(),
206	SLOT(onDateTimeOnSelection(SqpRange)));
207
208	// Widgets / controllers connections
209
210	// DataSource
211	connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem *)),
212	m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem *)));
213
214	// Time
215	connect(timeWidget, SIGNAL(timeUpdated(SqpRange)), &sqpApp->timeController(),
216	SLOT(onTimeToUpdate(SqpRange)));
217
218	// Visualization
219	connect(&sqpApp->visualizationController(),
220	SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), m_Ui->view,
221	SLOT(onVariableAboutToBeDeleted(std::shared_ptr<Variable>)));
222
223	connect(&sqpApp->visualizationController(),
224	SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)), m_Ui->view,
225	SLOT(onRangeChanged(std::shared_ptr<Variable>, const SqpRange &)));
226
227	// Widgets / widgets connections
228
229	// For the following connections, we use DirectConnection to allow each widget that can
230	// potentially attach a menu to the variable's menu to do so before this menu is displayed.
231	// The order of connections is also important, since it determines the order in which each
232	// widget will attach its menu
233	connect(
234	m_Ui->variableInspectorWidget,
235	SIGNAL(tableMenuAboutToBeDisplayed(QMenu *, const QVector<std::shared_ptr<Variable> > &)),
236	m_Ui->view, SLOT(attachVariableMenu(QMenu *, const QVector<std::shared_ptr<Variable> > &)),
237	Qt::DirectConnection);
238	}	101	}
239		102
240	MainWindow::~MainWindow()	103	MainWindow::~MainWindow()
241	{	104	{
242	}	105	}
243		106
		107
244	void MainWindow::changeEvent(QEvent *e)	108	void MainWindow::changeEvent(QEvent *e)
245	{	109	{
246	QMainWindow::changeEvent(e);	110	QMainWindow::changeEvent(e);

app/src/main.cpp ~~app/src/Main.cpp~~ renamed +1 -43

@@ -19,26 +19,12
19	/*-- Author : Alexis Jeandet	19	/*-- Author : Alexis Jeandet
20	-- Mail : alexis.jeandet@member.fsf.org	20	-- Mail : alexis.jeandet@member.fsf.org
21	----------------------------------------------------------------------------*/	21	----------------------------------------------------------------------------*/
22	#include "~~MainW~~indow.h"	22	#include "mainwindow.h"
23	#include <QProcessEnvironment>	23	#include <QProcessEnvironment>
24	#include <QThread>	24	#include <QThread>
25	#include <SqpApplication.h>	25	#include <SqpApplication.h>
26	#include <qglobal.h>	26	#include <qglobal.h>
27		27
28	#include <Plugin/PluginManager.h>
29	#include <QDir>
30
31	#include <QLoggingCategory>
32
33	Q_LOGGING_CATEGORY(LOG_Main, "Main")
34
35	namespace {
36
37	const auto PLUGIN_DIRECTORY_NAME = QStringLiteral("plugins");
38
39
40	} // namespace
41
42	int main(int argc, char *argv[])	28	int main(int argc, char *argv[])
43	{	29	{
44	SqpApplication a{argc, argv};	30	SqpApplication a{argc, argv};
@@ -48,33 +34,5 int main(int argc, char *argv[])
48	MainWindow w;	34	MainWindow w;
49	w.show();	35	w.show();
50		36
51	// Loads plugins
52	auto pluginDir = QDir{a.applicationDirPath()};
53	auto pluginLookupPath = {
54	a.applicationDirPath(),
55	a.applicationDirPath() + "/" + PLUGIN_DIRECTORY_NAME,
56	a.applicationDirPath() + "/../lib64/SciQlop",
57	a.applicationDirPath() + "/../lib64/sciqlop",
58	a.applicationDirPath() + "/../lib/SciQlop",
59	a.applicationDirPath() + "/../lib/sciqlop",
60	a.applicationDirPath() + "/../plugins",
61	};
62
63	#if _WIN32 \|\| _WIN64
64	pluginDir.mkdir(PLUGIN_DIRECTORY_NAME);
65	pluginDir.cd(PLUGIN_DIRECTORY_NAME);
66	#endif
67
68	PluginManager pluginManager{};
69
70	for (auto &&path : pluginLookupPath) {
71	QDir directory{path};
72	if (directory.exists()) {
73	qCDebug(LOG_Main())
74	<< QObject::tr("Plugin directory: %1").arg(directory.absolutePath());
75	pluginManager.loadPlugins(directory);
76	}
77	}
78
79	return a.exec();	37	return a.exec();
80	}	38	}

app/ui/MainWindow.ui +127 -83

@@ -11,7 +11,7
11	</rect>	11	</rect>
12	</property>	12	</property>
13	<property name="windowTitle">	13	<property name="windowTitle">
14	<string>~~SciQlop v0.0.1~~</string>	14	<string>QLop</string>
15	</property>	15	</property>
16	<property name="dockNestingEnabled">	16	<property name="dockNestingEnabled">
17	<bool>true</bool>	17	<bool>true</bool>
@@ -34,7 +34,7
34	</property>	34	</property>
35	<layout class="QHBoxLayout" name="horizontalLayout">	35	<layout class="QHBoxLayout" name="horizontalLayout">
36	<property name="spacing">	36	<property name="spacing">
37	<number>0</number>	37	<number>3</number>
38	</property>	38	</property>
39	<property name="leftMargin">	39	<property name="leftMargin">
40	<number>0</number>	40	<number>0</number>
@@ -49,73 +49,129
49	<number>0</number>	49	<number>0</number>
50	</property>	50	</property>
51	<item>	51	<item>
52	<widget class="Q~~Splitter" name="splitter~~">	52	<widget class="QWidget" name="leftInspectorWidget" native="true">
53	<property name="orientation">	53	<layout class="QHBoxLayout" name="horizontalLayout_2">
54	<enum>Qt::Horizontal</enum>	54	<property name="spacing">
55	</property>	55	<number>3</number>
56	<widget class="QWidget" name="leftMainInspectorWidget" native="true">	56	</property>
57	<layout class="QVBoxLayout" name="verticalLayout">	57	<property name="leftMargin">
58	<property name="spacing">	58	<number>0</number>
59	<number>0</number>	59	</property>
60	</property>	60	<property name="topMargin">
61	<property name="leftMargin">	61	<number>0</number>
62	<number>0</number>
63	</property>
64	<property name="topMargin">
65	<number>0</number>
66	</property>
67	<property name="rightMargin">
68	<number>0</number>
69	</property>
70	<property name="bottomMargin">
71	<number>0</number>
72	</property>
73	<item>
74	<widget class="DataSourceWidget" name="dataSourceWidget" native="true"/>
75	</item>
76	<item>
77	<widget class="QWidget" name="dateTimeWidget" native="true"/>
78	</item>
79	<item>
80	<widget class="VariableInspectorWidget" name="variableInspectorWidget" native="true"/>
81	</item>
82	</layout>
83	</widget>
84	<widget class="SqpSidePane" name="leftInspectorSidePane" native="true"/>
85	<widget class="VisualizationWidget" name="view" native="true">
86	<property name="sizePolicy">
87	<sizepolicy hsizetype="Expanding" vsizetype="Preferred">
88	<horstretch>0</horstretch>
89	<verstretch>0</verstretch>
90	</sizepolicy>
91	</property>	62	</property>
92	</widget>	63	<property name="rightMargin">
93	<widget class="SqpSidePane" name="rightInspectorSidePane" native="true"/>	64	<number>0</number>
94	<widget class="QWidget" name="rightMainInspectorWidget" native="true">	65	</property>
95	<layout class="QVBoxLayout" name="verticalLayout_3">	66	<property name="bottomMargin">
96	<property name="spacing">	67	<number>0</number>
97	<number>0</number>	68	</property>
98	~~</property~~>	69	<item>
99	<property name="leftMargin">	70	<widget class="QWidget" name="widget" native="true">
100	<number>0</number>	71	<layout class="QVBoxLayout" name="verticalLayout">
101	</property>	72	<property name="spacing">
102	<property name="topMargin">	73	<number>3</number>
103	<number>0</number>	74	</property>
104	</property>	75	<property name="leftMargin">
105	<property name="rightMargin">	76	<number>0</number>
106	<number>0</number>	77	</property>
107	</property>	78	<property name="topMargin">
108	<property name="bottomMargin">	79	<number>0</number>
109	<number>0</number>	80	</property>
110	</property>	81	<property name="rightMargin">
111	<item>	82	<number>0</number>
112	<widget class="QWidget" name="commonPropertyInspectorWidget" native="true"/>	83	</property>
113	</item>	84	<property name="bottomMargin">
114	<item>	85	<number>0</number>
115	<widget class="DataSourceWidget" name="catalogWidget" native="true"/>	86	</property>
116	</item>	87	<item>
117	</layout>	88	<widget class="QWidget" name="dateSourceWidget" native="true"/>
118	~~</widget~~>	89	</item>
		90	<item>
		91	<widget class="QWidget" name="dateTimeWidget" native="true"/>
		92	</item>
		93	<item>
		94	<widget class="QWidget" name="variableInspectorWidget" native="true"/>
		95	</item>
		96	</layout>
		97	</widget>
		98	</item>
		99	<item>
		100	<widget class="SqpSidePane" name="leftInspectorSidePane" native="true">
		101	<layout class="QVBoxLayout" name="verticalLayout_2">
		102	<property name="spacing">
		103	<number>3</number>
		104	</property>
		105	<property name="leftMargin">
		106	<number>0</number>
		107	</property>
		108	<property name="topMargin">
		109	<number>0</number>
		110	</property>
		111	<property name="rightMargin">
		112	<number>0</number>
		113	</property>
		114	<property name="bottomMargin">
		115	<number>0</number>
		116	</property>
		117	</layout>
		118	</widget>
		119	</item>
		120	</layout>
		121	</widget>
		122	</item>
		123	<item>
		124	<widget class="VisualizationWidget" name="view" native="true"/>
		125	</item>
		126	<item>
		127	<widget class="QWidget" name="rightInspectorWidget" native="true">
		128	<layout class="QHBoxLayout" name="horizontalLayout_3">
		129	<property name="spacing">
		130	<number>3</number>
		131	</property>
		132	<property name="leftMargin">
		133	<number>0</number>
		134	</property>
		135	<property name="topMargin">
		136	<number>0</number>
		137	</property>
		138	<property name="rightMargin">
		139	<number>0</number>
		140	</property>
		141	<property name="bottomMargin">
		142	<number>0</number>
		143	</property>
		144	<item>
		145	<widget class="SqpSidePane" name="rightInspectorSidePane" native="true"/>
		146	</item>
		147	<item>
		148	<widget class="QWidget" name="widget_2" native="true">
		149	<layout class="QVBoxLayout" name="verticalLayout_3">
		150	<property name="spacing">
		151	<number>3</number>
		152	</property>
		153	<property name="leftMargin">
		154	<number>0</number>
		155	</property>
		156	<property name="topMargin">
		157	<number>0</number>
		158	</property>
		159	<property name="rightMargin">
		160	<number>0</number>
		161	</property>
		162	<property name="bottomMargin">
		163	<number>0</number>
		164	</property>
		165	<item>
		166	<widget class="QWidget" name="commonPropertyInspectorWidget" native="true"/>
		167	</item>
		168	<item>
		169	<widget class="QWidget" name="catalogWidget" native="true"/>
		170	</item>
		171	</layout>
		172	</widget>
		173	</item>
		174	</layout>
119	</widget>	175	</widget>
120	</item>	176	</item>
121	</layout>	177	</layout>
@@ -126,7 +182,7
126	<x>0</x>	182	<x>0</x>
127	<y>0</y>	183	<y>0</y>
128	<width>800</width>	184	<width>800</width>
129	<height>28</height>	185	<height>26</height>
130	</rect>	186	</rect>
131	</property>	187	</property>
132	</widget>	188	</widget>
@@ -137,25 +193,13
137	<customwidget>	193	<customwidget>
138	<class>VisualizationWidget</class>	194	<class>VisualizationWidget</class>
139	<extends>QWidget</extends>	195	<extends>QWidget</extends>
140	<header location="global">Visualization/VisualizationWidget.h</header>	196	<header location="global">visualization/VisualizationWidget.h</header>
141	<container>1</container>	197	<container>1</container>
142	</customwidget>	198	</customwidget>
143	<customwidget>	199	<customwidget>
144	<class>SqpSidePane</class>	200	<class>SqpSidePane</class>
145	<extends>QWidget</extends>	201	<extends>QWidget</extends>
146	<header location="global">~~SideP~~ane/SqpSidePane.h</header>	202	<header location="global">sidepane/SqpSidePane.h</header>
147	<container>1</container>
148	</customwidget>
149	<customwidget>
150	<class>DataSourceWidget</class>
151	<extends>QWidget</extends>
152	<header location="global">DataSource/DataSourceWidget.h</header>
153	<container>1</container>
154	</customwidget>
155	<customwidget>
156	<class>VariableInspectorWidget</class>
157	<extends>QWidget</extends>
158	<header location="global">Variable/VariableInspectorWidget.h</header>
159	<container>1</container>	203	<container>1</container>
160	</customwidget>	204	</customwidget>
161	</customwidgets>	205	</customwidgets>

app/vera-exclusions/exclusions.txt 0 -2

             # Ignore false positive relative to App macro
             \.h:\d+:.IPSIS_S04.*found: Ui
-            # Ignore false positive relative to macros
-            Main\.cpp:\d+:.*IPSIS_S04_VARIABLE.*found: (__ppc64__)
  No newline at end of file

cmake/sciqlop.cmake +1 -1

             #
             # Configure the compiler
             #
-            #INCLUDE("cmake/compiler/compiler.cmake")
+            INCLUDE("cmake/compiler/compiler.cmake")
             #
             # Find all necessary dependencies

cmake/sciqlop_applications.cmake +14 -19

@@ -1,3 +1,17
		1	#
		2	# Sciqlop_modules.cmake
		3	#
		4	# Set ouptut directories
		5	#
		6	SET (EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/dist)
		7	SET (LIBRARY_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/dist)
		8	IF (UNIX)
		9	SET (CONFIG_OUTPUT_PATH $ENV{HOME}/.config/QtProject)
		10	ELSEIF(WIN32)
		11	SET (CONFIG_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/dist/app/QtProject)
		12	ELSE()
		13	SET (CONFIG_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/dist)
		14	ENDIF()
1		15
2	if(BUILD_TESTS)	16	if(BUILD_TESTS)
3	INCLUDE ("cmake/sciqlop_code_coverage.cmake")	17	INCLUDE ("cmake/sciqlop_code_coverage.cmake")
@@ -21,25 +35,6 ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/gui")
21		35
22	ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/app")	36	ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/app")
23		37
24	OPTION (BUILD_PLUGINS "Build the plugins" OFF)
25	IF(BUILD_PLUGINS)
26	set(sciqlop-mockplugin_DIR "${CMAKE_SOURCE_DIR}/plugins/mockplugin/cmake")
27	set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${sciqlop-mockplugin_DIR}")
28	ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/plugins/mockplugin")
29
30	set(sciqlop-amda_DIR "${CMAKE_SOURCE_DIR}/plugins/amda/cmake")
31	set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${sciqlop-amda_DIR}")
32	ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/plugins/amda")
33
34	# Temporary target to copy to plugins dir
35	find_package(sciqlop-mockplugin)
36	find_package(sciqlop-amda)
37	ADD_CUSTOM_TARGET(plugins
38	COMMAND ${CMAKE_COMMAND} -E copy ${SCIQLOP-MOCKPLUGIN_LIBRARIES} "${LIBRARY_OUTPUT_PATH}/plugins/${SCIQLOP-MOCKPLUGIN_LIBRARIES_NAME}"
39	COMMAND ${CMAKE_COMMAND} -E copy ${SCIQLOP-AMDA_LIBRARIES} "${LIBRARY_OUTPUT_PATH}/plugins/${SCIQLOP-AMDA_LIBRARIES_NAME}"
40	)
41	ENDIF(BUILD_PLUGINS)
42
43	# LOGGER	38	# LOGGER
44	set(QTLOGGING_INI_FILE "${CMAKE_SOURCE_DIR}/config/QtProject/qtlogging.ini")	39	set(QTLOGGING_INI_FILE "${CMAKE_SOURCE_DIR}/config/QtProject/qtlogging.ini")
45	FILE(COPY ${QTLOGGING_INI_FILE} DESTINATION ${CONFIG_OUTPUT_PATH})	40	FILE(COPY ${QTLOGGING_INI_FILE} DESTINATION ${CONFIG_OUTPUT_PATH})

cmake/sciqlop_package.cmake +3 -2

             SET (CPACK_PACKAGE_VERSION_MINOR "${SCIQLOP_VERSION_MINOR}")
             SET (CPACK_PACKAGE_VERSION_PATCH "${SCIQLOP_VERSION_PATCH}${SCIQLOP_VERSION_SUFFIX}")
             SET (CPACK_PACKAGE_VERSION "${SCIQLOP_VERSION}")
-            SET (CPACK_RESOURCE_FILE_LICENSE ${CMAKE_SOURCE_DIR}/COPYING)
+            SET (CPACK_RESOURCE_FILE_LICENSE ${CMAKE_SOURCE_DIR}/LICENSE)
             SET (CPACK_PACKAGE_CONTACT "nicolas.aunai@lpp.polytechnique.fr")
             SET(CPACK_PACKAGE_DESCRIPTION_FILE ${CMAKE_CURRENT_SOURCE_DIR}/README.md)
             # SET(CPACK_RESOURCE_FILE_WELCOME ${CMAKE_CURRENT_SOURCE_DIR}/WARN.txt)
-            SET(CPACK_RESOURCE_FILE_LICENSE ${CMAKE_CURRENT_SOURCE_DIR}/COPYING)
+            SET(CPACK_RESOURCE_FILE_LICENSE ${CMAKE_CURRENT_SOURCE_DIR}/LICENSE)
             # SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY ${PROJECT_NAME}-${PROJECT_VERSION})
             SET(FULLBUILD ON)
             SET(CPACK_PACKAGE_EXECUTABLES ${CPACK_PACKAGE_NAME} ${CPACK_PACKAGE_NAME})
             set(CPACK_PACKAGE_INSTALL_DIRECTORY ${CPACK_PACKAGE_NAME})
+            message("exepath" ${CPACK_PACKAGE_INSTALL_DIRECTORY})
             if (WIN32)
                SET(CPACK_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR})

cmake/sciqlop_package_qt.cmake +1 -1

             #ENDFOREACH()
             EXECUTE_PROCESS(
-            COMMAND windeployqt ${WINDEPLOYQT_ARGS} -printsupport ${SCIQLOP_EXE_LOCATION}
+            COMMAND windeployqt ${WINDEPLOYQT_ARGS} ${SCIQLOP_EXE_LOCATION}
             OUTPUT_VARIABLE QT_FILES
             )

cmake/sciqlop_params.cmake +9 -51

@@ -44,30 +44,6 else()
44	set(libRootDirForceValue)	44	set(libRootDirForceValue)
45	endif()	45	endif()
46		46
47	#
48	# Sciqlop_modules.cmake
49	#
50	# Set ouptut directories
51	#
52	IF (UNIX)
53	# 32 or 64 bits compiler
54	IF( CMAKE_SIZEOF_VOID_P EQUAL 8 )
55	SET(defaultLib "lib64/sciqlop")
56	ELSE()
57	SET(defaultLib "lib/sciqlop")
58	ENDIF()
59	SET (EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/bin)
60	SET (CONFIG_OUTPUT_PATH $ENV{HOME}/.config/QtProject)
61	SET (LIBRARY_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/${defaultLib})
62	ELSEIF(WIN32)
63	SET (EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/dist)
64	SET (LIBRARY_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/dist)
65	SET (CONFIG_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/dist/app/QtProject)
66	ELSE()
67	SET (EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/dist)
68	SET (CONFIG_OUTPUT_PATH $ENV{HOME}/.config/QtProject)
69	SET (LIBRARY_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/dist)
70	ENDIF()
71		47
72		48
73	#	49	#
@@ -78,51 +54,33 OPTION (BUILD_SHARED_LIBS "Build the shared libraries" ON)
78	# Generate position independant code (-fPIC)	54	# Generate position independant code (-fPIC)
79	SET(CMAKE_POSITION_INDEPENDENT_CODE TRUE)	55	SET(CMAKE_POSITION_INDEPENDENT_CODE TRUE)
80		56
81		57	#
82		58	# Configure installation directories
83	# Configuration for make install	59	#
84
85	set(PROJECT_PLUGIN_PREFIX "SciQlop")
86
87	IF (UNIX)	60	IF (UNIX)
88	SET(CMAKE_INSTALL_PREFIX "/usr/local/${PROJECT_PLUGIN_PREFIX}")
89	SET(defaultBin "bin")	61	SET(defaultBin "bin")
90	SET(defaultInc "include/sciqlop")	62	SET(defaultInc "include/sciqlop")
91		63
92	# 32 or 64 bits compiler	64	# 32 or 64 bits compiler
93	IF( CMAKE_SIZEOF_VOID_P EQUAL 8 )	65	IF( CMAKE_SIZEOF_VOID_P EQUAL 8 )
94	SET(defaultLib "lib64")	66	SET(defaultLib "lib64/sciqlop")
95	SET(defaultPluginsLib "lib64/${PROJECT_PLUGIN_PREFIX}")
96	ELSE()	67	ELSE()
97	SET(defaultLib "lib/")	68	SET(defaultLib "lib/sciqlop")
98	SET(defaultPluginsLib "lib/${PROJECT_PLUGIN_PREFIX}")
99	ENDIF()	69	ENDIF()
100		70
101	SET(defaultDoc "share/docs/~~${PROJECT_PLUGIN_PREFIX}~~")	71	SET(defaultDoc "share/docs/sciqlop")
102	ELSE()	72	ELSE()
103	SET(defaultBin "bin")	73	SET(defaultBin "bin")
104	SET(defaultInc "include/~~${PROJECT_PLUGIN_PREFIX}~~")	74	SET(defaultInc "include/sciqlop")
105	SET(defaultLib "lib")	75	SET(defaultLib "lib/sciqlop")
106	SET(defaultPluginsLib "lib/${PROJECT_PLUGIN_PREFIX}")	76	SET(defaultDoc "docs/sciqlop")
107	SET(defaultDoc "docs/${PROJECT_PLUGIN_PREFIX}")
108	ENDIF()	77	ENDIF()
109		78
110	SET(INSTALL_BINARY_DIR "${defaultBin}" CACHE STRING	79	SET(INSTALL_BINARY_DIR "${defaultBin}" CACHE STRING
111	"Installation directory for binaries")	80	"Installation directory for binaries")
112	SET(INSTALL_LIBRARY_DIR "${defaultLib}" CACHE STRING	81	SET(INSTALL_LIBRARY_DIR "${defaultLib}" CACHE STRING
113	"Installation directory for libraries")	82	"Installation directory for libraries")
114	SET(INSTALL_PLUGINS_LIBRARY_DIR "${defaultPluginsLib}" CACHE STRING
115	"Installation directory for libraries")
116	SET(INSTALL_INCLUDE_DIR "${defaultInc}" CACHE STRING	83	SET(INSTALL_INCLUDE_DIR "${defaultInc}" CACHE STRING
117	"Installation directory for headers")	84	"Installation directory for headers")
118	SET(INSTALL_DOCUMENTATION_DIR "${defaultDoc}" CACHE STRING	85	SET(INSTALL_DOCUMENTATION_DIR "${defaultDoc}" CACHE STRING
119	"Installation directory for documentations")	86	"Installation directory for documentations")
120
121
122	# Set the rpath when installing
123	SET(CMAKE_SKIP_BUILD_RPATH FALSE)
124	SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
125	SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${INSTALL_LIBRARY_DIR}")
126	SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
127
128	message("Install RPATH: ${CMAKE_INSTALL_PREFIX}/${INSTALL_LIBRARY_DIR}")

core/CMakeLists.txt +3 -12

             #
             # Find Qt modules
             #
-            SCIQLOP_FIND_QT(Core Network)
+            SCIQLOP_FIND_QT(Core)
             #
             # Compile the library library
             #
-            ADD_DEFINITIONS(-DCORE_LIB)
             FILE (GLOB_RECURSE MODULE_SOURCES
                     ${INCLUDES_DIR}/*.h
                     ${SOURCES_DIR}/*.c
             set_property(TARGET ${SQPCORE_LIBRARY_NAME} PROPERTY CXX_STANDARD 14)
             set_property(TARGET ${SQPCORE_LIBRARY_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
             TARGET_LINK_LIBRARIES(${SQPCORE_LIBRARY_NAME})
-            qt5_use_modules(${SQPCORE_LIBRARY_NAME} Core Network)
+            qt5_use_modules(${SQPCORE_LIBRARY_NAME} Core)
-            INSTALL(TARGETS ${SQPCORE_LIBRARY_NAME}
-              RUNTIME DESTINATION ${INSTALL_BINARY_DIR}
-              LIBRARY DESTINATION ${INSTALL_LIBRARY_DIR}
-              ARCHIVE DESTINATION ${INSTALL_LIBRARY_DIR}
             # From cmake documentation: http://www.cmake.org/cmake/help/v3.0/manual/cmake-buildsystem.7.html
             # Entries in the COMPILE_DEFINITIONS are prefixed with -D or /D and added to the compile line in an unspecified order.
             # The DEFINE_SYMBOL target property is also added as a compile definition as a special convenience case for SHARED and MODULE library targets

core/include/Common/spimpl.h +14 -12

             template <class T, class D, class C>
             struct is_default_manageable
-                : public std::integral_constant<bool, std::is_same<D, default_deleter_t<T> >::value
+                : public std::integral_constant<bool,
-                                                          && std::is_same<C, default_copier_t<T> >::value> {
+                                                std::is_same<D, default_deleter_t<T> >::value
+                                                    && std::is_same<C, default_copier_t<T> >::value> {
             };
             }
                 }
                 template <class U>
-                impl_ptr(U *u, typename std::enable_if<std::is_convertible<U *, pointer>::value
+                impl_ptr(U *u,
-                                                           && is_default_manageable::value,
+                         typename std::enable_if<std::is_convertible<U *, pointer>::value
-                                                       dummy_t_>::type
+                                                     && is_default_manageable::value,
-                               = dummy_t_()) SPIMPL_NOEXCEPT
+                                                 dummy_t_>::type
+                         = dummy_t_()) SPIMPL_NOEXCEPT
                     : impl_ptr(u, &details::default_delete<T>, &details::default_copy<T>)
                 {
                 }
             #ifdef SPIMPL_HAS_AUTO_PTR
                 template <class U>
-                impl_ptr(std::auto_ptr<U> &&u, typename std::enable_if<std::is_convertible<U *, pointer>::value
+                impl_ptr(std::auto_ptr<U> &&u,
-                                                                           && is_default_manageable::value,
+                         typename std::enable_if<std::is_convertible<U *, pointer>::value
-                                                                       dummy_t_>::type
+                                                     && is_default_manageable::value,
-                                               = dummy_t_()) SPIMPL_NOEXCEPT
+                                                 dummy_t_>::type
-                    : ptr_(u.release(), &details::default_delete<T>),
+                         = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(u.release(), &details::default_delete<T>),
-                      copier_(&details::default_copy<T>)
+                                                         copier_(&details::default_copy<T>)
                 {
                 }
             #endif

core/include/DataSource/DataSourceController.h +3 -36

             #ifndef SCIQLOP_DATASOURCECONTROLLER_H
             #define SCIQLOP_DATASOURCECONTROLLER_H
-            #include "CoreGlobal.h"
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSourceController)
             class DataSourceItem;
-            class IDataProvider;
             /**
              * @brief The DataSourceController class aims to make the link between SciQlop and its plugins. This
              * source) then others specifics method will be able to access it. You can load a data source driver
              * plugin then create a data source.
              */
-            class SCIQLOP_CORE_EXPORT DataSourceController : public QObject {
+            class DataSourceController : public QObject {
                 Q_OBJECT
             public:
                 explicit DataSourceController(QObject *parent = 0);
                  * Sets the structure of a data source. The controller takes ownership of the structure.
                  * @param dataSourceUid the unique id with which the data source has been registered into the
                  * controller. If it is invalid, the method has no effect.
-                 * @param dataSourceItem the structure of the data source. It must be not null to be registered
+                 * @param dataSourceItem the structure of the data source
                  * @sa registerDataSource()
                  */
                 void setDataSourceItem(const QUuid &dataSourceUid,
                                        std::unique_ptr<DataSourceItem> dataSourceItem) noexcept;
-                /**
-                 * Sets the data provider used to retrieve data from of a data source. The controller takes
-                 * ownership of the provider.
-                 * @param dataSourceUid the unique id with which the data source has been registered into the
-                 * controller. If it is invalid, the method has no effect.
-                 * @param dataProvider the provider of the data source
-                 * @sa registerDataSource()
-                 */
-                void setDataProvider(const QUuid &dataSourceUid,
-                                     std::unique_ptr<IDataProvider> dataProvider) noexcept;
-                /**
-                 * Loads an item (product) as a variable in SciQlop
-                 * @param dataSourceUid the unique id of the data source containing the item. It is used to get
-                 * the data provider associated to the data source, and pass it to for the variable creation
-                 * @param productItem the item to load
-                 */
-                void loadProductItem(const QUuid &dataSourceUid, const DataSourceItem &productItem) noexcept;
             public slots:
                 /// Manage init/end of the controller
                 void initialize();
             signals:
                 /// Signal emitted when a structure has been set for a data source
-                void dataSourceItemSet(DataSourceItem *dataSourceItem);
+                void dataSourceItemSet(const DataSourceItem &dataSourceItem);
-                /**
-                 * Signal emitted when a variable creation is asked for a product
-                 * @param variableName the name of the variable
-                 * @param variableMetadata the metadata of the variable
-                 * @param variableProvider the provider that will be used to retrieve the data of the variable
-                 * (can be null)
-                 */
-                void variableCreationRequested(const QString &variableName,
-                                               const QVariantHash &variableMetadata,
-                                               std::shared_ptr<IDataProvider> variableProvider);
             private:
                 void waitForFinish();

core/include/DataSource/DataSourceItem.h +6 -56

@@ -1,43 +1,20
1	#ifndef SCIQLOP_DATASOURCEITEM_H	1	#ifndef SCIQLOP_DATASOURCEITEM_H
2	#define SCIQLOP_DATASOURCEITEM_H	2	#define SCIQLOP_DATASOURCEITEM_H
3		3
4	#include "CoreGlobal.h"
5
6	#include <Common/spimpl.h>	4	#include <Common/spimpl.h>
7		5
8	#include <QVariant>	6	#include <QVariant>
9	#include <QVector>	7	#include <QVector>
10		8
11	class DataSourceItemAction;
12
13	/**
14	* Possible types of an item
15	*/
16	enum class DataSourceItemType { NODE, PRODUCT, COMPONENT };
17
18	/**	9	/**
19	* @brief The DataSourceItem class aims to represent a structure element of a data source.	10	* @brief The DataSourceItem class aims to represent a structure element of a data source.
20	* A data source has a tree structure that is made up of a main DataSourceItem object (root)	11	* A data source has a tree structure that is made up of a main DataSourceItem object (root)
21	* containing other DataSourceItem objects (children).	12	* containing other DataSourceItem objects (children).
22	* For each DataSourceItem can be associated a set of data representing it.	13	* For each DataSourceItem can be associated a set of data representing it.
23	*/	14	*/
24	class ~~SCIQLOP_CORE_EXPORT~~ DataSourceItem {	15	class DataSourceItem {
25	public:	16	public:
26	/// Key associated with the name of the item	17	explicit DataSourceItem(QVector<QVariant> data = {});
27	static const QString NAME_DATA_KEY;
28
29	explicit DataSourceItem(DataSourceItemType type, const QString &name);
30	explicit DataSourceItem(DataSourceItemType type, QVariantHash data = {});
31
32	/// @return the actions of the item as a vector
33	QVector<DataSourceItemAction *> actions() const noexcept;
34
35	/**
36	* Adds an action to the item. The item takes ownership of the action, and the action is
37	* automatically associated to the item
38	* @param action the action to add
39	*/
40	void addAction(std::unique_ptr<DataSourceItemAction> action) noexcept;
41		18
42	/**	19	/**
43	* Adds a child to the item. The item takes ownership of the child.	20	* Adds a child to the item. The item takes ownership of the child.
@@ -55,18 +32,11 public:
55	int childCount() const noexcept;	32	int childCount() const noexcept;
56		33
57	/**	34	/**
58	* Get the data associated to a ~~key~~	35	* Get the data associated to an index
59	* @param ~~key the key~~ to search	36	* @param dataIndex the index to search
60	* @return the data found if ~~key~~ is valid, default QVariant otherwise	37	* @return the data found if index is valid, default QVariant otherwise
61	*/	38	*/
62	QVariant data(~~cons~~t ~~QString~~ &~~key~~) const noexcept;	39	QVariant data(int dataIndex) const noexcept;
63
64	/// Gets all data
65	QVariantHash data() const noexcept;
66
67	bool isRoot() const noexcept;
68
69	QString name() const noexcept;
70		40
71	/**	41	/**
72	* Get the item's parent	42	* Get the item's parent
@@ -74,26 +44,6 public:
74	*/	44	*/
75	DataSourceItem *parentItem() const noexcept;	45	DataSourceItem *parentItem() const noexcept;
76		46
77	/**
78	* Gets the item's root
79	* @return the top parent, the item itself if it's the root item
80	*/
81	const DataSourceItem &rootItem() const noexcept;
82
83	/**
84	* Sets or appends a value to a key
85	* @param key the key
86	* @param value the value
87	* @param append if true, the value is added to the values already existing for the key,
88	* otherwise it replaces the existing values
89	*/
90	void setData(const QString &key, const QVariant &value, bool append = false) noexcept;
91
92	DataSourceItemType type() const noexcept;
93
94	bool operator==(const DataSourceItem &other);
95	bool operator!=(const DataSourceItem &other);
96
97	private:	47	private:
98	class DataSourceItemPrivate;	48	class DataSourceItemPrivate;
99	spimpl::unique_impl_ptr<DataSourceItemPrivate> impl;	49	spimpl::unique_impl_ptr<DataSourceItemPrivate> impl;

core/include/Plugin/PluginManager.h +1 -3

             #ifndef SCIQLOP_PLUGINMANAGER_H
             #define SCIQLOP_PLUGINMANAGER_H
-            #include "CoreGlobal.h"
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             /**
              * @brief The PluginManager class aims to handle the plugins loaded dynamically into SciQLop.
              */
-            class SCIQLOP_CORE_EXPORT PluginManager {
+            class PluginManager {
             public:
                 explicit PluginManager();

core/include/Visualization/VisualizationController.h +1 -13

             #ifndef SCIQLOP_VISUALIZATIONCONTROLLER_H
             #define SCIQLOP_VISUALIZATIONCONTROLLER_H
-            #include "CoreGlobal.h"
-            #include <Data/SqpRange.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationController)
             class DataSourceItem;
-            class Variable;
             /**
              * @brief The VisualizationController class aims to make the link between SciQlop and its plugins.
              * plugin source) then others specifics method will be able to access it. You can load a data source
              * driver plugin then create a data source.
              */
-            class SCIQLOP_CORE_EXPORT VisualizationController : public QObject {
+            class VisualizationController : public QObject {
                 Q_OBJECT
             public:
                 explicit VisualizationController(QObject *parent = 0);
                 virtual ~VisualizationController();
-            signals:
-                /// Signal emitted when a variable is about to be deleted from SciQlop
-                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:
                 /// Manage init/end of the controller
                 void initialize();

core/src/DataSource/DataSourceController.cpp +9 -74

@@ -1,7 +1,5
1	#include "DataSource/DataSourceController.h"	1	#include <DataSource/DataSourceController.h>
2	#include "DataSource/DataSourceItem.h"	2	#include <DataSource/DataSourceItem.h>
3
4	#include <Data/IDataProvider.h>
5		3
6	#include <QMutex>	4	#include <QMutex>
7	#include <QThread>	5	#include <QThread>
@@ -11,28 +9,6
11		9
12	Q_LOGGING_CATEGORY(LOG_DataSourceController, "DataSourceController")	10	Q_LOGGING_CATEGORY(LOG_DataSourceController, "DataSourceController")
13		11
14	namespace {
15
16	/**
17	* Builds the metadata of the variable that will be generated from the loading of an item
18	* @param dataSourceItem the data source item from which to generate the metadata
19	* @return the metadata of the variable
20	*/
21	QVariantHash variableMetadata(const DataSourceItem &dataSourceItem)
22	{
23	// Variable metadata contains...
24
25	// ... all metadata of the item
26	auto result = dataSourceItem.data();
27
28	// ... and the name of the plugin, recovered from root item
29	result.insert(QStringLiteral("plugin"), dataSourceItem.rootItem().name());
30
31	return result;
32	}
33
34	} // namespace
35
36	class DataSourceController::DataSourceControllerPrivate {	12	class DataSourceController::DataSourceControllerPrivate {
37	public:	13	public:
38	QMutex m_WorkingMutex;	14	QMutex m_WorkingMutex;
@@ -40,23 +16,19 public:
40	QHash<QUuid, QString> m_DataSources;	16	QHash<QUuid, QString> m_DataSources;
41	/// Data sources structures	17	/// Data sources structures
42	std::map<QUuid, std::unique_ptr<DataSourceItem> > m_DataSourceItems;	18	std::map<QUuid, std::unique_ptr<DataSourceItem> > m_DataSourceItems;
43	/// Data providers registered
44	/// @remarks Data providers are stored as shared_ptr as they can be sent to a variable and
45	/// continue to live without necessarily the data source controller
46	std::map<QUuid, std::shared_ptr<IDataProvider> > m_DataProviders;
47	};	19	};
48		20
49	DataSourceController::DataSourceController(QObject *parent)	21	DataSourceController::DataSourceController(QObject *parent)
50	: impl{spimpl::make_unique_impl<DataSourceControllerPrivate>()}	22	: impl{spimpl::make_unique_impl<DataSourceControllerPrivate>()}
51	{	23	{
52	qCDebug(LOG_DataSourceController()) << tr(~~"DataSourceController construction"~~)	24	qCDebug(LOG_DataSourceController())
53	<< QThread::currentThread();	25	<< tr("DataSourceController construction") << QThread::currentThread();
54	}	26	}
55		27
56	DataSourceController::~DataSourceController()	28	DataSourceController::~DataSourceController()
57	{	29	{
58	qCDebug(LOG_DataSourceController()) << tr(~~"DataSourceController destruction"~~)	30	qCDebug(LOG_DataSourceController())
59	<< QThread::currentThread();	31	<< tr("DataSourceController destruction") << QThread::currentThread();
60	this->waitForFinish();	32	this->waitForFinish();
61	}	33	}
62		34
@@ -71,20 +43,13 QUuid DataSourceController::registerDataSource(const QString &dataSourceName) no
71	void DataSourceController::setDataSourceItem(	43	void DataSourceController::setDataSourceItem(
72	const QUuid &dataSourceUid, std::unique_ptr<DataSourceItem> dataSourceItem) noexcept	44	const QUuid &dataSourceUid, std::unique_ptr<DataSourceItem> dataSourceItem) noexcept
73	{	45	{
74	if (!dataSourceItem) {
75	qCWarning(LOG_DataSourceController())
76	<< tr("Data source item can't be registered (null item)");
77	return;
78	}
79
80	if (impl->m_DataSources.contains(dataSourceUid)) {	46	if (impl->m_DataSources.contains(dataSourceUid)) {
81	// The data provider is implicitly converted to a shared_ptr
82	impl->m_DataSourceItems.insert(std::make_pair(dataSourceUid, std::move(dataSourceItem)));	47	impl->m_DataSourceItems.insert(std::make_pair(dataSourceUid, std::move(dataSourceItem)));
83		48
84	// Retrieves the data source item to emit the signal with it	49	// Retrieves the data source item to emit the signal with it
85	auto it = impl->m_DataSourceItems.find(dataSourceUid);	50	auto it = impl->m_DataSourceItems.find(dataSourceUid);
86	if (it != impl->m_DataSourceItems.end()) {	51	if (it != impl->m_DataSourceItems.end()) {
87	emit dataSourceItemSet(it->second.~~get~~());	52	emit dataSourceItemSet(*it->second);
88	}	53	}
89	}	54	}
90	else {	55	else {
@@ -94,40 +59,10 void DataSourceController::setDataSourceItem(
94	}	59	}
95	}	60	}
96		61
97	void DataSourceController::setDataProvider(const QUuid &dataSourceUid,
98	std::unique_ptr<IDataProvider> dataProvider) noexcept
99	{
100	if (impl->m_DataSources.contains(dataSourceUid)) {
101	impl->m_DataProviders.insert(std::make_pair(dataSourceUid, std::move(dataProvider)));
102	}
103	else {
104	qCWarning(LOG_DataSourceController()) << tr("Can't set data provider for uid %1 : no data "
105	"source has been registered with the uid")
106	.arg(dataSourceUid.toString());
107	}
108	}
109
110	void DataSourceController::loadProductItem(const QUuid &dataSourceUid,
111	const DataSourceItem &productItem) noexcept
112	{
113	if (productItem.type() == DataSourceItemType::PRODUCT
114	\|\| productItem.type() == DataSourceItemType::COMPONENT) {
115	/// Retrieves the data provider of the data source (if any)
116	auto it = impl->m_DataProviders.find(dataSourceUid);
117	auto dataProvider = (it != impl->m_DataProviders.end()) ? it->second : nullptr;
118
119	emit variableCreationRequested(productItem.name(), variableMetadata(productItem),
120	dataProvider);
121	}
122	else {
123	qCWarning(LOG_DataSourceController()) << tr("Can't load an item that is not a product");
124	}
125	}
126
127	void DataSourceController::initialize()	62	void DataSourceController::initialize()
128	{	63	{
129	qCDebug(LOG_DataSourceController()) << tr(~~"DataSourceController init"~~)	64	qCDebug(LOG_DataSourceController())
130	<< QThread::currentThread();	65	<< tr("DataSourceController init") << QThread::currentThread();
131	impl->m_WorkingMutex.lock();	66	impl->m_WorkingMutex.lock();
132	qCDebug(LOG_DataSourceController()) << tr("DataSourceController init END");	67	qCDebug(LOG_DataSourceController()) << tr("DataSourceController init END");
133	}	68	}

core/src/DataSource/DataSourceItem.cpp +7 -102

@@ -1,47 +1,21
1	#include <DataSource/DataSourceItem.h>	1	#include <DataSource/DataSourceItem.h>
2	#include <DataSource/DataSourceItemAction.h>
3		2
4	#include <QVector>	3	#include <QVector>
5		4
6	const QString DataSourceItem::NAME_DATA_KEY = QStringLiteral("name");
7
8	struct DataSourceItem::DataSourceItemPrivate {	5	struct DataSourceItem::DataSourceItemPrivate {
9	explicit DataSourceItemPrivate(~~DataSourceItemType~~ ~~type~~, ~~QVariantHash~~ data)	6	explicit DataSourceItemPrivate(QVector<QVariant> data)
10	: m_Parent{nullptr}, m_Children{}, ~~m_Type~~{~~type~~}, m_Data{std::move(data)}, ~~m_Actions~~{}	7	: m_Parent{nullptr}, m_Children{}, m_Data{std::move(data)}
11	{	8	{
12	}	9	}
13		10
14	DataSourceItem *m_Parent;	11	DataSourceItem *m_Parent;
15	std::vector<std::unique_ptr<DataSourceItem> > m_Children;	12	std::vector<std::unique_ptr<DataSourceItem> > m_Children;
16	DataSourceItemType m_Type;	13	QVector<QVariant> m_Data;
17	QVariantHash m_Data;
18	std::vector<std::unique_ptr<DataSourceItemAction> > m_Actions;
19	};	14	};
20		15
21	DataSourceItem::DataSourceItem(DataSourceItemType type, const QString &name)	16	DataSourceItem::DataSourceItem(QVector<QVariant> data)
22	: DataSourceItem{type, QVariantHash{{NAME_DATA_KEY, name}}}	17	: impl{spimpl::make_unique_impl<DataSourceItemPrivate>(data)}
23	{
24	}
25
26	DataSourceItem::DataSourceItem(DataSourceItemType type, QVariantHash data)
27	: impl{spimpl::make_unique_impl<DataSourceItemPrivate>(type, std::move(data))}
28	{
29	}
30
31	QVector<DataSourceItemAction *> DataSourceItem::actions() const noexcept
32	{
33	auto result = QVector<DataSourceItemAction *>{};
34
35	std::transform(std::cbegin(impl->m_Actions), std::cend(impl->m_Actions),
36	std::back_inserter(result), [](const auto &action) { return action.get(); });
37
38	return result;
39	}
40
41	void DataSourceItem::addAction(std::unique_ptr<DataSourceItemAction> action) noexcept
42	{	18	{
43	action->setDataSourceItem(this);
44	impl->m_Actions.push_back(std::move(action));
45	}	19	}
46		20
47	void DataSourceItem::appendChild(std::unique_ptr<DataSourceItem> child) noexcept	21	void DataSourceItem::appendChild(std::unique_ptr<DataSourceItem> child) noexcept
@@ -65,81 +39,12 int DataSourceItem::childCount() const noexcept
65	return impl->m_Children.size();	39	return impl->m_Children.size();
66	}	40	}
67		41
68	QVariant DataSourceItem::data(~~cons~~t ~~QString~~ &~~key~~) const noexcept	42	QVariant DataSourceItem::data(int dataIndex) const noexcept
69	{
70	return impl->m_Data.value(key);
71	}
72
73	QVariantHash DataSourceItem::data() const noexcept
74	{	43	{
75	return impl->m_Data;	44	return impl->m_Data.value(dataIndex);
76	}
77
78	bool DataSourceItem::isRoot() const noexcept
79	{
80	return impl->m_Parent == nullptr;
81	}
82
83	QString DataSourceItem::name() const noexcept
84	{
85	return data(NAME_DATA_KEY).toString();
86	}	45	}
87		46
88	DataSourceItem *DataSourceItem::parentItem() const noexcept	47	DataSourceItem *DataSourceItem::parentItem() const noexcept
89	{	48	{
90	return impl->m_Parent;	49	return impl->m_Parent;
91	}	50	}
92
93	const DataSourceItem &DataSourceItem::rootItem() const noexcept
94	{
95	return isRoot() ? *this : parentItem()->rootItem();
96	}
97
98	void DataSourceItem::setData(const QString &key, const QVariant &value, bool append) noexcept
99	{
100	auto it = impl->m_Data.constFind(key);
101	if (append && it != impl->m_Data.constEnd()) {
102	// Case of an existing value to which we want to add to the new value
103	if (it->canConvert<QVariantList>()) {
104	auto variantList = it->value<QVariantList>();
105	variantList.append(value);
106
107	impl->m_Data.insert(key, variantList);
108	}
109	else {
110	impl->m_Data.insert(key, QVariantList{*it, value});
111	}
112	}
113	else {
114	// Other cases :
115	// - new value in map OR
116	// - replacement of an existing value (not appending)
117	impl->m_Data.insert(key, value);
118	}
119	}
120
121	DataSourceItemType DataSourceItem::type() const noexcept
122	{
123	return impl->m_Type;
124	}
125
126	bool DataSourceItem::operator==(const DataSourceItem &other)
127	{
128	// Compares items' attributes
129	if (std::tie(impl->m_Type, impl->m_Data) == std::tie(other.impl->m_Type, other.impl->m_Data)) {
130	// Compares contents of items' children
131	return std::equal(std::cbegin(impl->m_Children), std::cend(impl->m_Children),
132	std::cbegin(other.impl->m_Children),
133	[](const auto &itemChild, const auto &otherChild) {
134	return itemChild == otherChild;
135	});
136	}
137	else {
138	return false;
139	}
140	}
141
142	bool DataSourceItem::operator!=(const DataSourceItem &other)
143	{
144	return !(*this == other);
145	}

core/src/Plugin/PluginManager.cpp +3 -9

@@ -106,15 +106,9 PluginManager::PluginManager() : impl{spimpl::make_unique_impl<PluginManagerPriv
106	void PluginManager::loadPlugins(const QDir &pluginDir)	106	void PluginManager::loadPlugins(const QDir &pluginDir)
107	{	107	{
108	// Load plugins	108	// Load plugins
109	auto pluginInfoList	109	auto pluginInfoList = pluginDir.entryInfoList(QDir::Files, QDir::Name);
110	= pluginDir.entryInfoList(QDir::Files \| QDir::Dirs \| QDir::NoDotAndDotDot, QDir::Name);	110	for (auto pluginInfo : qAsConst(pluginInfoList)) {
111	for (auto entryInfo : qAsConst(pluginInfoList)) {	111	impl->loadPlugin(pluginInfo.absoluteFilePath());
112	if (entryInfo.isDir()) {
113	this->loadPlugins(QDir{entryInfo.absoluteFilePath()});
114	}
115	else if (QLibrary::isLibrary(entryInfo.absoluteFilePath())) {
116	impl->loadPlugin(entryInfo.absoluteFilePath());
117	}
118	}	112	}
119	}	113	}
120		114

core/src/Visualization/VisualizationController.cpp +6 -8

             #include <Visualization/VisualizationController.h>
-            #include <Variable/Variable.h>
             #include <QMutex>
             #include <QThread>
             VisualizationController::VisualizationController(QObject *parent)
                     : impl{spimpl::make_unique_impl<VisualizationControllerPrivate>()}
             {
-                qCDebug(LOG_VisualizationController()) << tr("VisualizationController construction")
+                qCDebug(LOG_VisualizationController())
-                                                       << QThread::currentThread();
+                    << tr("VisualizationController construction") << QThread::currentThread();
             }
             VisualizationController::~VisualizationController()
             {
-                qCDebug(LOG_VisualizationController()) << tr("VisualizationController destruction")
+                qCDebug(LOG_VisualizationController())
-                                                       << QThread::currentThread();
+                    << tr("VisualizationController destruction") << QThread::currentThread();
                 this->waitForFinish();
             }
             void VisualizationController::initialize()
             {
-                qCDebug(LOG_VisualizationController()) << tr("VisualizationController init")
+                qCDebug(LOG_VisualizationController())
-                                                       << QThread::currentThread();
+                    << tr("VisualizationController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VisualizationController()) << tr("VisualizationController init END");
             }

core/tests/DataSource/TestDataSourceController.cpp +4 -4

                 DataSourceController dataSourceController{};
                 // Spy to test controllers' signals
-                QSignalSpy signalSpy{&dataSourceController, SIGNAL(dataSourceItemSet(DataSourceItem *))};
+                QSignalSpy signalSpy{&dataSourceController, SIGNAL(dataSourceItemSet(const DataSourceItem &))};
                 // Create a data source item
                 auto source1Name = QStringLiteral("Source1");
-                auto source1Item = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, source1Name);
+                auto source1Values = QVector<QVariant>{source1Name};
+                auto source1Item = std::make_unique<DataSourceItem>(std::move(source1Values));
                 // Add data source item to the controller and check that a signal has been emitted after setting
                 // data source item in the controller
                 // Try to a data source item with an unregistered uid and check that no signal has been emitted
                 auto unregisteredUid = QUuid::createUuid();
-                dataSourceController.setDataSourceItem(
+                dataSourceController.setDataSourceItem(unregisteredUid, std::make_unique<DataSourceItem>());
-                    unregisteredUid, std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT));
                 QCOMPARE(signalSpy.count(), 1);
             }

core/vera-exclusions/exclusions.txt 0 -49

@@ -1,52 +1,3
1	# On ignore toutes les règles vera++ pour le fichier spimpl	1	# On ignore toutes les règles vera++ pour le fichier spimpl
2	Common/spimpl\.h:\d+:.*	2	Common/spimpl\.h:\d+:.*
3		3
4	# Ignore false positive relative to two class definitions in a same file
5	ArrayData\.h:\d+:.IPSIS_S01.
6	ArrayDataIterator\.h:\d+:.IPSIS_S01.
7	DataSourceItem\.h:\d+:.IPSIS_S01.
8	DataSeries\.h:\d+:.IPSIS_S01.
9	DataSeriesIterator\.h:\d+:.IPSIS_S01.
10	DataSeriesMergeHelper\.h:\d+:.IPSIS_S01.
11
12	# Ignore false positive relative to a template class
13	ArrayData\.h:\d+:.IPSIS_S04_METHOD.found: push_back
14	ArrayData\.h:\d+:.IPSIS_S04_VARIABLE.found: (const_iterator)
15	ArrayData\.h:\d+:.IPSIS_S04_VARIABLE.found: (D)
16	ArrayData\.h:\d+:.IPSIS_S04_VARIABLE.found: (IC)
17	ArrayData\.h:\d+:.IPSIS_S04_NAMESPACE.found: (arraydata_detail)
18	ArrayData\.h:\d+:.IPSIS_S06.found: (D)
19	ArrayData\.h:\d+:.IPSIS_S06.found: (Dim)
20	ArrayData\.h:\d+:.IPSIS_S06.found: (IC)
21	ArrayData\.h:\d+:.IPSIS_S06.found: (IsConst)
22	DataSeries\.h:\d+:.IPSIS_S04_METHOD.found: LOG_DataSeries
23	DataSeries\.h:\d+:.IPSIS_S04_METHOD.found: push_back
24	DataSeries\.h:\d+:.IPSIS_S04_VARIABLE.
25	DataSeries\.h:\d+:.IPSIS_S04_NAMESPACE.found: (dataseries_detail)
26	DataSeries\.h:\d+:.IPSIS_S05.
27	DataSeries\.h:\d+:.IPSIS_S06.found: (value_type)
28	DataSeries\.h:\d+:.IPSIS_S06.found: (DataSeriesIteratorValue)
29	DataSeries\.h:\d+:.IPSIS_S06.found: (Dim)
30	DataSeries\.h:\d+:.IPSIS_S06.found: (IC)
31	DataSeries\.h:\d+:.IPSIS_S06.found: (IsConst)
32
33	# Ignore false positive relative to iterators
34	SqpIterator\.h:\d+:.IPSIS_S04_VARIABLE.found: (random_access_iterator_tag)
35	SqpIterator\.h:\d+:.IPSIS_S04_VARIABLE.found: (T)
36	SqpIterator\.h:\d+:.IPSIS_S04_VARIABLE.found: (ptrdiff_t)
37	SqpIterator\.h:\d+:.IPSIS_S04_VARIABLE.found: (value_type)
38	SqpIterator\.h:\d+:.IPSIS_S06.found: (iterator_category)
39	SqpIterator\.h:\d+:.IPSIS_S06.found: (random_access_iterator_tag)
40	SqpIterator\.h:\d+:.IPSIS_S06.found: (value_type)
41	SqpIterator\.h:\d+:.IPSIS_S06.found: (T)
42	SqpIterator\.h:\d+:.IPSIS_S06.found: (difference_type)
43	SqpIterator\.h:\d+:.IPSIS_S06.found: (ptrdiff_t)
44	SqpIterator\.h:\d+:.IPSIS_S06.found: (pointer)
45	SqpIterator\.h:\d+:.IPSIS_S06.found: (reference)
46	SqpIterator\.h:\d+:.IPSIS_S06.found: (value_type)
47
48	# Ignore false positive relative to an alias
49	DataSourceItemAction\.h:\d+:.IPSIS_S06.found: (ExecuteFunction)
50
51	# Ignore false positive relative to unnamed namespace
52	VariableController\.cpp:\d+:.IPSIS_F13.

formatting/cmake/use_clangformat.cmake 0 -10

                     clangformat_incr(i)
                 ENDWHILE()
                 # Retrieve source files to format
                 IF(recurse)
                     FILE(GLOB_RECURSE srcs ${globs})
                 # Create the directory where the touched files will be saved
                 SET(formatDirectory "${CMAKE_CURRENT_BINARY_DIR}/format")
                 FILE(MAKE_DIRECTORY ${formatDirectory})
-            #    STRING(REPLACE "*.ui" "" srcs ${srcs})
-                FOREACH(item ${globs})
-                  STRING(REGEX MATCH ".*\.ui$" item ${item})
-                  IF(item)
-                    LIST(APPEND UIS ${item})
-                  ENDIF(item)
-                ENDFOREACH(item ${globs})
-                LIST(REMOVE_ITEM srcs ${UIS})
                 FOREACH (s ${srcs})
                     SET(touchedFile ${formatDirectory}/format_touchedfile_${reportNb})
                     IF(addToAll)

formatting/vera-exclusions/exclusions.txt 0 -11

@@ -6,14 +6,3
6	# Ignore false positive relative to 'noexcept' keyword	6	# Ignore false positive relative to 'noexcept' keyword
7	.IPSIS_S04_VARIABLE.found: noexcept	7	.IPSIS_S04_VARIABLE.found: noexcept
8	.IPSIS_S06.found: noexcept	8	.IPSIS_S06.found: noexcept
9
10	# Ignore false positive relative to 'override' keyword
11	.IPSIS_S04_VARIABLE.found: override
12	.IPSIS_S06.found: override
13
14	# Ignore false positive relative to 'final' keyword
15	.IPSIS_S04_VARIABLE.found: final
16	.IPSIS_S06.found: final
17
18	# Ignore false positive relative to unnamed namespace
19	.IPSIS_F13.

gui/CMakeLists.txt 0 -9

@@ -67,15 +67,6 set_property(TARGET ${SQPGUI_LIBRARY_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
67	TARGET_LINK_LIBRARIES(${SQPGUI_LIBRARY_NAME} ${LIBRARIES})	67	TARGET_LINK_LIBRARIES(${SQPGUI_LIBRARY_NAME} ${LIBRARIES})
68	qt5_use_modules(${SQPGUI_LIBRARY_NAME} Core Widgets PrintSupport)	68	qt5_use_modules(${SQPGUI_LIBRARY_NAME} Core Widgets PrintSupport)
69		69
70
71	INSTALL(TARGETS ${SQPGUI_LIBRARY_NAME}
72	RUNTIME DESTINATION ${INSTALL_BINARY_DIR}
73	LIBRARY DESTINATION ${INSTALL_LIBRARY_DIR}
74	ARCHIVE DESTINATION ${INSTALL_LIBRARY_DIR}
75	)
76	add_dependencies(${SQPGUI_LIBRARY_NAME} ${SQPCORE_LIBRARY_NAME})
77
78
79	# From cmake documentation: http://www.cmake.org/cmake/help/v3.0/manual/cmake-buildsystem.7.html	70	# From cmake documentation: http://www.cmake.org/cmake/help/v3.0/manual/cmake-buildsystem.7.html
80	# Entries in the COMPILE_DEFINITIONS are prefixed with -D or /D and added to the compile line in an unspecified order.	71	# Entries in the COMPILE_DEFINITIONS are prefixed with -D or /D and added to the compile line in an unspecified order.
81	# The DEFINE_SYMBOL target property is also added as a compile definition as a special convenience case for SHARED and MODULE library targets	72	# The DEFINE_SYMBOL target property is also added as a compile definition as a special convenience case for SHARED and MODULE library targets

gui/include/SqpApplication.h +2 -8

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

gui/include/sidepane/SqpSidePane.h ~~gui/include/SidePane/SqpSidePane.h~~ renamed 0 0

NO CONTENT: file renamed from gui/include/SidePane/SqpSidePane.h to gui/include/sidepane/SqpSidePane.h

gui/include/visualization/VisualizationWidget.h ~~gui/include/Visualization/VisualizationWidget.h~~ renamed +1 -34

@@ -1,52 +1,19
1	#ifndef SCIQLOP_VISUALIZATIONWIDGET_H	1	#ifndef SCIQLOP_VISUALIZATIONWIDGET_H
2	#define SCIQLOP_VISUALIZATIONWIDGET_H	2	#define SCIQLOP_VISUALIZATIONWIDGET_H
3		3
4	#include "Visualization/IVisualizationWidget.h"
5	#include <Data/SqpRange.h>
6
7	#include <QLoggingCategory>
8	#include <QWidget>	4	#include <QWidget>
9		5
10	Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationWidget)
11
12	class QMenu;
13	class Variable;
14	class VisualizationTabWidget;
15
16	namespace Ui {	6	namespace Ui {
17	class VisualizationWidget;	7	class VisualizationWidget;
18	} // namespace Ui	8	} // namespace Ui
19		9
20	class VisualizationWidget : public QWidget, ~~public~~ ~~IVisualizationWidget~~ {	10	class VisualizationWidget : public QWidget {
21	Q_OBJECT	11	Q_OBJECT
22		12
23	public:	13	public:
24	explicit VisualizationWidget(QWidget *parent = 0);	14	explicit VisualizationWidget(QWidget *parent = 0);
25	virtual ~VisualizationWidget();	15	virtual ~VisualizationWidget();
26		16
27	// IVisualizationWidget interface
28	void accept(IVisualizationWidgetVisitor *visitor) override;
29	bool canDrop(const Variable &variable) const override;
30	bool contains(const Variable &variable) const override;
31	QString name() const override;
32
33	public slots:
34	/**
35	* Attaches to a menu the menu relative to the visualization of variables
36	* @param menu the parent menu of the generated menu
37	* @param variables the variables for which to generate the menu
38	*/
39	void attachVariableMenu(QMenu *menu,
40	const QVector<std::shared_ptr<Variable> > &variables) noexcept;
41
42	/// Slot called when a variable is about to be deleted from SciQlop
43	void onVariableAboutToBeDeleted(std::shared_ptr<Variable> variable) noexcept;
44
45	void onRangeChanged(std::shared_ptr<Variable> variable, const SqpRange &range) noexcept;
46
47	protected:
48	void closeEvent(QCloseEvent *event) override;
49
50	private:	17	private:
51	Ui::VisualizationWidget *ui;	18	Ui::VisualizationWidget *ui;
52	};	19	};

gui/include/visualization/qcustomplot.h ~~gui/include/Visualization/qcustomplot.h~~ renamed +64 -104

             #if QT_VERSION >= QT_VERSION_CHECK(5, 4, 0)
             #define QCP_DEVICEPIXELRATIO_SUPPORTED
-            #if QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)
-            #define QCP_DEVICEPIXELRATIO_FLOAT
-            #endif
             #endif
             #include <QtCore/QCache>
             class QCPColorScale;
             class QCPBars;
-            /* including file 'src/global.h', size 16225                                 */
+            /* including file 'src/global.h', size 16131                                 */
-            /* commit e7c6a5540d344a96d107dce53f9d4414a09a7320 2017-07-25 00:52:29 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             // decl definitions for shared library compilation/usage:
             #if defined(QCUSTOMPLOT_COMPILE_LIBRARY)
             /* end of 'src/axis/axistickerdatetime.h' */
-            /* including file 'src/axis/axistickertime.h', size 3542                     */
+            /* including file 'src/axis/axistickertime.h', size 3288                     */
-            /* commit c38adb94d83c6a752597a5d43d45c0561fbe1d4d 2017-08-13 17:37:53 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             class QCP_LIB_DECL QCPAxisTickerTime : public QCPAxisTicker {
                 Q_GADGET
                   \see setFieldWidth, setTimeFormat
                 */
-                enum TimeUnit {
+                enum TimeUnit { tuMilliseconds, tuSeconds, tuMinutes, tuHours, tuDays };
-                    tuMilliseconds ///< Milliseconds, one thousandth of a second (%%z in \ref setTimeFormat)
-                    tuSeconds ///< Seconds (%%s in \ref setTimeFormat)
-                    tuMinutes ///< Minutes (%%m in \ref setTimeFormat)
-                    tuHours ///< Hours (%%h in \ref setTimeFormat)
-                    tuDays ///< Days (%%d in \ref setTimeFormat)
-                };
                 Q_ENUMS(TimeUnit)
                 QCPAxisTickerTime();
             /* end of 'src/axis/axistickerlog.h' */
-            /* including file 'src/axis/axis.h', size 20634                              */
+            /* including file 'src/axis/axis.h', size 20230                              */
-            /* commit 0cc4d9f61f7bf45321a88fec89d909b020ffa26f 2017-08-14 00:43:29 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             class QCP_LIB_DECL QCPGrid : public QCPLayerable {
                 Q_OBJECT
                 QVector<double> mSubTickVector;
                 bool mCachedMarginValid;
                 int mCachedMargin;
-                bool mDragging;
-                QCPRange mDragStartRange;
-                QCP::AntialiasedElements mAADragBackup, mNotAADragBackup;
                 // introduced virtual methods:
                 virtual int calculateMargin();
                 virtual void selectEvent(QMouseEvent *event, bool additive, const QVariant &details,
                                          bool *selectionStateChanged) Q_DECL_OVERRIDE;
                 virtual void deselectEvent(bool *selectionStateChanged) Q_DECL_OVERRIDE;
-                // mouse events:
-                virtual void mousePressEvent(QMouseEvent *event, const QVariant &details);
-                virtual void mouseMoveEvent(QMouseEvent *event, const QPointF &startPos);
-                virtual void mouseReleaseEvent(QMouseEvent *event, const QPointF &startPos);
-                virtual void wheelEvent(QWheelEvent *event);
                 // non-virtual methods:
                 void setupTickVectors();
             /* end of 'src/scatterstyle.h' */
-            /* including file 'src/datacontainer.h', size 4596                           */
+            /* including file 'src/datacontainer.h', size 4535                           */
-            /* commit bee82298bd87b91a50093fb0b81cd7c734724a6f 2017-08-13 16:10:24 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             /*! \relates QCPDataContainer
               Returns whether the sort key of \a a is less than the sort key of \a b.
             }
             template <class DataType>
-            class QCPDataContainer // no QCP_LIB_DECL, template class ends up in header (cpp included below)
+            class QCP_LIB_DECL QCPDataContainer {
             public:
                 typedef typename QVector<DataType>::const_iterator const_iterator;
                 typedef typename QVector<DataType>::iterator iterator;
             // include implementation in header since it is a class template:
-            /* including file 'src/datacontainer.cpp', size 31349                        */
+            /* including file 'src/datacontainer.cpp', size 31224                        */
-            /* commit 820d2282db70144c358c13433cd74b4175f9252b 2017-07-24 00:24:17 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPDataContainer
             /*!
               Makes sure \a begin and \a end mark a data range that is both within the bounds of this data
-              container's data, as well as within the specified \a dataRange. The initial range described by
+              container's data, as well as within the specified \a dataRange.
-              the passed iterators \a begin and \a end is never expanded, only contracted if necessary.
               This function doesn't require for \a dataRange to be within the bounds of this data container's
               valid range.
             /* end of 'src/plottable.h' */
-            /* including file 'src/item.h', size 9384                                    */
+            /* including file 'src/item.h', size 9368                                    */
-            /* commit 681a87c5e5365a5c7187d20b4077031003c48449 2017-07-23 23:46:48 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             class QCP_LIB_DECL QCPItemAnchor {
                 Q_GADGET
                 QCPAxis *keyAxis() const { return mKeyAxis.data(); }
                 QCPAxis *valueAxis() const { return mValueAxis.data(); }
                 QCPAxisRect *axisRect() const;
-                virtual QPointF pixelPosition() const Q_DECL_OVERRIDE;
+                virtual QPointF pixelPosition() const;
                 // setters:
                 void setType(PositionType type);
             /* end of 'src/item.h' */
-            /* including file 'src/core.h', size 14886                                   */
+            /* including file 'src/core.h', size 14797                                   */
-            /* commit 29aafbce469a36d175d4fb32cbfd1f50a6072890 2016-10-12 19:21:24 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             class QCP_LIB_DECL QCustomPlot : public QWidget {
                 Q_OBJECT
                 QPoint mMousePressPos;
                 bool mMouseHasMoved;
                 QPointer<QCPLayerable> mMouseEventLayerable;
-                QPointer<QCPLayerable> mMouseSignalLayerable;
                 QVariant mMouseEventLayerableDetails;
-                QVariant mMouseSignalLayerableDetails;
                 bool mReplotting;
                 bool mReplotQueued;
                 int mOpenGlMultisamples;
             /* end of 'src/core.h' */
-            /* including file 'src/plottable1d.h', size 4544                             */
+            /* including file 'src/plottable1d.h', size 4250                             */
-            /* commit bee82298bd87b91a50093fb0b81cd7c734724a6f 2017-08-13 16:10:24 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
-            class QCPPlottableInterface1D {
+            class QCP_LIB_DECL QCPPlottableInterface1D {
             public:
-                virtual ~QCPPlottableInterface1D() {}
                 // introduced pure virtual methods:
                 virtual int dataCount() const = 0;
                 virtual double dataMainKey(int index) const = 0;
             };
             template <class DataType>
-            class QCPAbstractPlottable1D : public QCPAbstractPlottable,
+            class QCP_LIB_DECL QCPAbstractPlottable1D : public QCPAbstractPlottable,
-                                           public QCPPlottableInterface1D // no QCP_LIB_DECL, template class
+                                                        public QCPPlottableInterface1D {
-                                                                          // ends up in header (cpp included
-                                                                          // below)
                 // No Q_OBJECT macro due to template class
             public:
                 virtual ~QCPAbstractPlottable1D();
                 // virtual methods of 1d plottable interface:
-                virtual int dataCount() const Q_DECL_OVERRIDE;
+                virtual int dataCount() const;
-                virtual double dataMainKey(int index) const Q_DECL_OVERRIDE;
+                virtual double dataMainKey(int index) const;
-                virtual double dataSortKey(int index) const Q_DECL_OVERRIDE;
+                virtual double dataSortKey(int index) const;
-                virtual double dataMainValue(int index) const Q_DECL_OVERRIDE;
+                virtual double dataMainValue(int index) const;
-                virtual QCPRange dataValueRange(int index) const Q_DECL_OVERRIDE;
+                virtual QCPRange dataValueRange(int index) const;
-                virtual QPointF dataPixelPosition(int index) const Q_DECL_OVERRIDE;
+                virtual QPointF dataPixelPosition(int index) const;
-                virtual bool sortKeyIsMainKey() const Q_DECL_OVERRIDE;
+                virtual bool sortKeyIsMainKey() const;
-                virtual QCPDataSelection selectTestRect(const QRectF &rect,
+                virtual QCPDataSelection selectTestRect(const QRectF &rect, bool onlySelectable) const;
-                                                        bool onlySelectable) const Q_DECL_OVERRIDE;
+                virtual int findBegin(double sortKey, bool expandedRange = true) const;
-                virtual int findBegin(double sortKey, bool expandedRange = true) const Q_DECL_OVERRIDE;
+                virtual int findEnd(double sortKey, bool expandedRange = true) const;
-                virtual int findEnd(double sortKey, bool expandedRange = true) const Q_DECL_OVERRIDE;
-                // reimplemented virtual methods:
+                // virtual methods:
-                virtual double selectTest(const QPointF &pos, bool onlySelectable,
+                virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details = 0) const;
-                                          QVariant *details = 0) const Q_DECL_OVERRIDE;
+                virtual QCPPlottableInterface1D *interface1D() { return this; }
-                virtual QCPPlottableInterface1D *interface1D() Q_DECL_OVERRIDE { return this; }
             protected:
                 // property members:
             /* end of 'src/colorgradient.h' */
-            /* including file 'src/selectiondecorator-bracket.h', size 4442              */
+            /* including file 'src/selectiondecorator-bracket.h', size 4426              */
-            /* commit 681a87c5e5365a5c7187d20b4077031003c48449 2017-07-23 23:46:48 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             class QCP_LIB_DECL QCPSelectionDecoratorBracket : public QCPSelectionDecorator {
                 Q_GADGET
                 virtual void drawBracket(QCPPainter *painter, int direction) const;
                 // virtual methods:
-                virtual void drawDecoration(QCPPainter *painter, QCPDataSelection selection) Q_DECL_OVERRIDE;
+                virtual void drawDecoration(QCPPainter *painter, QCPDataSelection selection);
             protected:
                 // property members:
             /* end of 'src/selectiondecorator-bracket.h' */
-            /* including file 'src/layoutelements/layoutelement-axisrect.h', size 7507   */
+            /* including file 'src/layoutelements/layoutelement-axisrect.h', size 7528   */
-            /* commit 77ba168312f935543fc31d1ae9b4cdcf34aae4f9 2017-08-13 18:29:48 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             class QCP_LIB_DECL QCPAxisRect : public QCPLayoutElement {
                 Q_OBJECT
                 // non-property members:
                 QList<QCPRange> mDragStartHorzRange, mDragStartVertRange;
                 QCP::AntialiasedElements mAADragBackup, mNotAADragBackup;
+                QPoint mDragStart;
                 bool mDragging;
                 QHash<QCPAxis::AxisType, QList<QCPAxis *> > mAxes;
             /* end of 'src/layoutelements/layoutelement-textelement.h' */
-            /* including file 'src/layoutelements/layoutelement-colorscale.h', size 5923 */
+            /* including file 'src/layoutelements/layoutelement-colorscale.h', size 5907 */
-            /* commit 681a87c5e5365a5c7187d20b4077031003c48449 2017-07-23 23:46:48 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             class QCPColorScaleAxisRectPrivate : public QCPAxisRect {
                 using QCPAxisRect::mouseReleaseEvent;
                 using QCPAxisRect::wheelEvent;
                 using QCPAxisRect::update;
-                virtual void draw(QCPPainter *painter) Q_DECL_OVERRIDE;
+                virtual void draw(QCPPainter *painter);
                 void updateGradientImage();
                 Q_SLOT void axisSelectionChanged(QCPAxis::SelectableParts selectedParts);
                 Q_SLOT void axisSelectableChanged(QCPAxis::SelectableParts selectableParts);
             /* end of 'src/layoutelements/layoutelement-colorscale.h' */
-            /* including file 'src/plottables/plottable-graph.h', size 9294              */
+            /* including file 'src/plottables/plottable-graph.h', size 8826              */
-            /* commit f3881770eaf7366171012ad01cad2aaf5f61dd27 2017-06-23 02:48:21 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             class QCP_LIB_DECL QCPGraphData {
             public:
                 QVector<QPointF> dataToStepRightLines(const QVector<QCPGraphData> &data) const;
                 QVector<QPointF> dataToStepCenterLines(const QVector<QCPGraphData> &data) const;
                 QVector<QPointF> dataToImpulseLines(const QVector<QCPGraphData> &data) const;
-                QVector<QCPDataRange> getNonNanSegments(const QVector<QPointF> *lineData,
+                void addFillBasePoints(QVector<QPointF> *lines) const;
-                                                        Qt::Orientation keyOrientation) const;
+                void removeFillBasePoints(QVector<QPointF> *lines) const;
-                QVector<QPair<QCPDataRange, QCPDataRange> >
+                QPointF lowerFillBasePoint(double lowerKey) const;
-                getOverlappingSegments(QVector<QCPDataRange> thisSegments, const QVector<QPointF> *thisData,
+                QPointF upperFillBasePoint(double upperKey) const;
-                                       QVector<QCPDataRange> otherSegments,
+                const QPolygonF getChannelFillPolygon(const QVector<QPointF> *lines) const;
-                                       const QVector<QPointF> *otherData) const;
-                bool segmentsIntersect(double aLower, double aUpper, double bLower, double bUpper,
-                                       int &bPrecedence) const;
-                QPointF getFillBasePoint(QPointF matchingDataPoint) const;
-                const QPolygonF getFillPolygon(const QVector<QPointF> *lineData, QCPDataRange segment) const;
-                const QPolygonF getChannelFillPolygon(const QVector<QPointF> *lineData,
-                                                      QCPDataRange thisSegment,
-                                                      const QVector<QPointF> *otherData,
-                                                      QCPDataRange otherSegment) const;
                 int findIndexBelowX(const QVector<QPointF> *data, double x) const;
                 int findIndexAboveX(const QVector<QPointF> *data, double x) const;
                 int findIndexBelowY(const QVector<QPointF> *data, double y) const;
             /* end of 'src/plottables/plottable-financial.h' */
-            /* including file 'src/plottables/plottable-errorbar.h', size 7727           */
+            /* including file 'src/plottables/plottable-errorbar.h', size 7567           */
-            /* commit 681a87c5e5365a5c7187d20b4077031003c48449 2017-07-23 23:46:48 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             class QCP_LIB_DECL QCPErrorBarsData {
             public:
                 void addData(double errorMinus, double errorPlus);
                 // virtual methods of 1d plottable interface:
-                virtual int dataCount() const Q_DECL_OVERRIDE;
+                virtual int dataCount() const;
-                virtual double dataMainKey(int index) const Q_DECL_OVERRIDE;
+                virtual double dataMainKey(int index) const;
-                virtual double dataSortKey(int index) const Q_DECL_OVERRIDE;
+                virtual double dataSortKey(int index) const;
-                virtual double dataMainValue(int index) const Q_DECL_OVERRIDE;
+                virtual double dataMainValue(int index) const;
-                virtual QCPRange dataValueRange(int index) const Q_DECL_OVERRIDE;
+                virtual QCPRange dataValueRange(int index) const;
-                virtual QPointF dataPixelPosition(int index) const Q_DECL_OVERRIDE;
+                virtual QPointF dataPixelPosition(int index) const;
-                virtual bool sortKeyIsMainKey() const Q_DECL_OVERRIDE;
+                virtual bool sortKeyIsMainKey() const;
-                virtual QCPDataSelection selectTestRect(const QRectF &rect,
+                virtual QCPDataSelection selectTestRect(const QRectF &rect, bool onlySelectable) const;
-                                                        bool onlySelectable) const Q_DECL_OVERRIDE;
+                virtual int findBegin(double sortKey, bool expandedRange = true) const;
-                virtual int findBegin(double sortKey, bool expandedRange = true) const Q_DECL_OVERRIDE;
+                virtual int findEnd(double sortKey, bool expandedRange = true) const;
-                virtual int findEnd(double sortKey, bool expandedRange = true) const Q_DECL_OVERRIDE;
                 // reimplemented virtual methods:
                 virtual double selectTest(const QPointF &pos, bool onlySelectable,

gui/src/SqpApplication.cpp +5 -83

             #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")
             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");
                     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();
+                qCInfo(LOG_SqpApplication()) << tr("SqpApplication construction");
                 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();
             }
             {
             }
-            DataSourceController &SqpApplication::dataSourceController() noexcept
+            DataSourceController &SqpApplication::dataSourceController() const noexcept
             {
                 return *impl->m_DataSourceController;
             }
-            NetworkController &SqpApplication::networkController() noexcept
+            VisualizationController &SqpApplication::visualizationController() const 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/sidepane/SqpSidePane.cpp ~~gui/src/SidePane/SqpSidePane.cpp~~ renamed +7 -7

-            #include "SidePane/SqpSidePane.h"
+            #include "sidepane/SqpSidePane.h"
             #include "ui_SqpSidePane.h"
             #include <QAction>
                   " }";
             }
-            SqpSidePane::SqpSidePane(QWidget *parent) : QWidget{parent}, ui{new Ui::SqpSidePane}
+            SqpSidePane::SqpSidePane(QWidget *parent) : QWidget(parent), ui(new Ui::SqpSidePane)
             {
-                //    QVBoxLayout *sidePaneLayout = new QVBoxLayout(this);
+                QVBoxLayout *sidePaneLayout = new QVBoxLayout(this);
-                //    sidePaneLayout->setContentsMargins(0, 0, 0, 0);
+                sidePaneLayout->setContentsMargins(0, 0, 0, 0);
-                //    this->setLayout(sidePaneLayout);
+                this->setLayout(sidePaneLayout);
                 ui->setupUi(this);
-                m_SidePaneToolbar = new QToolBar();
+                m_SidePaneToolbar = new QToolBar(this);
                 m_SidePaneToolbar->setOrientation(Qt::Vertical);
-                this->layout()->addWidget(m_SidePaneToolbar);
+                sidePaneLayout->addWidget(m_SidePaneToolbar);
                 m_SidePaneToolbar->setStyleSheet(SQPSIDEPANESTYLESHEET);
             }

gui/src/visualization/qcustomplot.cpp ~~gui/src/Visualization/qcustomplot.cpp~~ renamed +559 -836

             **          Version: 2.0.0-beta                                           **
             ****************************************************************************/
-            #include "Visualization/qcustomplot.h"
+            #include "visualization/qcustomplot.h"
             /* including file 'src/vector2d.cpp', size 7340                              */
               \see initializeParentPlot
             */
-            void QCPLayerable::parentPlotInitialized(QCustomPlot *parentPlot)
+            void QCPLayerable::parentPlotInitialized(QCustomPlot *parentPlot){Q_UNUSED(parentPlot)}
-                Q_UNUSED(parentPlot)
             /*! \internal
             /* end of 'src/axis/range.cpp' */
-            /* including file 'src/selection.cpp', size 21906                            */
+            /* including file 'src/selection.cpp', size 21898                            */
-            /* commit 820d2282db70144c358c13433cd74b4175f9252b 2017-07-24 00:24:17 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPDataRange
             }
             /*!
-              Removes all data point indices that are described by \a other from this data selection.
+              Removes all data point indices that are described by \a other from this data range.
             */
             QCPDataSelection &QCPDataSelection::operator-=(const QCPDataSelection &other)
             {
             }
             /*!
-              Removes all data point indices that are described by \a other from this data selection.
+              Removes all data point indices that are described by \a other from this data range.
             */
             QCPDataSelection &QCPDataSelection::operator-=(const QCPDataRange &other)
             {
             /* end of 'src/selectionrect.cpp' */
-            /* including file 'src/layout.cpp', size 74663                               */
+            /* including file 'src/layout.cpp', size 74302                               */
-            /* commit a872eb91ec087561efd83dd9cb041a26ab95ce55 2017-07-31 00:21:41 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPMarginGroup
             }
             /*!
-              If \a phase is \ref upLayout, calls \ref updateLayout, which subclasses may reimplement to
+              First calls the QCPLayoutElement::update base class implementation to update the margins on this
-              reposition and resize their cells.
+              layout.
-              Finally, the call is propagated down to all child \ref QCPLayoutElement "QCPLayoutElements".
+              Then calls \ref updateLayout which subclasses reimplement to reposition and resize their cells.
-              For details about this method and the update phases, see the documentation of \ref
+              Finally, \ref update is called on all child elements.
-              QCPLayoutElement::update.
             */
             void QCPLayout::update(UpdatePhase phase)
             {
               If you want to have all current elements arranged in the new order, set \a rearrange to true. The
               elements will be rearranged in a way that tries to preserve their linear index. However, empty
-              cells are skipped during build-up of the new cell order, which shifts the succeeding element's
+              cells are skipped during build-up of the new cell order, which shifts the succeding element's
               index. The rearranging is performed even if the specified \a order is already the current fill
               order. Thus this method can be used to re-wrap the current elements.
             /*!
               Inserts a new column with empty cells at the column index \a newIndex. Valid values for \a
-              newIndex range from 0 (inserts a column at the left) to \a columnCount (appends a column at the
+              newIndex range from 0 (inserts a row at the left) to \a rowCount (appends a row at the right).
-              right).
               \see insertRow
             */
             {
                 row = -1;
                 column = -1;
-                const int nCols = columnCount();
+                if (columnCount() == 0 || rowCount() == 0)
-                const int nRows = rowCount();
-                if (nCols == 0 || nRows == 0)
                     return;
                 if (index < 0 || index >= elementCount()) {
                     qDebug() << Q_FUNC_INFO << "index out of bounds:" << index;
                 switch (mFillOrder) {
                     case foRowsFirst: {
-                        column = index / nRows;
+                        column = index / rowCount();
-                        row = index % nRows;
+                        row = index % rowCount();
                         break;
                     }
                     case foColumnsFirst: {
-                        row = index / nCols;
+                        row = index / columnCount();
-                        column = index % nCols;
+                        column = index % columnCount();
                         break;
                     }
                 }
                     result.rwidth() += minColWidths.at(i);
                 for (int i = 0; i < minRowHeights.size(); ++i)
                     result.rheight() += minRowHeights.at(i);
-                result.rwidth() += qMax(0, columnCount() - 1) * mColumnSpacing;
+                result.rwidth()
-                result.rheight() += qMax(0, rowCount() - 1) * mRowSpacing;
+                    += qMax(0, columnCount() - 1) * mColumnSpacing + mMargins.left() + mMargins.right();
+                result.rheight() += qMax(0, rowCount() - 1) * mRowSpacing + mMargins.top() + mMargins.bottom();
                 return result;
             }
                     result.setWidth(qMin(result.width() + maxColWidths.at(i), QWIDGETSIZE_MAX));
                 for (int i = 0; i < maxRowHeights.size(); ++i)
                     result.setHeight(qMin(result.height() + maxRowHeights.at(i), QWIDGETSIZE_MAX));
-                result.rwidth() += qMax(0, columnCount() - 1) * mColumnSpacing;
+                result.rwidth()
-                result.rheight() += qMax(0, rowCount() - 1) * mRowSpacing;
+                    += qMax(0, columnCount() - 1) * mColumnSpacing + mMargins.left() + mMargins.right();
+                result.rheight() += qMax(0, rowCount() - 1) * mRowSpacing + mMargins.top() + mMargins.bottom();
                 return result;
             }
               Places the minimum column widths and row heights into \a minColWidths and \a minRowHeights
               respectively.
-              The minimum height of a row is the largest minimum height of any element's outer rect in that
+              The minimum height of a row is the largest minimum height of any element in that row. The minimum
-              row. The minimum width of a column is the largest minimum width of any element's outer rect in
+              width of a column is the largest minimum width of any element in that column.
-              that column.
               This is a helper function for \ref updateLayout.
                 *minRowHeights = QVector<int>(rowCount(), 0);
                 for (int row = 0; row < rowCount(); ++row) {
                     for (int col = 0; col < columnCount(); ++col) {
-                        if (QCPLayoutElement *el = mElements.at(row).at(col)) {
+                        if (mElements.at(row).at(col)) {
-                            QSize minHint = el->minimumSizeHint();
+                            QSize minHint = mElements.at(row).at(col)->minimumSizeHint();
-                            QSize min = el->minimumSize();
+                            QSize min = mElements.at(row).at(col)->minimumSize();
                             QSize final(min.width() > 0 ? min.width() : minHint.width(),
                                         min.height() > 0 ? min.height() : minHint.height());
-                            final += QSize(el->margins().left() + el->margins().right(),
-                                           el->margins().top() + el->margins().bottom());
                             if (minColWidths->at(col) < final.width())
                                 (*minColWidths)[col] = final.width();
                             if (minRowHeights->at(row) < final.height())
               Places the maximum column widths and row heights into \a maxColWidths and \a maxRowHeights
               respectively.
-              The maximum height of a row is the smallest maximum height of any element's outer rect in that
+              The maximum height of a row is the smallest maximum height of any element in that row. The
-              row. The maximum width of a column is the smallest maximum width of any element's outer rect in
+              maximum width of a column is the smallest maximum width of any element in that column.
-              that column.
               This is a helper function for \ref updateLayout.
                 *maxRowHeights = QVector<int>(rowCount(), QWIDGETSIZE_MAX);
                 for (int row = 0; row < rowCount(); ++row) {
                     for (int col = 0; col < columnCount(); ++col) {
-                        if (QCPLayoutElement *el = mElements.at(row).at(col)) {
+                        if (mElements.at(row).at(col)) {
-                            QSize maxHint = el->maximumSizeHint();
+                            QSize maxHint = mElements.at(row).at(col)->maximumSizeHint();
-                            QSize max = el->maximumSize();
+                            QSize max = mElements.at(row).at(col)->maximumSize();
                             QSize final(max.width() < QWIDGETSIZE_MAX ? max.width() : maxHint.width(),
                                         max.height() < QWIDGETSIZE_MAX ? max.height() : maxHint.height());
-                            final += QSize(el->margins().left() + el->margins().right(),
-                                           el->margins().top() + el->margins().bottom());
                             if (maxColWidths->at(col) > final.width())
                                 (*maxColWidths)[col] = final.width();
                             if (maxRowHeights->at(row) > final.height())
             void QCPLayoutInset::updateLayout()
             {
                 for (int i = 0; i < mElements.size(); ++i) {
-                    QCPLayoutElement *el = mElements.at(i);
                     QRect insetRect;
                     QSize finalMinSize, finalMaxSize;
-                    QSize minSizeHint = el->minimumSizeHint();
+                    QSize minSizeHint = mElements.at(i)->minimumSizeHint();
-                    QSize maxSizeHint = el->maximumSizeHint();
+                    QSize maxSizeHint = mElements.at(i)->maximumSizeHint();
-                    finalMinSize.setWidth(el->minimumSize().width() > 0 ? el->minimumSize().width()
+                    finalMinSize.setWidth(mElements.at(i)->minimumSize().width() > 0
-                                                                        : minSizeHint.width());
+                                              ? mElements.at(i)->minimumSize().width()
-                    finalMinSize.setHeight(el->minimumSize().height() > 0 ? el->minimumSize().height()
+                                              : minSizeHint.width());
-                                                                          : minSizeHint.height());
+                    finalMinSize.setHeight(mElements.at(i)->minimumSize().height() > 0
-                    finalMaxSize.setWidth(el->maximumSize().width() < QWIDGETSIZE_MAX
+                                               ? mElements.at(i)->minimumSize().height()
-                                              ? el->maximumSize().width()
+                                               : minSizeHint.height());
+                    finalMaxSize.setWidth(mElements.at(i)->maximumSize().width() < QWIDGETSIZE_MAX
+                                              ? mElements.at(i)->maximumSize().width()
                                               : maxSizeHint.width());
-                    finalMaxSize.setHeight(el->maximumSize().height() < QWIDGETSIZE_MAX
+                    finalMaxSize.setHeight(mElements.at(i)->maximumSize().height() < QWIDGETSIZE_MAX
-                                               ? el->maximumSize().height()
+                                               ? mElements.at(i)->maximumSize().height()
                                                : maxSizeHint.height());
-                    finalMinSize += QSize(el->margins().left() + el->margins().right(),
-                                          el->margins().top() + el->margins().bottom());
-                    finalMaxSize += QSize(el->margins().left() + el->margins().right(),
-                                          el->margins().top() + el->margins().bottom());
                     if (mInsetPlacement.at(i) == ipFree) {
                         insetRect = QRect(rect().x() + rect().width() * mInsetRect.at(i).x(),
                                           rect().y() + rect().height() * mInsetRect.at(i).y(),
             /* end of 'src/axis/axistickerlog.cpp' */
-            /* including file 'src/axis/axis.cpp', size 99397                            */
+            /* including file 'src/axis/axis.cpp', size 94458                            */
-            /* commit 0cc4d9f61f7bf45321a88fec89d909b020ffa26f 2017-08-14 00:43:29 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
                     }
                     else // mScaleType == stLogarithmic
                     {
-                        if (value >= 0.0 && mRange.upper < 0.0) // invalid value for logarithmic scale, just
+                        if (value >= 0 && mRange.upper < 0) // invalid value for logarithmic scale, just draw it
-                                                                // draw it outside visible range
+                                                            // outside visible range
                             return !mRangeReversed ? mAxisRect->right() + 200 : mAxisRect->left() - 200;
-                        else if (value <= 0.0 && mRange.upper >= 0.0) // invalid value for logarithmic scale,
+                        else if (value <= 0 && mRange.upper > 0) // invalid value for logarithmic scale, just
-                                                                      // just draw it outside visible range
+                                                                 // draw it outside visible range
                             return !mRangeReversed ? mAxisRect->left() - 200 : mAxisRect->right() + 200;
                         else {
                             if (!mRangeReversed)
                     }
                     else // mScaleType == stLogarithmic
                     {
-                        if (value >= 0.0 && mRange.upper < 0.0) // invalid value for logarithmic scale, just
+                        if (value >= 0 && mRange.upper < 0) // invalid value for logarithmic scale, just draw it
-                                                                // draw it outside visible range
+                                                            // outside visible range
                             return !mRangeReversed ? mAxisRect->top() - 200 : mAxisRect->bottom() + 200;
-                        else if (value <= 0.0 && mRange.upper >= 0.0) // invalid value for logarithmic scale,
+                        else if (value <= 0 && mRange.upper > 0) // invalid value for logarithmic scale, just
-                                                                      // just draw it outside visible range
+                                                                 // draw it outside visible range
                             return !mRangeReversed ? mAxisRect->bottom() + 200 : mAxisRect->top() - 200;
                         else {
                             if (!mRangeReversed)
             /*! \internal
-              This mouse event reimplementation provides the functionality to let the user drag individual axes
-              exclusively, by startig the drag on top of the axis.
-              For the axis to accept this event and perform the single axis drag, the parent \ref QCPAxisRect
-              must be configured accordingly, i.e. it must allow range dragging in the orientation of this axis
-              (\ref QCPAxisRect::setRangeDrag) and this axis must be a draggable axis (\ref
-              QCPAxisRect::setRangeDragAxes)
-              \seebaseclassmethod
-              \note The dragging of possibly multiple axes at once by starting the drag anywhere in the axis
-              rect is handled by the axis rect's mouse event, e.g. \ref QCPAxisRect::mousePressEvent.
-            */
-            void QCPAxis::mousePressEvent(QMouseEvent *event, const QVariant &details)
-                Q_UNUSED(details)
-                if (!mParentPlot->interactions().testFlag(QCP::iRangeDrag)
-                    || !mAxisRect->rangeDrag().testFlag(orientation())
-                    || !mAxisRect->rangeDragAxes(orientation()).contains(this)) {
-                    event->ignore();
-                    return;
-                if (event->buttons() & Qt::LeftButton) {
-                    mDragging = true;
-                    // initialize antialiasing backup in case we start dragging:
-                    if (mParentPlot->noAntialiasingOnDrag()) {
-                        mAADragBackup = mParentPlot->antialiasedElements();
-                        mNotAADragBackup = mParentPlot->notAntialiasedElements();
-                    // Mouse range dragging interaction:
-                    if (mParentPlot->interactions().testFlag(QCP::iRangeDrag))
-                        mDragStartRange = mRange;
-            /*! \internal
-              This mouse event reimplementation provides the functionality to let the user drag individual axes
-              exclusively, by startig the drag on top of the axis.
-              \seebaseclassmethod
-              \note The dragging of possibly multiple axes at once by starting the drag anywhere in the axis
-              rect is handled by the axis rect's mouse event, e.g. \ref QCPAxisRect::mousePressEvent.
-              \see QCPAxis::mousePressEvent
-            */
-            void QCPAxis::mouseMoveEvent(QMouseEvent *event, const QPointF &startPos)
-                if (mDragging) {
-                    const double startPixel = orientation() == Qt::Horizontal ? startPos.x() : startPos.y();
-                    const double currentPixel
-                        = orientation() == Qt::Horizontal ? event->pos().x() : event->pos().y();
-                    if (mScaleType == QCPAxis::stLinear) {
-                        const double diff = pixelToCoord(startPixel) - pixelToCoord(currentPixel);
-                        setRange(mDragStartRange.lower + diff, mDragStartRange.upper + diff);
-                    else if (mScaleType == QCPAxis::stLogarithmic) {
-                        const double diff = pixelToCoord(startPixel) / pixelToCoord(currentPixel);
-                        setRange(mDragStartRange.lower * diff, mDragStartRange.upper * diff);
-                    if (mParentPlot->noAntialiasingOnDrag())
-                        mParentPlot->setNotAntialiasedElements(QCP::aeAll);
-                    mParentPlot->replot(QCustomPlot::rpQueuedReplot);
-            /*! \internal
-              This mouse event reimplementation provides the functionality to let the user drag individual axes
-              exclusively, by startig the drag on top of the axis.
-              \seebaseclassmethod
-              \note The dragging of possibly multiple axes at once by starting the drag anywhere in the axis
-              rect is handled by the axis rect's mouse event, e.g. \ref QCPAxisRect::mousePressEvent.
-              \see QCPAxis::mousePressEvent
-            */
-            void QCPAxis::mouseReleaseEvent(QMouseEvent *event, const QPointF &startPos)
-                Q_UNUSED(event)
-                Q_UNUSED(startPos)
-                mDragging = false;
-                if (mParentPlot->noAntialiasingOnDrag()) {
-                    mParentPlot->setAntialiasedElements(mAADragBackup);
-                    mParentPlot->setNotAntialiasedElements(mNotAADragBackup);
-            /*! \internal
-              This mouse event reimplementation provides the functionality to let the user zoom individual axes
-              exclusively, by performing the wheel event on top of the axis.
-              For the axis to accept this event and perform the single axis zoom, the parent \ref QCPAxisRect
-              must be configured accordingly, i.e. it must allow range zooming in the orientation of this axis
-              (\ref QCPAxisRect::setRangeZoom) and this axis must be a zoomable axis (\ref
-              QCPAxisRect::setRangeZoomAxes)
-              \seebaseclassmethod
-              \note The zooming of possibly multiple axes at once by performing the wheel event anywhere in the
-              axis rect is handled by the axis rect's mouse event, e.g. \ref QCPAxisRect::wheelEvent.
-            */
-            void QCPAxis::wheelEvent(QWheelEvent *event)
-                // Mouse range zooming interaction:
-                if (!mParentPlot->interactions().testFlag(QCP::iRangeZoom)
-                    || !mAxisRect->rangeZoom().testFlag(orientation())
-                    || !mAxisRect->rangeZoomAxes(orientation()).contains(this)) {
-                    event->ignore();
-                    return;
-                const double wheelSteps = event->delta() / 120.0; // a single step delta is +/-120 usually
-                const double factor = qPow(mAxisRect->rangeZoomFactor(orientation()), wheelSteps);
-                scaleRange(factor,
-                           pixelToCoord(orientation() == Qt::Horizontal ? event->pos().x() : event->pos().y()));
-                mParentPlot->replot();
-            /*! \internal
               A convenience function to easily set the QPainter::Antialiased hint on the provided \a painter
               before drawing axis lines.
                 painter->setBrush(QBrush(basePen.color()));
                 QCPVector2D baseLineVector(baseLine.dx(), baseLine.dy());
                 if (lowerEnding.style() != QCPLineEnding::esNone)
-                    lowerEnding.draw(painter, QCPVector2D(baseLine.p1())
+                    lowerEnding.draw(painter,
-                                                  - baseLineVector.normalized() * lowerEnding.realLength()
+                                     QCPVector2D(baseLine.p1())
-                                                        * (lowerEnding.inverted() ? -1 : 1),
+                                         - baseLineVector.normalized() * lowerEnding.realLength()
+                                               * (lowerEnding.inverted() ? -1 : 1),
                                      -baseLineVector);
                 if (upperEnding.style() != QCPLineEnding::esNone)
-                    upperEnding.draw(painter, QCPVector2D(baseLine.p2())
+                    upperEnding.draw(painter,
-                                                  + baseLineVector.normalized() * upperEnding.realLength()
+                                     QCPVector2D(baseLine.p2())
-                                                        * (upperEnding.inverted() ? -1 : 1),
+                                         + baseLineVector.normalized() * upperEnding.realLength()
+                                               * (upperEnding.inverted() ? -1 : 1),
                                      baseLineVector);
                 painter->setAntialiasing(antialiasingBackup);
                             cachedLabel->pixmap = QPixmap(labelData.rotatedTotalBounds.size()
                                                           * mParentPlot->bufferDevicePixelRatio());
             #ifdef QCP_DEVICEPIXELRATIO_SUPPORTED
-            #ifdef QCP_DEVICEPIXELRATIO_FLOAT
-                            cachedLabel->pixmap.setDevicePixelRatio(mParentPlot->devicePixelRatioF());
-            #else
                             cachedLabel->pixmap.setDevicePixelRatio(mParentPlot->devicePixelRatio());
             #endif
-            #endif
                         }
                         else
                             cachedLabel->pixmap = QPixmap(labelData.rotatedTotalBounds.size());
+                        cachedLabel->pixmap = QPixmap(labelData.rotatedTotalBounds.size());
                         cachedLabel->pixmap.fill(Qt::transparent);
                         QCPPainter cachePainter(&cachedLabel->pixmap);
                         cachePainter.setPen(painter->pen());
             /* end of 'src/axis/axis.cpp' */
-            /* including file 'src/scatterstyle.cpp', size 17450                         */
+            /* including file 'src/scatterstyle.cpp', size 17420                         */
-            /* commit 820d2282db70144c358c13433cd74b4175f9252b 2017-07-24 00:24:17 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPScatterStyle
               The custom shape line will be drawn with \a pen and filled with \a brush. The size has a slightly
               different meaning than for built-in scatter points: The custom path will be drawn scaled by a
-              factor of \a size/6.0. Since the default \a size is 6, the custom path will appear in its
+              factor of \a size/6.0. Since the default \a size is 6, the custom path will appear at a its
-              original size by default. To for example double the size of the path, set \a size to 12.
+              natural size by default. To double the size of the path for example, set \a size to 12.
             */
             QCPScatterStyle::QCPScatterStyle(const QPainterPath &customPath, const QPen &pen,
                                              const QBrush &brush, double size)
                         break;
                     }
                     case ssDiamond: {
-                        QPointF lineArray[4]
+                        painter->drawLine(QLineF(x - w, y, x, y - w));
-                            = {QPointF(x - w, y), QPointF(x, y - w), QPointF(x + w, y), QPointF(x, y + w)};
+                        painter->drawLine(QLineF(x, y - w, x + w, y));
-                        painter->drawPolygon(lineArray, 4);
+                        painter->drawLine(QLineF(x + w, y, x, y + w));
+                        painter->drawLine(QLineF(x, y + w, x - w, y));
                         break;
                     }
                     case ssStar: {
                         break;
                     }
                     case ssTriangle: {
-                        QPointF lineArray[3] = {QPointF(x - w, y + 0.755 * w), QPointF(x + w, y + 0.755 * w),
+                        painter->drawLine(QLineF(x - w, y + 0.755 * w, x + w, y + 0.755 * w));
-                                                QPointF(x, y - 0.977 * w)};
+                        painter->drawLine(QLineF(x + w, y + 0.755 * w, x, y - 0.977 * w));
-                        painter->drawPolygon(lineArray, 3);
+                        painter->drawLine(QLineF(x, y - 0.977 * w, x - w, y + 0.755 * w));
                         break;
                     }
                     case ssTriangleInverted: {
-                        QPointF lineArray[3] = {QPointF(x - w, y - 0.755 * w), QPointF(x + w, y - 0.755 * w),
+                        painter->drawLine(QLineF(x - w, y - 0.755 * w, x + w, y - 0.755 * w));
-                                                QPointF(x, y + 0.977 * w)};
+                        painter->drawLine(QLineF(x + w, y - 0.755 * w, x, y + 0.977 * w));
-                        painter->drawPolygon(lineArray, 3);
+                        painter->drawLine(QLineF(x, y + 0.977 * w, x - w, y - 0.755 * w));
                         break;
                     }
                     case ssCrossSquare: {
-                        painter->drawRect(QRectF(x - w, y - w, mSize, mSize));
                         painter->drawLine(QLineF(x - w, y - w, x + w * 0.95, y + w * 0.95));
                         painter->drawLine(QLineF(x - w, y + w * 0.95, x + w * 0.95, y - w));
+                        painter->drawRect(QRectF(x - w, y - w, mSize, mSize));
                         break;
                     }
                     case ssPlusSquare: {
-                        painter->drawRect(QRectF(x - w, y - w, mSize, mSize));
                         painter->drawLine(QLineF(x - w, y, x + w * 0.95, y));
                         painter->drawLine(QLineF(x, y + w, x, y - w));
+                        painter->drawRect(QRectF(x - w, y - w, mSize, mSize));
                         break;
                     }
                     case ssCrossCircle: {
-                        painter->drawEllipse(QPointF(x, y), w, w);
                         painter->drawLine(QLineF(x - w * 0.707, y - w * 0.707, x + w * 0.670, y + w * 0.670));
                         painter->drawLine(QLineF(x - w * 0.707, y + w * 0.670, x + w * 0.670, y - w * 0.707));
+                        painter->drawEllipse(QPointF(x, y), w, w);
                         break;
                     }
                     case ssPlusCircle: {
-                        painter->drawEllipse(QPointF(x, y), w, w);
                         painter->drawLine(QLineF(x - w, y, x + w, y));
                         painter->drawLine(QLineF(x, y + w, x, y - w));
+                        painter->drawEllipse(QPointF(x, y), w, w);
                         break;
                     }
                     case ssPeace: {
-                        painter->drawEllipse(QPointF(x, y), w, w);
                         painter->drawLine(QLineF(x, y - w, x, y + w));
                         painter->drawLine(QLineF(x, y, x - w * 0.707, y + w * 0.707));
                         painter->drawLine(QLineF(x, y, x + w * 0.707, y + w * 0.707));
+                        painter->drawEllipse(QPointF(x, y), w, w);
                         break;
                     }
                     case ssPixmap: {
             // amalgamation: add datacontainer.cpp
-            /* including file 'src/plottable.cpp', size 38845                            */
+            /* including file 'src/plottable.cpp', size 38861                            */
-            /* commit b0bed12626f942821097f43091126b6fb7163122 2017-08-13 17:17:33 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPSelectionDecorator
             QCPSelectionDecorator::QCPSelectionDecorator()
                     : mPen(QColor(80, 80, 255), 2.5),
                       mBrush(Qt::NoBrush),
-                      mScatterStyle(),
+                      mScatterStyle(QCPScatterStyle::ssNone, QPen(Qt::blue, 2), Qt::NoBrush, 6.0),
-                      mUsedScatterProperties(QCPScatterStyle::spNone),
+                      mUsedScatterProperties(QCPScatterStyle::spPen),
                       mPlottable(0)
             {
             }
               Use this method to define which properties of the scatter style (set via \ref setScatterStyle)
               will be used for selected data segments. All properties of the scatter style that are not
               specified in \a properties will remain as specified in the plottable's original scatter style.
-              \see QCPScatterStyle::ScatterProperty
             */
             void QCPSelectionDecorator::setUsedScatterProperties(
                 const QCPScatterStyle::ScatterProperties &properties)
             /* end of 'src/item.cpp' */
-            /* including file 'src/core.cpp', size 125027                                */
+            /* including file 'src/core.cpp', size 124243                                */
-            /* commit 9ede7553208db59867d1ea9f1988cd90e3c7ffed 2017-08-13 17:25:24 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCustomPlot
                       mOpenGl(false),
                       mMouseHasMoved(false),
                       mMouseEventLayerable(0),
-                      mMouseSignalLayerable(0),
                       mReplotting(false),
                       mReplotQueued(false),
                       mOpenGlMultisamples(16),
                 currentLocale.setNumberOptions(QLocale::OmitGroupSeparator);
                 setLocale(currentLocale);
             #ifdef QCP_DEVICEPIXELRATIO_SUPPORTED
-            #ifdef QCP_DEVICEPIXELRATIO_FLOAT
-                setBufferDevicePixelRatio(QWidget::devicePixelRatioF());
-            #else
                 setBufferDevicePixelRatio(QWidget::devicePixelRatio());
             #endif
-            #endif
                 mOpenGlAntialiasedElementsBackup = mAntialiasedElements;
                 mOpenGlCacheLabelsBackup = mPlottingHints.testFlag(QCP::phCacheLabels);
             }
             /*!
-              \warning This is still an experimental feature and its performance depends on the system that it
-              runs on. Having multiple QCustomPlot widgets in one application with enabled OpenGL rendering
-              might cause context conflicts on some systems.
               This method allows to enable OpenGL plot rendering, for increased plotting performance of
               graphically demanding plots (thick lines, translucent fills, etc.).
                         mSelectionRect->startSelection(event);
                 }
                 else {
-                    // no selection rect interaction, prepare for click signal emission and forward event to
+                    // no selection rect interaction, so forward event to layerable under the cursor:
-                    // layerable under the cursor:
                     QList<QVariant> details;
                     QList<QCPLayerable *> candidates = layerableListAt(mMousePressPos, false, &details);
-                    if (!candidates.isEmpty()) {
-                        mMouseSignalLayerable = candidates.first(); // candidate for signal emission is always
-                                                                    // topmost hit layerable (signal emitted in
-                                                                    // release event)
-                        mMouseSignalLayerableDetails = details.first();
-                    // forward event to topmost candidate which accepts the event:
                     for (int i = 0; i < candidates.size(); ++i) {
-                        event->accept(); // default impl of QCPLayerable's mouse events call ignore() on the
+                        event->accept(); // default impl of QCPLayerable's mouse events ignore the event, in
-                                         // event, in that case propagate to next candidate in list
+                                         // that case propagate to next candidate in list
                         candidates.at(i)->mousePressEvent(event, details.at(i));
                         if (event->isAccepted()) {
                             mMouseEventLayerable = candidates.at(i);
                         processPointSelection(event);
                     // emit specialized click signals of QCustomPlot instance:
-                    if (QCPAbstractPlottable *ap
+                    if (QCPAbstractPlottable *ap = qobject_cast<QCPAbstractPlottable *>(mMouseEventLayerable)) {
-                        = qobject_cast<QCPAbstractPlottable *>(mMouseSignalLayerable)) {
                         int dataIndex = 0;
-                        if (!mMouseSignalLayerableDetails.value<QCPDataSelection>().isEmpty())
+                        if (!mMouseEventLayerableDetails.value<QCPDataSelection>().isEmpty())
                             dataIndex
-                                = mMouseSignalLayerableDetails.value<QCPDataSelection>().dataRange().begin();
+                                = mMouseEventLayerableDetails.value<QCPDataSelection>().dataRange().begin();
                         emit plottableClick(ap, dataIndex, event);
                     }
-                    else if (QCPAxis *ax = qobject_cast<QCPAxis *>(mMouseSignalLayerable))
+                    else if (QCPAxis *ax = qobject_cast<QCPAxis *>(mMouseEventLayerable))
-                        emit axisClick(ax, mMouseSignalLayerableDetails.value<QCPAxis::SelectablePart>(),
+                        emit axisClick(ax, mMouseEventLayerableDetails.value<QCPAxis::SelectablePart>(), event);
-                                       event);
+                    else if (QCPAbstractItem *ai = qobject_cast<QCPAbstractItem *>(mMouseEventLayerable))
-                    else if (QCPAbstractItem *ai = qobject_cast<QCPAbstractItem *>(mMouseSignalLayerable))
                         emit itemClick(ai, event);
-                    else if (QCPLegend *lg = qobject_cast<QCPLegend *>(mMouseSignalLayerable))
+                    else if (QCPLegend *lg = qobject_cast<QCPLegend *>(mMouseEventLayerable))
                         emit legendClick(lg, 0, event);
                     else if (QCPAbstractLegendItem *li
-                             = qobject_cast<QCPAbstractLegendItem *>(mMouseSignalLayerable))
+                             = qobject_cast<QCPAbstractLegendItem *>(mMouseEventLayerable))
                         emit legendClick(li->parentLegend(), li, event);
-                    mMouseSignalLayerable = 0;
                 }
                 if (mSelectionRect && mSelectionRect->isActive()) // Note: if a click was detected above, the
                                         hue -= 1.0;
                                     if (useAlpha) {
                                         const QRgb rgb
-                                            = QColor::fromHsvF(hue, (1 - t) * lowHsv.saturationF()
+                                            = QColor::fromHsvF(hue,
-                                                                        + t * highHsv.saturationF(),
+                                                               (1 - t) * lowHsv.saturationF()
+                                                                   + t * highHsv.saturationF(),
                                                                (1 - t) * lowHsv.valueF() + t * highHsv.valueF())
                                                   .rgb();
                                         const float alpha = (1 - t) * lowHsv.alphaF() + t * highHsv.alphaF();
                                     }
                                     else {
                                         mColorBuffer[i]
-                                            = QColor::fromHsvF(hue, (1 - t) * lowHsv.saturationF()
+                                            = QColor::fromHsvF(hue,
-                                                                        + t * highHsv.saturationF(),
+                                                               (1 - t) * lowHsv.saturationF()
+                                                                   + t * highHsv.saturationF(),
                                                                (1 - t) * lowHsv.valueF() + t * highHsv.valueF())
                                                   .rgb();
                                     }
             /* end of 'src/selectiondecorator-bracket.cpp' */
-            /* including file 'src/layoutelements/layoutelement-axisrect.cpp', size 47584 */
+            /* including file 'src/layoutelements/layoutelement-axisrect.cpp', size 47509 */
-            /* commit 77ba168312f935543fc31d1ae9b4cdcf34aae4f9 2017-08-13 18:29:48 +0200  */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200  */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
               new QCPAxis instance is created internally. QCustomPlot owns the returned axis, so if you want to
               remove an axis, use \ref removeAxis instead of deleting it manually.
-              You may inject QCPAxis instances (or subclasses of QCPAxis) by setting \a axis to an axis that was
+              You may inject QCPAxis instances (or sublasses of QCPAxis) by setting \a axis to an axis that was
               previously created outside QCustomPlot. It is important to note that QCustomPlot takes ownership
               of the axis, so you may not delete it afterwards. Further, the \a axis must have been created
               with this axis rect as parent and with the same axis type as specified in \a type. If this is not
                 while (it.hasNext()) {
                     it.next();
                     if (it.value().contains(axis)) {
-                        if (it.value().first() == axis && it.value().size() > 1) // if removing first axis,
-                                                                                 // transfer axis offset to the
-                                                                                 // new first axis (which at
-                                                                                 // this point is the second
-                                                                                 // axis, if it exists)
-                            it.value()[1]->setOffset(axis->offset());
                         mAxes[it.key()].removeOne(axis);
                         if (qobject_cast<QCustomPlot *>(parentPlot())) // make sure this isn't called from
                                                                        // QObject dtor when QCustomPlot is
             void QCPAxisRect::mousePressEvent(QMouseEvent *event, const QVariant &details)
             {
                 Q_UNUSED(details)
+                mDragStart = event->pos(); // need this even when not LeftButton is pressed, to determine in
+                                           // releaseEvent whether it was a full click (no position change
+                                           // between press and release)
                 if (event->buttons() & Qt::LeftButton) {
                     mDragging = true;
                     // initialize antialiasing backup in case we start dragging:
                                 break;
                             if (ax->mScaleType == QCPAxis::stLinear) {
                                 double diff
-                                    = ax->pixelToCoord(startPos.x()) - ax->pixelToCoord(event->pos().x());
+                                    = ax->pixelToCoord(mDragStart.x()) - ax->pixelToCoord(event->pos().x());
                                 ax->setRange(mDragStartHorzRange.at(i).lower + diff,
                                              mDragStartHorzRange.at(i).upper + diff);
                             }
                             else if (ax->mScaleType == QCPAxis::stLogarithmic) {
                                 double diff
-                                    = ax->pixelToCoord(startPos.x()) / ax->pixelToCoord(event->pos().x());
+                                    = ax->pixelToCoord(mDragStart.x()) / ax->pixelToCoord(event->pos().x());
                                 ax->setRange(mDragStartHorzRange.at(i).lower * diff,
                                              mDragStartHorzRange.at(i).upper * diff);
                             }
                                 break;
                             if (ax->mScaleType == QCPAxis::stLinear) {
                                 double diff
-                                    = ax->pixelToCoord(startPos.y()) - ax->pixelToCoord(event->pos().y());
+                                    = ax->pixelToCoord(mDragStart.y()) - ax->pixelToCoord(event->pos().y());
                                 ax->setRange(mDragStartVertRange.at(i).lower + diff,
                                              mDragStartVertRange.at(i).upper + diff);
                             }
                             else if (ax->mScaleType == QCPAxis::stLogarithmic) {
                                 double diff
-                                    = ax->pixelToCoord(startPos.y()) / ax->pixelToCoord(event->pos().y());
+                                    = ax->pixelToCoord(mDragStart.y()) / ax->pixelToCoord(event->pos().y());
                                 ax->setRange(mDragStartVertRange.at(i).lower * diff,
                                              mDragStartVertRange.at(i).upper * diff);
                             }
                     {
                         if (mParentPlot->noAntialiasingOnDrag())
                             mParentPlot->setNotAntialiasedElements(QCP::aeAll);
-                        mParentPlot->replot(QCustomPlot::rpQueuedReplot);
+                        mParentPlot->replot();
                     }
                 }
             }
             /* end of 'src/layoutelements/layoutelement-axisrect.cpp' */
-            /* including file 'src/layoutelements/layoutelement-legend.cpp', size 30971  */
+            /* including file 'src/layoutelements/layoutelement-legend.cpp', size 30933  */
-            /* commit 305808813c9c6451dca8399c2fc66d68ebd24b5e 2017-08-15 23:03:07 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPAbstractLegendItem
               QCPLegend::setIconBorderPen and \ref QCPLegend::setIconTextPadding.
               The function \ref QCPAbstractPlottable::addToLegend/\ref QCPAbstractPlottable::removeFromLegend
-              creates/removes legend items of this type.
+              creates/removes legend items of this type in the default implementation. However, these functions
+              may be reimplemented such that a different kind of legend item (e.g a direct subclass of
+              QCPAbstractLegendItem) is used for that plottable.
               Since QCPLegend is based on QCPLayoutGrid, a legend item itself is just a subclass of
               QCPLayoutElement. While it could be added to a legend (or any other layout) via the normal layout
                 QSize iconSize = mParentLegend->iconSize();
                 textRect = fontMetrics.boundingRect(0, 0, 0, iconSize.height(), Qt::TextDontClip,
                                                     mPlottable->name());
-                result.setWidth(iconSize.width() + mParentLegend->iconTextPadding() + textRect.width());
+                result.setWidth(iconSize.width() + mParentLegend->iconTextPadding() + textRect.width()
-                result.setHeight(qMax(textRect.height(), iconSize.height()));
+                                + mMargins.left() + mMargins.right());
+                result.setHeight(qMax(textRect.height(), iconSize.height()) + mMargins.top()
+                                 + mMargins.bottom());
                 return result;
             }
               A legend is a small box somewhere in the plot which lists plottables with their name and icon.
-              A legend is populated with legend items by calling \ref QCPAbstractPlottable::addToLegend on the
+              Normally, the legend is populated by calling \ref QCPAbstractPlottable::addToLegend. The
-              plottable, for which a legend item shall be created. In the case of the main legend (\ref
+              respective legend item can be removed with \ref QCPAbstractPlottable::removeFromLegend. However,
-              QCustomPlot::legend), simply adding plottables to the plot while \ref
+              QCPLegend also offers an interface to add and manipulate legend items directly: \ref item, \ref
-              QCustomPlot::setAutoAddPlottableToLegend is set to true (the default) creates corresponding
+              itemWithPlottable, \ref itemCount, \ref addItem, \ref removeItem, etc.
-              legend items. The legend item associated with a certain plottable can be removed with \ref
-              QCPAbstractPlottable::removeFromLegend. However, QCPLegend also offers an interface to add and
-              manipulate legend items directly: \ref item, \ref itemWithPlottable, \ref itemCount, \ref
-              addItem, \ref removeItem, etc.
               Since \ref QCPLegend derives from \ref QCPLayoutGrid, it can be placed in any position a \ref
               QCPLayoutElement may be positioned. The legend items are themselves \ref QCPLayoutElement
             /* end of 'src/layoutelements/layoutelement-legend.cpp' */
-            /* including file 'src/layoutelements/layoutelement-textelement.cpp', size 12561 */
+            /* including file 'src/layoutelements/layoutelement-textelement.cpp', size 12759 */
-            /* commit a872eb91ec087561efd83dd9cb041a26ab95ce55 2017-07-31 00:21:41 +0200     */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200     */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPTextElement
             QSize QCPTextElement::minimumSizeHint() const
             {
                 QFontMetrics metrics(mFont);
-                return metrics.boundingRect(0, 0, 0, 0, Qt::AlignCenter, mText).size();
+                QSize result = metrics.boundingRect(0, 0, 0, 0, Qt::AlignCenter, mText).size();
+                result.rwidth() += mMargins.left() + mMargins.right();
+                result.rheight() += mMargins.top() + mMargins.bottom();
+                return result;
             }
             /* inherits documentation from base class */
             {
                 QFontMetrics metrics(mFont);
                 QSize result = metrics.boundingRect(0, 0, 0, 0, Qt::AlignCenter, mText).size();
+                result.rheight() += mMargins.top() + mMargins.bottom();
                 result.setWidth(QWIDGETSIZE_MAX);
                 return result;
             }
                 switch (phase) {
                     case upMargins: {
                         if (mType == QCPAxis::atBottom || mType == QCPAxis::atTop) {
-                            setMaximumSize(QWIDGETSIZE_MAX, mBarWidth + mAxisRect.data()->margins().top()
+                            setMaximumSize(QWIDGETSIZE_MAX,
-                                                                + mAxisRect.data()->margins().bottom()
+                                           mBarWidth + mAxisRect.data()->margins().top()
-                                                                + margins().top() + margins().bottom());
+                                               + mAxisRect.data()->margins().bottom() + margins().top()
-                            setMinimumSize(0, mBarWidth + mAxisRect.data()->margins().top()
+                                               + margins().bottom());
-                                                  + mAxisRect.data()->margins().bottom() + margins().top()
+                            setMinimumSize(0,
-                                                  + margins().bottom());
+                                           mBarWidth + mAxisRect.data()->margins().top()
+                                               + mAxisRect.data()->margins().bottom() + margins().top()
+                                               + margins().bottom());
                         }
                         else {
                             setMaximumSize(mBarWidth + mAxisRect.data()->margins().left()
             /* end of 'src/layoutelements/layoutelement-colorscale.cpp' */
-            /* including file 'src/plottables/plottable-graph.cpp', size 73960           */
+            /* including file 'src/plottables/plottable-graph.cpp', size 72363           */
-            /* commit 7e7381ef4f218e004d72a218820634fff0959d1b 2017-08-02 00:02:36 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPGraphData
                 if (mLineStyle != lsNone)
                     getOptimizedLineData(&lineData, begin, end);
-                if (mKeyAxis->rangeReversed()
-                    != (mKeyAxis->orientation() == Qt::Vertical)) // make sure key pixels are sorted ascending
-                                                                  // in lineData (significantly simplifies
-                                                                  // following processing)
-                    std::reverse(lineData.begin(), lineData.end());
                 switch (mLineStyle) {
                     case lsNone:
                         lines->clear();
                 QVector<QCPGraphData> data;
                 getOptimizedScatterData(&data, begin, end);
-                if (mKeyAxis->rangeReversed()
-                    != (mKeyAxis->orientation() == Qt::Vertical)) // make sure key pixels are sorted ascending
-                                                                  // in data (significantly simplifies following
-                                                                  // processing)
-                    std::reverse(data.begin(), data.end());
                 scatters->resize(data.size());
                 if (keyAxis->orientation() == Qt::Vertical) {
                     for (int i = 0; i < data.size(); ++i) {
                     return result;
                 }
+                result.reserve(data.size() + 2); // added 2 to reserve memory for lower/upper fill base points
+                                                 // that might be needed for fill
                 result.resize(data.size());
                 // transform data points to pixels:
                     return result;
                 }
+                result.reserve(data.size() * 2 + 2); // added 2 to reserve memory for lower/upper fill base
+                                                     // points that might be needed for fill
                 result.resize(data.size() * 2);
                 // calculate steps from data and transform to pixel coordinates:
                     return result;
                 }
+                result.reserve(data.size() * 2 + 2); // added 2 to reserve memory for lower/upper fill base
+                                                     // points that might be needed for fill
                 result.resize(data.size() * 2);
                 // calculate steps from data and transform to pixel coordinates:
                     return result;
                 }
+                result.reserve(data.size() * 2 + 2); // added 2 to reserve memory for lower/upper fill base
+                                                     // points that might be needed for fill
                 result.resize(data.size() * 2);
                 // calculate steps from data and transform to pixel coordinates:
                     return result;
                 }
-                result.resize(data.size() * 2);
+                result.resize(data.size()
+                              * 2); // no need to reserve 2 extra points because impulse plot has no fill
                 // transform data points to pixels:
                 if (keyAxis->orientation() == Qt::Vertical) {
               Draws the fill of the graph using the specified \a painter, with the currently set brush.
-              Depending on whether a normal fill or a channel fill (\ref setChannelFillGraph) is needed, \ref
+              \a lines contains the points of the graph line, in pixel coordinates.
-              getFillPolygon or \ref getChannelFillPolygon are used to find the according fill polygons.
-              In order to handle NaN Data points correctly (the fill needs to be split into disjoint areas),
+              If the fill is a normal fill towards the zero-value-line, only the points in \a lines are
-              this method first determines a list of non-NaN segments with \ref getNonNanSegments, on which to
+              required and two extra points at the zero-value-line, which are added by \ref addFillBasePoints
-              operate. In the channel fill case, \ref getOverlappingSegments is used to consolidate the non-NaN
+              and removed by \ref removeFillBasePoints after the fill drawing is done.
-              segments of the two involved graphs, before passing the overlapping pairs to \ref
-              getChannelFillPolygon.
-              Pass the points of this graph's line as \a lines, in pixel coordinates.
+              On the other hand if the fill is a channel fill between this QCPGraph and another QCPGraph (\a
+              mChannelFillGraph), the more complex polygon is calculated with the \ref getChannelFillPolygon
+              function, and then drawn.
               \see drawLinePlot, drawImpulsePlot, drawScatterPlot
             */
                     return;
                 applyFillAntialiasingHint(painter);
-                QVector<QCPDataRange> segments = getNonNanSegments(lines, keyAxis()->orientation());
                 if (!mChannelFillGraph) {
                     // draw base fill under graph, fill goes all the way to the zero-value-line:
-                    for (int i = 0; i < segments.size(); ++i)
+                    addFillBasePoints(lines);
-                        painter->drawPolygon(getFillPolygon(lines, segments.at(i)));
+                    painter->drawPolygon(QPolygonF(*lines));
+                    removeFillBasePoints(lines);
                 }
                 else {
-                    // draw fill between this graph and mChannelFillGraph:
+                    // draw channel fill between this graph and mChannelFillGraph:
-                    QVector<QPointF> otherLines;
+                    painter->drawPolygon(getChannelFillPolygon(lines));
-                    mChannelFillGraph->getLines(&otherLines, QCPDataRange(0, mChannelFillGraph->dataCount()));
-                    if (!otherLines.isEmpty()) {
-                        QVector<QCPDataRange> otherSegments
-                            = getNonNanSegments(&otherLines, mChannelFillGraph->keyAxis()->orientation());
-                        QVector<QPair<QCPDataRange, QCPDataRange> > segmentPairs
-                            = getOverlappingSegments(segments, lines, otherSegments, &otherLines);
-                        for (int i = 0; i < segmentPairs.size(); ++i)
-                            painter->drawPolygon(getChannelFillPolygon(lines, segmentPairs.at(i).first,
-                                                                       &otherLines, segmentPairs.at(i).second));
                 }
             }
                 else // don't use adaptive sampling algorithm, transfer points one-to-one from the data
                      // container into the output
                 {
-                    lineData->resize(dataCount);
+                    QCPGraphDataContainer::const_iterator it = begin;
-                    std::copy(begin, end, lineData->begin());
+                    lineData->reserve(dataCount + 2); // +2 for possible fill end points
+                    while (it != end) {
+                        lineData->append(*it);
+                        ++it;
+                    }
                 }
             }
                 }
             }
-            /*!  \internal
+            /*! \internal
-              This method goes through the passed points in \a lineData and returns a list of the segments
+              The line vector generated by e.g. \ref getLines describes only the line that connects the data
-              which don't contain NaN data points.
+              points. If the graph needs to be filled, two additional points need to be added at the
+              value-zero-line in the lower and upper key positions of the graph. This function calculates these
+              points and adds them to the end of \a lineData. Since the fill is typically drawn before the line
+              stroke, these added points need to be removed again after the fill is done, with the
+              removeFillBasePoints function.
-              \a keyOrientation defines whether the \a x or \a y member of the passed QPointF is used to check
+              The expanding of \a lines by two points will not cause unnecessary memory reallocations, because
-              for NaN. If \a keyOrientation is \c Qt::Horizontal, the \a y member is checked, if it is \c
+              the data vector generation functions (e.g. \ref getLines) reserve two extra points when they
-              Qt::Vertical, the \a x member is checked.
+              allocate memory for \a lines.
-              \see getOverlappingSegments, drawFill
+              \see removeFillBasePoints, lowerFillBasePoint, upperFillBasePoint
             */
-            QVector<QCPDataRange> QCPGraph::getNonNanSegments(const QVector<QPointF> *lineData,
+            void QCPGraph::addFillBasePoints(QVector<QPointF> *lines) const
-                                                              Qt::Orientation keyOrientation) const
             {
-                QVector<QCPDataRange> result;
+                if (!mKeyAxis) {
-                const int n = lineData->size();
+                    qDebug() << Q_FUNC_INFO << "invalid key axis";
+                    return;
-                QCPDataRange currentSegment(-1, -1);
-                int i = 0;
+                if (!lines) {
+                    qDebug() << Q_FUNC_INFO << "passed null as lineData";
+                    return;
+                }
+                if (lines->isEmpty())
+                    return;
-                if (keyOrientation == Qt::Horizontal) {
+                // append points that close the polygon fill at the key axis:
-                    while (i < n) {
+                if (mKeyAxis.data()->orientation() == Qt::Vertical) {
-                        while (i < n && qIsNaN(lineData->at(i).y())) // seek next non-NaN data point
+                    *lines << upperFillBasePoint(lines->last().y());
-                            ++i;
+                    *lines << lowerFillBasePoint(lines->first().y());
-                        if (i == n)
-                            break;
-                        currentSegment.setBegin(i++);
-                        while (i < n && !qIsNaN(lineData->at(i).y())) // seek next NaN data point or end of data
-                            ++i;
-                        currentSegment.setEnd(i++);
-                        result.append(currentSegment);
                 }
-                else // keyOrientation == Qt::Vertical
+                else {
+                    *lines << upperFillBasePoint(lines->last().x());
-                    while (i < n) {
+                    *lines << lowerFillBasePoint(lines->first().x());
-                        while (i < n && qIsNaN(lineData->at(i).x())) // seek next non-NaN data point
-                            ++i;
-                        if (i == n)
-                            break;
-                        currentSegment.setBegin(i++);
-                        while (i < n && !qIsNaN(lineData->at(i).x())) // seek next NaN data point or end of data
-                            ++i;
-                        currentSegment.setEnd(i++);
-                        result.append(currentSegment);
                 }
-                return result;
             }
-            /*!  \internal
+            /*! \internal
-              This method takes two segment lists (e.g. created by \ref getNonNanSegments) \a thisSegments and
-              \a otherSegments, and their associated point data \a thisData and \a otherData.
-              It returns all pairs of segments (the first from \a thisSegments, the second from \a
-              otherSegments), which overlap in plot coordinates.
-              This method is useful in the case of a channel fill between two graphs, when only those non-NaN
-              segments which actually overlap in their key coordinate shall be considered for drawing a channel
-              fill polygon.
-              It is assumed that the passed segments in \a thisSegments are ordered ascending by index, and
+              removes the two points from \a lines that were added by \ref addFillBasePoints.
-              that the segments don't overlap themselves. The same is assumed for the segments in \a
-              otherSegments. This is fulfilled when the segments are obtained via \ref getNonNanSegments.
-              \see getNonNanSegments, segmentsIntersect, drawFill, getChannelFillPolygon
+              \see addFillBasePoints, lowerFillBasePoint, upperFillBasePoint
             */
-            QVector<QPair<QCPDataRange, QCPDataRange> > QCPGraph::getOverlappingSegments(
+            void QCPGraph::removeFillBasePoints(QVector<QPointF> *lines) const
-                QVector<QCPDataRange> thisSegments, const QVector<QPointF> *thisData,
-                QVector<QCPDataRange> otherSegments, const QVector<QPointF> *otherData) const
             {
-                QVector<QPair<QCPDataRange, QCPDataRange> > result;
+                if (!lines) {
-                if (thisData->isEmpty() || otherData->isEmpty() || thisSegments.isEmpty()
+                    qDebug() << Q_FUNC_INFO << "passed null as lineData";
-                    || otherSegments.isEmpty())
+                    return;
-                    return result;
-                int thisIndex = 0;
-                int otherIndex = 0;
-                const bool verticalKey = mKeyAxis->orientation() == Qt::Vertical;
-                while (thisIndex < thisSegments.size() && otherIndex < otherSegments.size()) {
-                    if (thisSegments.at(thisIndex).size()
-                        < 2) // segments with fewer than two points won't have a fill anyhow
-                        ++thisIndex;
-                        continue;
-                    if (otherSegments.at(otherIndex).size()
-                        < 2) // segments with fewer than two points won't have a fill anyhow
-                        ++otherIndex;
-                        continue;
-                    double thisLower, thisUpper, otherLower, otherUpper;
-                    if (!verticalKey) {
-                        thisLower = thisData->at(thisSegments.at(thisIndex).begin()).x();
-                        thisUpper = thisData->at(thisSegments.at(thisIndex).end() - 1).x();
-                        otherLower = otherData->at(otherSegments.at(otherIndex).begin()).x();
-                        otherUpper = otherData->at(otherSegments.at(otherIndex).end() - 1).x();
-                    else {
-                        thisLower = thisData->at(thisSegments.at(thisIndex).begin()).y();
-                        thisUpper = thisData->at(thisSegments.at(thisIndex).end() - 1).y();
-                        otherLower = otherData->at(otherSegments.at(otherIndex).begin()).y();
-                        otherUpper = otherData->at(otherSegments.at(otherIndex).end() - 1).y();
-                    int bPrecedence;
-                    if (segmentsIntersect(thisLower, thisUpper, otherLower, otherUpper, bPrecedence))
-                        result.append(QPair<QCPDataRange, QCPDataRange>(thisSegments.at(thisIndex),
-                                                                        otherSegments.at(otherIndex)));
-                    if (bPrecedence <= 0) // otherSegment doesn't reach as far as thisSegment, so continue with
-                                          // next otherSegment, keeping current thisSegment
-                        ++otherIndex;
-                    else // otherSegment reaches further than thisSegment, so continue with next thisSegment,
-                         // keeping current otherSegment
-                        ++thisIndex;
                 }
+                if (lines->isEmpty())
+                    return;
-                return result;
+                lines->remove(lines->size() - 2, 2);
             }
-            /*!  \internal
+            /*! \internal
-              Returns whether the segments defined by the coordinates (aLower, aUpper) and (bLower, bUpper)
-              have overlap.
-              The output parameter \a bPrecedence indicates whether the \a b segment reaches farther than the
+              called by \ref addFillBasePoints to conveniently assign the point which closes the fill polygon
-              \a a segment or not. If \a bPrecedence returns 1, segment \a b reaches the farthest to higher
+              on the lower side of the zero-value-line parallel to the key axis. The logarithmic axis scale
-              coordinates (i.e. bUpper > aUpper). If it returns -1, segment \a a reaches the farthest. Only if
+              case is a bit special, since the zero-value-line in pixel coordinates is in positive or negative
-              both segment's upper bounds are identical, 0 is returned as \a bPrecedence.
+              infinity. So this case is handled separately by just closing the fill polygon on the axis which
+              lies in the direction towards the zero value.
-              It is assumed that the lower bounds always have smaller or equal values than the upper bounds.
+              \a lowerKey will be the the key (in pixels) of the returned point. Depending on whether the key
+              axis is horizontal or vertical, \a lowerKey will end up as the x or y value of the returned
+              point, respectively.
-              \see getOverlappingSegments
+              \see upperFillBasePoint, addFillBasePoints
             */
-            bool QCPGraph::segmentsIntersect(double aLower, double aUpper, double bLower, double bUpper,
+            QPointF QCPGraph::lowerFillBasePoint(double lowerKey) const
-                                             int &bPrecedence) const
             {
-                bPrecedence = 0;
+                QCPAxis *keyAxis = mKeyAxis.data();
-                if (aLower > bUpper) {
+                QCPAxis *valueAxis = mValueAxis.data();
-                    bPrecedence = -1;
+                if (!keyAxis || !valueAxis) {
-                    return false;
+                    qDebug() << Q_FUNC_INFO << "invalid key or value axis";
+                    return QPointF();
-                else if (bLower > aUpper) {
-                    bPrecedence = 1;
-                    return false;
                 }
-                else {
-                    if (aUpper > bUpper)
-                        bPrecedence = -1;
-                    else if (aUpper < bUpper)
-                        bPrecedence = 1;
-                    return true;
+                QPointF point;
+                if (valueAxis->scaleType() == QCPAxis::stLinear) {
+                    if (keyAxis->axisType() == QCPAxis::atLeft) {
+                        point.setX(valueAxis->coordToPixel(0));
+                        point.setY(lowerKey);
+                    }
+                    else if (keyAxis->axisType() == QCPAxis::atRight) {
+                        point.setX(valueAxis->coordToPixel(0));
+                        point.setY(lowerKey);
+                    }
+                    else if (keyAxis->axisType() == QCPAxis::atTop) {
+                        point.setX(lowerKey);
+                        point.setY(valueAxis->coordToPixel(0));
+                    }
+                    else if (keyAxis->axisType() == QCPAxis::atBottom) {
+                        point.setX(lowerKey);
+                        point.setY(valueAxis->coordToPixel(0));
+                    }
                 }
+                else // valueAxis->mScaleType == QCPAxis::stLogarithmic
+                {
+                    // In logarithmic scaling we can't just draw to value zero so we just fill all the way
+                    // to the axis which is in the direction towards zero
+                    if (keyAxis->orientation() == Qt::Vertical) {
+                        if ((valueAxis->range().upper < 0 && !valueAxis->rangeReversed())
+                            || (valueAxis->range().upper > 0 && valueAxis->rangeReversed())) // if range is
+                                                                                             // negative, zero
+                                                                                             // is on opposite
+                                                                                             // side of key axis
+                            point.setX(keyAxis->axisRect()->right());
+                        else
+                            point.setX(keyAxis->axisRect()->left());
+                        point.setY(lowerKey);
+                    }
+                    else if (keyAxis->axisType() == QCPAxis::atTop
+                             || keyAxis->axisType() == QCPAxis::atBottom) {
+                        point.setX(lowerKey);
+                        if ((valueAxis->range().upper < 0 && !valueAxis->rangeReversed())
+                            || (valueAxis->range().upper > 0 && valueAxis->rangeReversed())) // if range is
+                                                                                             // negative, zero
+                                                                                             // is on opposite
+                                                                                             // side of key axis
+                            point.setY(keyAxis->axisRect()->top());
+                        else
+                            point.setY(keyAxis->axisRect()->bottom());
+                    }
+                }
+                return point;
             }
             /*! \internal
-              Returns the point which closes the fill polygon on the zero-value-line parallel to the key axis.
+              called by \ref addFillBasePoints to conveniently assign the point which closes the fill
-              The logarithmic axis scale case is a bit special, since the zero-value-line in pixel coordinates
+              polygon on the upper side of the zero-value-line parallel to the key axis. The logarithmic axis
-              is in positive or negative infinity. So this case is handled separately by just closing the fill
+              scale case is a bit special, since the zero-value-line in pixel coordinates is in positive or
-              polygon on the axis which lies in the direction towards the zero value.
+              negative infinity. So this case is handled separately by just closing the fill polygon on the
+              axis which lies in the direction towards the zero value.
-              \a matchingDataPoint will provide the key (in pixels) of the returned point. Depending on whether
+              \a upperKey will be the the key (in pixels) of the returned point. Depending on whether the key
-              the key axis of this graph is horizontal or vertical, \a matchingDataPoint will provide the x or
+              axis is horizontal or vertical, \a upperKey will end up as the x or y value of the returned
-              y value of the returned point, respectively.
+              point, respectively.
+              \see lowerFillBasePoint, addFillBasePoints
             */
-            QPointF QCPGraph::getFillBasePoint(QPointF matchingDataPoint) const
+            QPointF QCPGraph::upperFillBasePoint(double upperKey) const
             {
                 QCPAxis *keyAxis = mKeyAxis.data();
                 QCPAxis *valueAxis = mValueAxis.data();
                     return QPointF();
                 }
-                QPointF result;
+                QPointF point;
                 if (valueAxis->scaleType() == QCPAxis::stLinear) {
-                    if (keyAxis->orientation() == Qt::Horizontal) {
+                    if (keyAxis->axisType() == QCPAxis::atLeft) {
-                        result.setX(matchingDataPoint.x());
+                        point.setX(valueAxis->coordToPixel(0));
-                        result.setY(valueAxis->coordToPixel(0));
+                        point.setY(upperKey);
                     }
-                    else // keyAxis->orientation() == Qt::Vertical
+                    else if (keyAxis->axisType() == QCPAxis::atRight) {
+                        point.setX(valueAxis->coordToPixel(0));
-                        result.setX(valueAxis->coordToPixel(0));
+                        point.setY(upperKey);
-                        result.setY(matchingDataPoint.y());
+                    else if (keyAxis->axisType() == QCPAxis::atTop) {
+                        point.setX(upperKey);
+                        point.setY(valueAxis->coordToPixel(0));
+                    }
+                    else if (keyAxis->axisType() == QCPAxis::atBottom) {
+                        point.setX(upperKey);
+                        point.setY(valueAxis->coordToPixel(0));
                     }
                 }
                 else // valueAxis->mScaleType == QCPAxis::stLogarithmic
                                                                                              // negative, zero
                                                                                              // is on opposite
                                                                                              // side of key axis
-                            result.setX(keyAxis->axisRect()->right());
+                            point.setX(keyAxis->axisRect()->right());
                         else
-                            result.setX(keyAxis->axisRect()->left());
+                            point.setX(keyAxis->axisRect()->left());
-                        result.setY(matchingDataPoint.y());
+                        point.setY(upperKey);
                     }
                     else if (keyAxis->axisType() == QCPAxis::atTop
                              || keyAxis->axisType() == QCPAxis::atBottom) {
-                        result.setX(matchingDataPoint.x());
+                        point.setX(upperKey);
                         if ((valueAxis->range().upper < 0 && !valueAxis->rangeReversed())
                             || (valueAxis->range().upper > 0 && valueAxis->rangeReversed())) // if range is
                                                                                              // negative, zero
                                                                                              // is on opposite
                                                                                              // side of key axis
-                            result.setY(keyAxis->axisRect()->top());
+                            point.setY(keyAxis->axisRect()->top());
                         else
-                            result.setY(keyAxis->axisRect()->bottom());
+                            point.setY(keyAxis->axisRect()->bottom());
                     }
                 }
-                return result;
+                return point;
             }
             /*! \internal
-              Returns the polygon needed for drawing normal fills between this graph and the key axis.
+              Generates the polygon needed for drawing channel fills between this graph and the graph specified
+              in \a mChannelFillGraph (see \ref setChannelFillGraph). The data points representing the line of
+              this graph in pixel coordinates must be passed in \a lines, the corresponding points of the other
+              graph are generated by calling its \ref getLines method.
-              Pass the graph's data points (in pixel coordinates) as \a lineData, and specify the \a segment
+              This method may return an empty polygon if the key ranges of the two graphs have no overlap of if
-              which shall be used for the fill. The collection of \a lineData points described by \a segment
+              they don't have the same orientation (e.g. one key axis vertical, the other horizontal). For
-              must not contain NaN data points (see \ref getNonNanSegments).
+              increased performance (due to implicit sharing), it is recommended to keep the returned QPolygonF
+              const.
-              The returned fill polygon will be closed at the key axis (the zero-value line) for linear value
-              axes. For logarithmic value axes the polygon will reach just beyond the corresponding axis rect
-              side (see \ref getFillBasePoint).
-              For increased performance (due to implicit sharing), keep the returned QPolygonF const.
-              \see drawFill, getNonNanSegments
-            */
-            const QPolygonF QCPGraph::getFillPolygon(const QVector<QPointF> *lineData,
-                                                     QCPDataRange segment) const
-                if (segment.size() < 2)
-                    return QPolygonF();
-                QPolygonF result(segment.size() + 2);
-                result[0] = getFillBasePoint(lineData->at(segment.begin()));
-                std::copy(lineData->constBegin() + segment.begin(), lineData->constBegin() + segment.end(),
-                          result.begin() + 1);
-                result[result.size() - 1] = getFillBasePoint(lineData->at(segment.end() - 1));
-                return result;
-            /*! \internal
-              Returns the polygon needed for drawing (partial) channel fills between this graph and the graph
-              specified by \ref setChannelFillGraph.
-              The data points of this graph are passed as pixel coordinates via \a thisData, the data of the
-              other graph as \a otherData. The returned polygon will be calculated for the specified data
-              segments \a thisSegment and \a otherSegment, pertaining to the respective \a thisData and \a
-              otherData, respectively.
-              The passed \a thisSegment and \a otherSegment should correspond to the segment pairs returned by
-              \ref getOverlappingSegments, to make sure only segments that actually have key coordinate overlap
-              need to be processed here.
-              For increased performance due to implicit sharing, keep the returned QPolygonF const.
-              \see drawFill, getOverlappingSegments, getNonNanSegments
             */
-            const QPolygonF QCPGraph::getChannelFillPolygon(const QVector<QPointF> *thisData,
+            const QPolygonF QCPGraph::getChannelFillPolygon(const QVector<QPointF> *lines) const
-                                                            QCPDataRange thisSegment,
-                                                            const QVector<QPointF> *otherData,
-                                                            QCPDataRange otherSegment) const
             {
                 if (!mChannelFillGraph)
                     return QPolygonF();
                                         // fits, valueAxis will fit too, because it's always orthogonal to
                                         // keyAxis)
-                if (thisData->isEmpty())
+                if (lines->isEmpty())
                     return QPolygonF();
-                QVector<QPointF> thisSegmentData(thisSegment.size());
+                QVector<QPointF> otherData;
-                QVector<QPointF> otherSegmentData(otherSegment.size());
+                mChannelFillGraph.data()->getLines(&otherData,
-                std::copy(thisData->constBegin() + thisSegment.begin(),
+                                                   QCPDataRange(0, mChannelFillGraph.data()->dataCount()));
-                          thisData->constBegin() + thisSegment.end(), thisSegmentData.begin());
+                if (otherData.isEmpty())
-                std::copy(otherData->constBegin() + otherSegment.begin(),
+                    return QPolygonF();
-                          otherData->constBegin() + otherSegment.end(), otherSegmentData.begin());
+                QVector<QPointF> thisData;
+                thisData.reserve(
+                    lines->size()
+                    + otherData.size()); // because we will join both vectors at end of this function
+                for (int i = 0; i < lines->size(); ++i) // don't use the vector<<(vector),  it squeezes
+                                                        // internally, which ruins the performance tuning with
+                                                        // reserve()
+                    thisData << lines->at(i);
                 // pointers to be able to swap them, depending which data range needs cropping:
-                QVector<QPointF> *staticData = &thisSegmentData;
+                QVector<QPointF> *staticData = &thisData;
-                QVector<QPointF> *croppedData = &otherSegmentData;
+                QVector<QPointF> *croppedData = &otherData;
                 // crop both vectors to ranges in which the keys overlap (which coord is key, depends on
                 // axisType):
                 if (keyAxis->orientation() == Qt::Horizontal) {
                     // x is key
+                    // if an axis range is reversed, the data point keys will be descending. Reverse them, since
+                    // following algorithm assumes ascending keys:
+                    if (staticData->first().x() > staticData->last().x()) {
+                        int size = staticData->size();
+                        for (int i = 0; i < size / 2; ++i)
+                            qSwap((*staticData)[i], (*staticData)[size - 1 - i]);
+                    }
+                    if (croppedData->first().x() > croppedData->last().x()) {
+                        int size = croppedData->size();
+                        for (int i = 0; i < size / 2; ++i)
+                            qSwap((*croppedData)[i], (*croppedData)[size - 1 - i]);
+                    }
                     // crop lower bound:
                     if (staticData->first().x() < croppedData->first().x()) // other one must be cropped
                         qSwap(staticData, croppedData);
-                    const int lowBound = findIndexBelowX(croppedData, staticData->first().x());
+                    int lowBound = findIndexBelowX(croppedData, staticData->first().x());
                     if (lowBound == -1)
                         return QPolygonF(); // key ranges have no overlap
                     croppedData->remove(0, lowBound);
-                    // set lowest point of cropped data to fit exactly key position of first static data point
+                    // set lowest point of cropped data to fit exactly key position of first static data
-                    // via linear interpolation:
+                    // point via linear interpolation:
                     if (croppedData->size() < 2)
                         return QPolygonF(); // need at least two points for interpolation
                     double slope;
-                    if (!qFuzzyCompare(croppedData->at(1).x(), croppedData->at(0).x()))
+                    if (croppedData->at(1).x() - croppedData->at(0).x() != 0)
                         slope = (croppedData->at(1).y() - croppedData->at(0).y())
                                 / (croppedData->at(1).x() - croppedData->at(0).x());
                     else
                     if (highBound == -1)
                         return QPolygonF(); // key ranges have no overlap
                     croppedData->remove(highBound + 1, croppedData->size() - (highBound + 1));
-                    // set highest point of cropped data to fit exactly key position of last static data point
+                    // set highest point of cropped data to fit exactly key position of last static data
-                    // via linear interpolation:
+                    // point via linear interpolation:
                     if (croppedData->size() < 2)
-                        return QPolygonF();                 // need at least two points for interpolation
+                        return QPolygonF();           // need at least two points for interpolation
-                    const int li = croppedData->size() - 1; // last index
+                    int li = croppedData->size() - 1; // last index
-                    if (!qFuzzyCompare(croppedData->at(li).x(), croppedData->at(li - 1).x()))
+                    if (croppedData->at(li).x() - croppedData->at(li - 1).x() != 0)
                         slope = (croppedData->at(li).y() - croppedData->at(li - 1).y())
                                 / (croppedData->at(li).x() - croppedData->at(li - 1).x());
                     else
                 else // mKeyAxis->orientation() == Qt::Vertical
                 {
                     // y is key
+                    // similar to "x is key" but switched x,y. Further, lower/upper meaning is inverted compared
+                    // to x,
+                    // because in pixel coordinates, y increases from top to bottom, not bottom to top like data
+                    // coordinate.
+                    // if an axis range is reversed, the data point keys will be descending. Reverse them, since
+                    // following algorithm assumes ascending keys:
+                    if (staticData->first().y() < staticData->last().y()) {
+                        int size = staticData->size();
+                        for (int i = 0; i < size / 2; ++i)
+                            qSwap((*staticData)[i], (*staticData)[size - 1 - i]);
+                    }
+                    if (croppedData->first().y() < croppedData->last().y()) {
+                        int size = croppedData->size();
+                        for (int i = 0; i < size / 2; ++i)
+                            qSwap((*croppedData)[i], (*croppedData)[size - 1 - i]);
+                    }
                     // crop lower bound:
-                    if (staticData->first().y() < croppedData->first().y()) // other one must be cropped
+                    if (staticData->first().y() > croppedData->first().y()) // other one must be cropped
                         qSwap(staticData, croppedData);
-                    int lowBound = findIndexBelowY(croppedData, staticData->first().y());
+                    int lowBound = findIndexAboveY(croppedData, staticData->first().y());
                     if (lowBound == -1)
                         return QPolygonF(); // key ranges have no overlap
                     croppedData->remove(0, lowBound);
-                    // set lowest point of cropped data to fit exactly key position of first static data point
+                    // set lowest point of cropped data to fit exactly key position of first static data
-                    // via linear interpolation:
+                    // point via linear interpolation:
                     if (croppedData->size() < 2)
                         return QPolygonF(); // need at least two points for interpolation
                     double slope;
-                    if (!qFuzzyCompare(croppedData->at(1).y(),
+                    if (croppedData->at(1).y() - croppedData->at(0).y()
-                                       croppedData->at(0).y())) // avoid division by zero in step plots
+                        != 0) // avoid division by zero in step plots
                         slope = (croppedData->at(1).x() - croppedData->at(0).x())
                                 / (croppedData->at(1).y() - croppedData->at(0).y());
                     else
                     (*croppedData)[0].setY(staticData->first().y());
                     // crop upper bound:
-                    if (staticData->last().y() > croppedData->last().y()) // other one must be cropped
+                    if (staticData->last().y() < croppedData->last().y()) // other one must be cropped
                         qSwap(staticData, croppedData);
-                    int highBound = findIndexAboveY(croppedData, staticData->last().y());
+                    int highBound = findIndexBelowY(croppedData, staticData->last().y());
                     if (highBound == -1)
                         return QPolygonF(); // key ranges have no overlap
                     croppedData->remove(highBound + 1, croppedData->size() - (highBound + 1));
-                    // set highest point of cropped data to fit exactly key position of last static data point
+                    // set highest point of cropped data to fit exactly key position of last static data
-                    // via linear interpolation:
+                    // point via linear interpolation:
                     if (croppedData->size() < 2)
                         return QPolygonF();           // need at least two points for interpolation
                     int li = croppedData->size() - 1; // last index
-                    if (!qFuzzyCompare(croppedData->at(li).y(),
+                    if (croppedData->at(li).y() - croppedData->at(li - 1).y()
-                                       croppedData->at(li - 1).y())) // avoid division by zero in step plots
+                        != 0) // avoid division by zero in step plots
                         slope = (croppedData->at(li).x() - croppedData->at(li - 1).x())
                                 / (croppedData->at(li).y() - croppedData->at(li - 1).y());
                     else
                 }
                 // return joined:
-                for (int i = otherSegmentData.size() - 1; i >= 0;
+                for (int i = otherData.size() - 1; i >= 0;
                      --i) // insert reversed, otherwise the polygon will be twisted
-                    thisSegmentData << otherSegmentData.at(i);
+                    thisData << otherData.at(i);
-                return QPolygonF(thisSegmentData);
+                return QPolygonF(thisData);
             }
             /*! \internal
               Finds the smallest index of \a data, whose points x value is just above \a x. Assumes x values in
-              \a data points are ordered ascending, as is ensured by \ref getLines/\ref getScatters if the key
+              \a data points are ordered ascending, as is the case when plotting with horizontal key axis.
-              axis is horizontal.
               Used to calculate the channel fill polygon, see \ref getChannelFillPolygon.
             */
             /*! \internal
               Finds the highest index of \a data, whose points x value is just below \a x. Assumes x values in
-              \a data points are ordered ascending, as is ensured by \ref getLines/\ref getScatters if the key
+              \a data points are ordered ascending, as is the case when plotting with horizontal key axis.
-              axis is horizontal.
               Used to calculate the channel fill polygon, see \ref getChannelFillPolygon.
             */
             /*! \internal
               Finds the smallest index of \a data, whose points y value is just above \a y. Assumes y values in
-              \a data points are ordered ascending, as is ensured by \ref getLines/\ref getScatters if the key
+              \a data points are ordered descending, as is the case when plotting with vertical key axis.
-              axis is vertical.
               Used to calculate the channel fill polygon, see \ref getChannelFillPolygon.
             */
             int QCPGraph::findIndexAboveY(const QVector<QPointF> *data, double y) const
             {
-                for (int i = data->size() - 1; i >= 0; --i) {
+                for (int i = 0; i < data->size(); ++i) {
                     if (data->at(i).y() < y) {
-                        if (i < data->size() - 1)
+                        if (i > 0)
-                            return i + 1;
+                            return i - 1;
                         else
-                            return data->size() - 1;
+                            return 0;
                     }
                 }
                 return -1;
             /*! \internal
               Finds the highest index of \a data, whose points y value is just below \a y. Assumes y values in
-              \a data points are ordered ascending, as is ensured by \ref getLines/\ref getScatters if the key
+              \a data points are ordered descending, as is the case when plotting with vertical key axis (since
-              axis is vertical.
+              keys are ordered ascending).
               Used to calculate the channel fill polygon, see \ref getChannelFillPolygon.
             */
             int QCPGraph::findIndexBelowY(const QVector<QPointF> *data, double y) const
             {
-                for (int i = 0; i < data->size(); ++i) {
+                for (int i = data->size() - 1; i >= 0; --i) {
                     if (data->at(i).y() > y) {
-                        if (i > 0)
+                        if (i < data->size() - 1)
-                            return i - 1;
+                            return i + 1;
                         else
-                            return 0;
+                            return data->size() - 1;
                     }
                 }
                 return -1;
             /* end of 'src/plottables/plottable-graph.cpp' */
-            /* including file 'src/plottables/plottable-curve.cpp', size 63527           */
+            /* including file 'src/plottables/plottable-curve.cpp', size 60009           */
-            /* commit 63bcca79007f7f56dce5dd035560f2e871d1dfc1 2017-07-20 18:02:21 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPCurveData
                 setScatterStyle(QCPScatterStyle());
                 setLineStyle(lsLine);
-                setScatterSkip(0);
             }
             QCPCurve::~QCPCurve()
                                                 double value, double keyMin, double valueMax, double keyMax,
                                                 double valueMin) const
             {
-                // The intersection point interpolation here is done in pixel coordinates, so we don't need to
+                double intersectKey = keyMin;     // initial value is just fail-safe
-                // differentiate between different axis scale types. Note that the nomenclature
+                double intersectValue = valueMax; // initial value is just fail-safe
-                // top/left/bottom/right/min/max is with respect to the rect in plot coordinates, wich may be
-                // different in pixel coordinates (horz/vert key axes, reversed ranges)
-                const double keyMinPx = mKeyAxis->coordToPixel(keyMin);
-                const double keyMaxPx = mKeyAxis->coordToPixel(keyMax);
-                const double valueMinPx = mValueAxis->coordToPixel(valueMin);
-                const double valueMaxPx = mValueAxis->coordToPixel(valueMax);
-                const double otherValuePx = mValueAxis->coordToPixel(otherValue);
-                const double valuePx = mValueAxis->coordToPixel(value);
-                const double otherKeyPx = mKeyAxis->coordToPixel(otherKey);
-                const double keyPx = mKeyAxis->coordToPixel(key);
-                double intersectKeyPx = keyMinPx;     // initial key just a fail-safe
-                double intersectValuePx = valueMinPx; // initial value just a fail-safe
                 switch (otherRegion) {
                     case 1: // top and left edge
                     {
-                        intersectValuePx = valueMaxPx;
+                        intersectValue = valueMax;
-                        intersectKeyPx = otherKeyPx
+                        intersectKey
-                                         + (keyPx - otherKeyPx) / (valuePx - otherValuePx)
+                            = otherKey
-                                               * (intersectValuePx - otherValuePx);
+                              + (key - otherKey) / (value - otherValue) * (intersectValue - otherValue);
-                        if (intersectKeyPx < qMin(keyMinPx, keyMaxPx)
+                        if (intersectKey < keyMin
-                            || intersectKeyPx > qMax(keyMinPx, keyMaxPx)) // check whether top edge is not
+                            || intersectKey > keyMax) // doesn't intersect, so must intersect other:
-                                                                          // intersected, then it must be left
-                                                                          // edge (qMin/qMax necessary since
-                                                                          // axes may be reversed)
                         {
-                            intersectKeyPx = keyMinPx;
+                            intersectKey = keyMin;
-                            intersectValuePx = otherValuePx
+                            intersectValue
-                                               + (valuePx - otherValuePx) / (keyPx - otherKeyPx)
+                                = otherValue
-                                                     * (intersectKeyPx - otherKeyPx);
+                                  + (value - otherValue) / (key - otherKey) * (intersectKey - otherKey);
                         }
                         break;
                     }
                     case 2: // left edge
                     {
-                        intersectKeyPx = keyMinPx;
+                        intersectKey = keyMin;
-                        intersectValuePx
+                        intersectValue
-                            = otherValuePx
+                            = otherValue + (value - otherValue) / (key - otherKey) * (intersectKey - otherKey);
-                              + (valuePx - otherValuePx) / (keyPx - otherKeyPx) * (intersectKeyPx - otherKeyPx);
                         break;
                     }
                     case 3: // bottom and left edge
                     {
-                        intersectValuePx = valueMinPx;
+                        intersectValue = valueMin;
-                        intersectKeyPx = otherKeyPx
+                        intersectKey
-                                         + (keyPx - otherKeyPx) / (valuePx - otherValuePx)
+                            = otherKey
-                                               * (intersectValuePx - otherValuePx);
+                              + (key - otherKey) / (value - otherValue) * (intersectValue - otherValue);
-                        if (intersectKeyPx < qMin(keyMinPx, keyMaxPx)
+                        if (intersectKey < keyMin
-                            || intersectKeyPx > qMax(keyMinPx, keyMaxPx)) // check whether bottom edge is not
+                            || intersectKey > keyMax) // doesn't intersect, so must intersect other:
-                                                                          // intersected, then it must be left
-                                                                          // edge (qMin/qMax necessary since
-                                                                          // axes may be reversed)
                         {
-                            intersectKeyPx = keyMinPx;
+                            intersectKey = keyMin;
-                            intersectValuePx = otherValuePx
+                            intersectValue
-                                               + (valuePx - otherValuePx) / (keyPx - otherKeyPx)
+                                = otherValue
-                                                     * (intersectKeyPx - otherKeyPx);
+                                  + (value - otherValue) / (key - otherKey) * (intersectKey - otherKey);
                         }
                         break;
                     }
                     case 4: // top edge
                     {
-                        intersectValuePx = valueMaxPx;
+                        intersectValue = valueMax;
-                        intersectKeyPx = otherKeyPx
+                        intersectKey
-                                         + (keyPx - otherKeyPx) / (valuePx - otherValuePx)
+                            = otherKey
-                                               * (intersectValuePx - otherValuePx);
+                              + (key - otherKey) / (value - otherValue) * (intersectValue - otherValue);
                         break;
                     }
                     case 5: {
                     }
                     case 6: // bottom edge
                     {
-                        intersectValuePx = valueMinPx;
+                        intersectValue = valueMin;
-                        intersectKeyPx = otherKeyPx
+                        intersectKey
-                                         + (keyPx - otherKeyPx) / (valuePx - otherValuePx)
+                            = otherKey
-                                               * (intersectValuePx - otherValuePx);
+                              + (key - otherKey) / (value - otherValue) * (intersectValue - otherValue);
                         break;
                     }
                     case 7: // top and right edge
                     {
-                        intersectValuePx = valueMaxPx;
+                        intersectValue = valueMax;
-                        intersectKeyPx = otherKeyPx
+                        intersectKey
-                                         + (keyPx - otherKeyPx) / (valuePx - otherValuePx)
+                            = otherKey
-                                               * (intersectValuePx - otherValuePx);
+                              + (key - otherKey) / (value - otherValue) * (intersectValue - otherValue);
-                        if (intersectKeyPx < qMin(keyMinPx, keyMaxPx)
+                        if (intersectKey < keyMin
-                            || intersectKeyPx > qMax(keyMinPx, keyMaxPx)) // check whether top edge is not
+                            || intersectKey > keyMax) // doesn't intersect, so must intersect other:
-                                                                          // intersected, then it must be right
-                                                                          // edge (qMin/qMax necessary since
-                                                                          // axes may be reversed)
                         {
-                            intersectKeyPx = keyMaxPx;
+                            intersectKey = keyMax;
-                            intersectValuePx = otherValuePx
+                            intersectValue
-                                               + (valuePx - otherValuePx) / (keyPx - otherKeyPx)
+                                = otherValue
-                                                     * (intersectKeyPx - otherKeyPx);
+                                  + (value - otherValue) / (key - otherKey) * (intersectKey - otherKey);
                         }
                         break;
                     }
                     case 8: // right edge
                     {
-                        intersectKeyPx = keyMaxPx;
+                        intersectKey = keyMax;
-                        intersectValuePx
+                        intersectValue
-                            = otherValuePx
+                            = otherValue + (value - otherValue) / (key - otherKey) * (intersectKey - otherKey);
-                              + (valuePx - otherValuePx) / (keyPx - otherKeyPx) * (intersectKeyPx - otherKeyPx);
                         break;
                     }
                     case 9: // bottom and right edge
                     {
-                        intersectValuePx = valueMinPx;
+                        intersectValue = valueMin;
-                        intersectKeyPx = otherKeyPx
+                        intersectKey
-                                         + (keyPx - otherKeyPx) / (valuePx - otherValuePx)
+                            = otherKey
-                                               * (intersectValuePx - otherValuePx);
+                              + (key - otherKey) / (value - otherValue) * (intersectValue - otherValue);
-                        if (intersectKeyPx < qMin(keyMinPx, keyMaxPx)
+                        if (intersectKey < keyMin
-                            || intersectKeyPx > qMax(keyMinPx, keyMaxPx)) // check whether bottom edge is not
+                            || intersectKey > keyMax) // doesn't intersect, so must intersect other:
-                                                                          // intersected, then it must be right
-                                                                          // edge (qMin/qMax necessary since
-                                                                          // axes may be reversed)
                         {
-                            intersectKeyPx = keyMaxPx;
+                            intersectKey = keyMax;
-                            intersectValuePx = otherValuePx
+                            intersectValue
-                                               + (valuePx - otherValuePx) / (keyPx - otherKeyPx)
+                                = otherValue
-                                                     * (intersectKeyPx - otherKeyPx);
+                                  + (value - otherValue) / (key - otherKey) * (intersectKey - otherKey);
                         }
                         break;
                     }
                 }
-                if (mKeyAxis->orientation() == Qt::Horizontal)
+                return coordsToPixels(intersectKey, intersectValue);
-                    return QPointF(intersectKeyPx, intersectValuePx);
-                else
-                    return QPointF(intersectValuePx, intersectKeyPx);
             }
             /*! \internal
                                        double keyMin, double valueMax, double keyMax, double valueMin,
                                        QPointF &crossA, QPointF &crossB) const
             {
-                // The intersection point interpolation here is done in pixel coordinates, so we don't need to
+                QList<QPointF> intersections;    // x of QPointF corresponds to key and y to value
-                // differentiate between different axis scale types. Note that the nomenclature
-                // top/left/bottom/right/min/max is with respect to the rect in plot coordinates, wich may be
-                // different in pixel coordinates (horz/vert key axes, reversed ranges)
-                QList<QPointF> intersections;
-                const double valueMinPx = mValueAxis->coordToPixel(valueMin);
-                const double valueMaxPx = mValueAxis->coordToPixel(valueMax);
-                const double keyMinPx = mKeyAxis->coordToPixel(keyMin);
-                const double keyMaxPx = mKeyAxis->coordToPixel(keyMax);
-                const double keyPx = mKeyAxis->coordToPixel(key);
-                const double valuePx = mValueAxis->coordToPixel(value);
-                const double prevKeyPx = mKeyAxis->coordToPixel(prevKey);
-                const double prevValuePx = mValueAxis->coordToPixel(prevValue);
                 if (qFuzzyIsNull(key - prevKey)) // line is parallel to value axis
                 {
-                    // due to region filter in mayTraverse(), if line is parallel to value or key axis, region 5
+                    // due to region filter in mayTraverseR(), if line is parallel to value or key axis, R is
-                    // is traversed here
+                    // traversed here
                     intersections.append(
-                        mKeyAxis->orientation() == Qt::Horizontal
+                        QPointF(key, valueMin)); // direction will be taken care of at end of method
-                            ? QPointF(keyPx, valueMinPx)
+                    intersections.append(QPointF(key, valueMax));
-                            : QPointF(valueMinPx, keyPx)); // direction will be taken care of at end of method
-                    intersections.append(mKeyAxis->orientation() == Qt::Horizontal
-                                             ? QPointF(keyPx, valueMaxPx)
-                                             : QPointF(valueMaxPx, keyPx));
                 }
                 else if (qFuzzyIsNull(value - prevValue)) // line is parallel to key axis
                 {
-                    // due to region filter in mayTraverse(), if line is parallel to value or key axis, region 5
+                    // due to region filter in mayTraverseR(), if line is parallel to value or key axis, R is
-                    // is traversed here
+                    // traversed here
                     intersections.append(
-                        mKeyAxis->orientation() == Qt::Horizontal
+                        QPointF(keyMin, value)); // direction will be taken care of at end of method
-                            ? QPointF(keyMinPx, valuePx)
+                    intersections.append(QPointF(keyMax, value));
-                            : QPointF(valuePx, keyMinPx)); // direction will be taken care of at end of method
-                    intersections.append(mKeyAxis->orientation() == Qt::Horizontal
-                                             ? QPointF(keyMaxPx, valuePx)
-                                             : QPointF(valuePx, keyMaxPx));
                 }
                 else // line is skewed
                 {
                     double gamma;
-                    double keyPerValuePx = (keyPx - prevKeyPx) / (valuePx - prevValuePx);
+                    double keyPerValue = (key - prevKey) / (value - prevValue);
                     // check top of rect:
-                    gamma = prevKeyPx + (valueMaxPx - prevValuePx) * keyPerValuePx;
+                    gamma = prevKey + (valueMax - prevValue) * keyPerValue;
-                    if (gamma >= qMin(keyMinPx, keyMaxPx)
+                    if (gamma >= keyMin && gamma <= keyMax)
-                        && gamma <= qMax(keyMinPx, keyMaxPx)) // qMin/qMax necessary since axes may be reversed
+                        intersections.append(QPointF(gamma, valueMax));
-                        intersections.append(mKeyAxis->orientation() == Qt::Horizontal
-                                                 ? QPointF(gamma, valueMaxPx)
-                                                 : QPointF(valueMaxPx, gamma));
                     // check bottom of rect:
-                    gamma = prevKeyPx + (valueMinPx - prevValuePx) * keyPerValuePx;
+                    gamma = prevKey + (valueMin - prevValue) * keyPerValue;
-                    if (gamma >= qMin(keyMinPx, keyMaxPx)
+                    if (gamma >= keyMin && gamma <= keyMax)
-                        && gamma <= qMax(keyMinPx, keyMaxPx)) // qMin/qMax necessary since axes may be reversed
+                        intersections.append(QPointF(gamma, valueMin));
-                        intersections.append(mKeyAxis->orientation() == Qt::Horizontal
+                    double valuePerKey = 1.0 / keyPerValue;
-                                                 ? QPointF(gamma, valueMinPx)
-                                                 : QPointF(valueMinPx, gamma));
-                    const double valuePerKeyPx = 1.0 / keyPerValuePx;
                     // check left of rect:
-                    gamma = prevValuePx + (keyMinPx - prevKeyPx) * valuePerKeyPx;
+                    gamma = prevValue + (keyMin - prevKey) * valuePerKey;
-                    if (gamma >= qMin(valueMinPx, valueMaxPx)
+                    if (gamma >= valueMin && gamma <= valueMax)
-                        && gamma <= qMax(valueMinPx,
+                        intersections.append(QPointF(keyMin, gamma));
-                                         valueMaxPx)) // qMin/qMax necessary since axes may be reversed
-                        intersections.append(mKeyAxis->orientation() == Qt::Horizontal
-                                                 ? QPointF(keyMinPx, gamma)
-                                                 : QPointF(gamma, keyMinPx));
                     // check right of rect:
-                    gamma = prevValuePx + (keyMaxPx - prevKeyPx) * valuePerKeyPx;
+                    gamma = prevValue + (keyMax - prevKey) * valuePerKey;
-                    if (gamma >= qMin(valueMinPx, valueMaxPx)
+                    if (gamma >= valueMin && gamma <= valueMax)
-                        && gamma <= qMax(valueMinPx,
+                        intersections.append(QPointF(keyMax, gamma));
-                                         valueMaxPx)) // qMin/qMax necessary since axes may be reversed
-                        intersections.append(mKeyAxis->orientation() == Qt::Horizontal
-                                                 ? QPointF(keyMaxPx, gamma)
-                                                 : QPointF(gamma, keyMaxPx));
                 }
                 // handle cases where found points isn't exactly 2:
                 }
                 // possibly re-sort points so optimized point segment has same direction as original segment:
-                double xDelta = keyPx - prevKeyPx;
+                if ((key - prevKey) * (intersections.at(1).x() - intersections.at(0).x())
-                double yDelta = valuePx - prevValuePx;
+                        + (value - prevValue) * (intersections.at(1).y() - intersections.at(0).y())
-                if (mKeyAxis->orientation() != Qt::Horizontal)
-                    qSwap(xDelta, yDelta);
-                if (xDelta * (intersections.at(1).x() - intersections.at(0).x())
-                        + yDelta * (intersections.at(1).y() - intersections.at(0).y())
                     < 0) // scalar product of both segments < 0 -> opposite direction
                     intersections.move(0, 1);
-                crossA = intersections.at(0);
+                crossA = coordsToPixels(intersections.at(0).x(), intersections.at(0).y());
-                crossB = intersections.at(1);
+                crossB = coordsToPixels(intersections.at(1).x(), intersections.at(1).y());
                 return true;
             }
             /* end of 'src/plottables/plottable-statisticalbox.cpp' */
-            /* including file 'src/plottables/plottable-colormap.cpp', size 47881        */
+            /* including file 'src/plottables/plottable-colormap.cpp', size 47531        */
-            /* commit 83a770151292397b3ba4984108d7ed167a9aec65 2017-08-13 16:22:21 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPColorMapData
                     : QCPAbstractPlottable(keyAxis, valueAxis),
                       mDataScaleType(QCPAxis::stLinear),
                       mMapData(new QCPColorMapData(10, 10, QCPRange(0, 5), QCPRange(0, 5))),
-                      mGradient(QCPColorGradient::gpCold),
                       mInterpolate(true),
                       mTightBoundary(false),
                       mMapImageInvalidated(true)
                     mMapImage = QImage(
                         QSize(valueSize * valueOversamplingFactor, keySize * keyOversamplingFactor), format);
-                if (mMapImage.isNull()) {
+                QImage *localMapImage = &mMapImage; // this is the image on which the colorization operates.
-                    qDebug() << Q_FUNC_INFO << "Couldn't create map image (possibly too large for memory)";
+                                                    // Either the final mMapImage, or if we need oversampling,
-                    mMapImage = QImage(QSize(10, 10), format);
+                                                    // mUndersampledMapImage
-                    mMapImage.fill(Qt::black);
+                if (keyOversamplingFactor > 1 || valueOversamplingFactor > 1) {
+                    // resize undersampled map image to actual key/value cell sizes:
-                else {
+                    if (keyAxis->orientation() == Qt::Horizontal
-                    QImage *localMapImage = &mMapImage; // this is the image on which the colorization operates.
+                        && (mUndersampledMapImage.width() != keySize
-                                                        // Either the final mMapImage, or if we need
+                            || mUndersampledMapImage.height() != valueSize))
-                                                        // oversampling, mUndersampledMapImage
+                        mUndersampledMapImage = QImage(QSize(keySize, valueSize), format);
-                    if (keyOversamplingFactor > 1 || valueOversamplingFactor > 1) {
+                    else if (keyAxis->orientation() == Qt::Vertical
-                        // resize undersampled map image to actual key/value cell sizes:
+                             && (mUndersampledMapImage.width() != valueSize
-                        if (keyAxis->orientation() == Qt::Horizontal
+                                 || mUndersampledMapImage.height() != keySize))
-                            && (mUndersampledMapImage.width() != keySize
+                        mUndersampledMapImage = QImage(QSize(valueSize, keySize), format);
-                                || mUndersampledMapImage.height() != valueSize))
+                    localMapImage
-                            mUndersampledMapImage = QImage(QSize(keySize, valueSize), format);
+                        = &mUndersampledMapImage; // make the colorization run on the undersampled image
-                        else if (keyAxis->orientation() == Qt::Vertical
-                                 && (mUndersampledMapImage.width() != valueSize
+                else if (!mUndersampledMapImage.isNull())
-                                     || mUndersampledMapImage.height() != keySize))
+                    mUndersampledMapImage = QImage(); // don't need oversampling mechanism anymore (map size has
-                            mUndersampledMapImage = QImage(QSize(valueSize, keySize), format);
+                                                      // changed) but mUndersampledMapImage still has nonzero
-                        localMapImage
+                                                      // size, free it
-                            = &mUndersampledMapImage; // make the colorization run on the undersampled image
+                const double *rawData = mMapData->mData;
-                    else if (!mUndersampledMapImage.isNull())
+                const unsigned char *rawAlpha = mMapData->mAlpha;
-                        mUndersampledMapImage = QImage(); // don't need oversampling mechanism anymore (map size
+                if (keyAxis->orientation() == Qt::Horizontal) {
-                                                          // has changed) but mUndersampledMapImage still has
+                    const int lineCount = valueSize;
-                                                          // nonzero size, free it
+                    const int rowCount = keySize;
+                    for (int line = 0; line < lineCount; ++line) {
-                    const double *rawData = mMapData->mData;
+                        QRgb *pixels = reinterpret_cast<QRgb *>(localMapImage->scanLine(
-                    const unsigned char *rawAlpha = mMapData->mAlpha;
+                            lineCount - 1 - line)); // invert scanline index because QImage counts scanlines
-                    if (keyAxis->orientation() == Qt::Horizontal) {
+                                                    // from top, but our vertical index counts from bottom
-                        const int lineCount = valueSize;
+                                                    // (mathematical coordinate system)
-                        const int rowCount = keySize;
+                        if (rawAlpha)
-                        for (int line = 0; line < lineCount; ++line) {
+                            mGradient.colorize(rawData + line * rowCount, rawAlpha + line * rowCount,
-                            QRgb *pixels = reinterpret_cast<QRgb *>(localMapImage->scanLine(
+                                               mDataRange, pixels, rowCount, 1,
-                                lineCount - 1 - line)); // invert scanline index because QImage counts scanlines
+                                               mDataScaleType == QCPAxis::stLogarithmic);
-                                                        // from top, but our vertical index counts from bottom
+                        else
-                                                        // (mathematical coordinate system)
+                            mGradient.colorize(rawData + line * rowCount, mDataRange, pixels, rowCount, 1,
-                            if (rawAlpha)
+                                               mDataScaleType == QCPAxis::stLogarithmic);
-                                mGradient.colorize(rawData + line * rowCount, rawAlpha + line * rowCount,
-                                                   mDataRange, pixels, rowCount, 1,
-                                                   mDataScaleType == QCPAxis::stLogarithmic);
-                            else
-                                mGradient.colorize(rawData + line * rowCount, mDataRange, pixels, rowCount, 1,
-                                                   mDataScaleType == QCPAxis::stLogarithmic);
-                    else // keyAxis->orientation() == Qt::Vertical
-                        const int lineCount = keySize;
-                        const int rowCount = valueSize;
-                        for (int line = 0; line < lineCount; ++line) {
-                            QRgb *pixels = reinterpret_cast<QRgb *>(localMapImage->scanLine(
-                                lineCount - 1 - line)); // invert scanline index because QImage counts scanlines
-                                                        // from top, but our vertical index counts from bottom
-                                                        // (mathematical coordinate system)
-                            if (rawAlpha)
-                                mGradient.colorize(rawData + line, rawAlpha + line, mDataRange, pixels,
-                                                   rowCount, lineCount,
-                                                   mDataScaleType == QCPAxis::stLogarithmic);
-                            else
-                                mGradient.colorize(rawData + line, mDataRange, pixels, rowCount, lineCount,
-                                                   mDataScaleType == QCPAxis::stLogarithmic);
                     }
+                }
-                    if (keyOversamplingFactor > 1 || valueOversamplingFactor > 1) {
+                else // keyAxis->orientation() == Qt::Vertical
-                        if (keyAxis->orientation() == Qt::Horizontal)
-                            mMapImage = mUndersampledMapImage.scaled(
+                    const int lineCount = keySize;
-                                keySize * keyOversamplingFactor, valueSize * valueOversamplingFactor,
+                    const int rowCount = valueSize;
-                                Qt::IgnoreAspectRatio, Qt::FastTransformation);
+                    for (int line = 0; line < lineCount; ++line) {
+                        QRgb *pixels = reinterpret_cast<QRgb *>(localMapImage->scanLine(
+                            lineCount - 1 - line)); // invert scanline index because QImage counts scanlines
+                                                    // from top, but our vertical index counts from bottom
+                                                    // (mathematical coordinate system)
+                        if (rawAlpha)
+                            mGradient.colorize(rawData + line, rawAlpha + line, mDataRange, pixels, rowCount,
+                                               lineCount, mDataScaleType == QCPAxis::stLogarithmic);
                         else
-                            mMapImage = mUndersampledMapImage.scaled(
+                            mGradient.colorize(rawData + line, mDataRange, pixels, rowCount, lineCount,
-                                valueSize * valueOversamplingFactor, keySize * keyOversamplingFactor,
+                                               mDataScaleType == QCPAxis::stLogarithmic);
-                                Qt::IgnoreAspectRatio, Qt::FastTransformation);
                     }
                 }
+                if (keyOversamplingFactor > 1 || valueOversamplingFactor > 1) {
+                    if (keyAxis->orientation() == Qt::Horizontal)
+                        mMapImage = mUndersampledMapImage.scaled(keySize * keyOversamplingFactor,
+                                                                 valueSize * valueOversamplingFactor,
+                                                                 Qt::IgnoreAspectRatio, Qt::FastTransformation);
+                    else
+                        mMapImage = mUndersampledMapImage.scaled(valueSize * valueOversamplingFactor,
+                                                                 keySize * keyOversamplingFactor,
+                                                                 Qt::IgnoreAspectRatio, Qt::FastTransformation);
+                }
                 mMapData->mDataModified = false;
                 mMapImageInvalidated = false;
             }
             /* end of 'src/plottables/plottable-financial.cpp' */
-            /* including file 'src/plottables/plottable-errorbar.cpp', size 37355        */
+            /* including file 'src/plottables/plottable-errorbar.cpp', size 37210        */
-            /* commit 6f159843e9ec9ea6431b26591937aea13a9f2751 2017-07-25 11:13:32 +0200 */
+            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPErrorBarsData
                 QPointF centerPixel = mDataPlottable->interface1D()->dataPixelPosition(index);
                 if (qIsNaN(centerPixel.x()) || qIsNaN(centerPixel.y()))
                     return;
-                QCPAxis *errorAxis = mErrorType == etValueError ? mValueAxis.data() : mKeyAxis.data();
+                QCPAxis *errorAxis = mErrorType == etValueError ? mValueAxis : mKeyAxis;
-                QCPAxis *orthoAxis = mErrorType == etValueError ? mKeyAxis.data() : mValueAxis.data();
+                QCPAxis *orthoAxis = mErrorType == etValueError ? mKeyAxis : mValueAxis;
                 const double centerErrorAxisPixel
                     = errorAxis->orientation() == Qt::Horizontal ? centerPixel.x() : centerPixel.y();
                 const double centerOrthoAxisPixel
                 closestData = mDataContainer->constEnd();
                 if (!mDataPlottable || mDataContainer->isEmpty())
                     return -1.0;
-                if (!mKeyAxis || !mValueAxis) {
-                    qDebug() << Q_FUNC_INFO << "invalid key or value axis";
-                    return -1.0;
                 QCPErrorBarsDataContainer::const_iterator begin, end;
                 getVisibleDataBounds(begin, end, QCPDataRange(0, dataCount()));

gui/ui/sidepane/SqpSidePane.ui ~~gui/ui/DataSource/DataSourceWidget.ui~~ renamed +7 -19

@@ -1,7 +1,9
1	<?xml version="1.0" encoding="UTF-8"?>
2	<ui version="4.0">	1	<ui version="4.0">
3	<class>DataSourceWidget</class>	2	<author/>
4	<widget class="QWidget" name="DataSourceWidget">	3	<comment/>
		4	<exportmacro/>
		5	<class>SqpSidePane</class>
		6	<widget name="SqpSidePane" class="QWidget">
5	<property name="geometry">	7	<property name="geometry">
6	<rect>	8	<rect>
7	<x>0</x>	9	<x>0</x>
@@ -11,23 +13,9
11	</rect>	13	</rect>
12	</property>	14	</property>
13	<property name="windowTitle">	15	<property name="windowTitle">
14	<string>~~Data sources~~</string>	16	<string>Form</string>
15	</property>	17	</property>
16	<layout class="QGridLayout" name="gridLayout">
17	<item row="0" column="0">
18	<widget class="QLineEdit" name="filterLineEdit"/>
19	</item>
20	<item row="1" column="0">
21	<widget class="QTreeWidget" name="treeWidget">
22	<column>
23	<property name="text">
24	<string notr="true">1</string>
25	</property>
26	</column>
27	</widget>
28	</item>
29	</layout>
30	</widget>	18	</widget>
31	<resources/>	19	<pixmapfunction/>
32	<connections/>	20	<connections/>
33	</ui>	21	</ui>

gui/ui/visualization/VisualizationWidget.ui ~~gui/ui/Visualization/VisualizationWidget.ui~~ renamed +11 -13

@@ -14,23 +14,21
14	<string>Form</string>	14	<string>Form</string>
15	</property>	15	</property>
16	<layout class="QVBoxLayout" name="verticalLayout">	16	<layout class="QVBoxLayout" name="verticalLayout">
17	<property name="leftMargin">
18	<number>0</number>
19	</property>
20	<property name="topMargin">
21	<number>0</number>
22	</property>
23	<property name="rightMargin">
24	<number>0</number>
25	</property>
26	<property name="bottomMargin">
27	<number>0</number>
28	</property>
29	<item>	17	<item>
30	<widget class="QTabWidget" name="tabWidget">	18	<widget class="QTabWidget" name="tabWidget">
31	<property name="currentIndex">	19	<property name="currentIndex">
32	<number>-1</number>	20	<number>0</number>
33	</property>	21	</property>
		22	<widget class="QWidget" name="firstView">
		23	<attribute name="title">
		24	<string>View 1</string>
		25	</attribute>
		26	</widget>
		27	<widget class="QWidget" name="secondView">
		28	<attribute name="title">
		29	<string>+</string>
		30	</attribute>
		31	</widget>
34	</widget>	32	</widget>
35	</item>	33	</item>
36	</layout>	34	</layout>

gui/ui/visualization/VisualizationZoneWidget.ui ~~gui/ui/Variable/VariableInspectorWidget.ui~~ renamed +7 -17

@@ -1,7 +1,9
1	<?xml version="1.0" encoding="UTF-8"?>
2	<ui version="4.0">	1	<ui version="4.0">
3	<class>VariableInspectorWidget</class>	2	<author/>
4	<widget class="QWidget" name="VariableInspectorWidget">	3	<comment/>
		4	<exportmacro/>
		5	<class>VisualizationZoneWidget</class>
		6	<widget name="VisualizationZoneWidget" class="QWidget">
5	<property name="geometry">	7	<property name="geometry">
6	<rect>	8	<rect>
7	<x>0</x>	9	<x>0</x>
@@ -11,21 +13,9
11	</rect>	13	</rect>
12	</property>	14	</property>
13	<property name="windowTitle">	15	<property name="windowTitle">
14	<string>~~Variables~~</string>	16	<string>Form</string>
15	</property>	17	</property>
16	<layout class="QGridLayout" name="gridLayout">
17	<item row="0" column="0">
18	<widget class="QTableView" name="tableView">
19	<property name="sortingEnabled">
20	<bool>true</bool>
21	</property>
22	<attribute name="horizontalHeaderStretchLastSection">
23	<bool>true</bool>
24	</attribute>
25	</widget>
26	</item>
27	</layout>
28	</widget>	18	</widget>
29	<resources/>	19	<pixmapfunction/>
30	<connections/>	20	<connections/>
31	</ui>	21	</ui>

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

+            # Ignore false positive relative to App macro
             \.h:\d+:.IPSIS_S04.*found: ui
             qcustomplot\.h:\d+:.IPSIS
             qcustomplot\.cpp:\d+:.IPSIS
-            # Ignore false positive relative to App macro
             SqpApplication\.h:\d+:.IPSIS_S03.*found: sqpApp
             SqpApplication\.h:\d+:.IPSIS_S04_VARIABLE.*found: sqpApp

plugin/CMakeLists.txt +1 -8

             FILE (GLOB_RECURSE MODULE_SOURCES
                     ${INCLUDES_DIR}/*.h)
-            ADD_LIBRARY(${SQPPLUGIN_LIBRARY_NAME} ${MODULE_SOURCES})
+                ADD_LIBRARY(${SQPPLUGIN_LIBRARY_NAME} ${MODULE_SOURCES})
-            INSTALL(TARGETS ${SQPPLUGIN_LIBRARY_NAME}
-              RUNTIME DESTINATION ${INSTALL_BINARY_DIR}
-              LIBRARY DESTINATION ${INSTALL_LIBRARY_DIR}
-              ARCHIVE DESTINATION ${INSTALL_LIBRARY_DIR}
             # Add the files to the list of files to be analyzed
             LIST(APPEND CHECKSTYLE_INPUT_FILES ${MODULE_SOURCES})

COPYING removed 0 -674

	1	NO CONTENT: file was removed			NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (674 lines changed) Show them Hide them

app/meson.build removed 0 -38

NO CONTENT: file was removed

app/resources/qlopapp.rc removed 0 -1

NO CONTENT: file was removed

app/resources/sciqlop.ico removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

build_cfg/mac/Info.plist removed 0 -22

NO CONTENT: file was removed

build_cfg/mac/build.sh removed 0 -8

NO CONTENT: file was removed

build_cfg/mac/install_script.sh removed 0 -12

NO CONTENT: file was removed

build_cfg/mac/sciqlopLOGO.icns removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

build_cfg/windows/build.sh removed 0 -8

NO CONTENT: file was removed

build_cfg/windows/cross_fedora_win64.txt removed 0 -18

NO CONTENT: file was removed

build_cfg/windows/install_script.sh removed 0 -26

NO CONTENT: file was removed

core/include/Common/DateUtils.h removed 0 -19

NO CONTENT: file was removed

core/include/Common/MetaTypes.h removed 0 -46

NO CONTENT: file was removed

core/include/Common/SortUtils.h removed 0 -139

NO CONTENT: file was removed

core/include/Common/StringUtils.h removed 0 -35

NO CONTENT: file was removed

core/include/CoreGlobal.h removed 0 -12

NO CONTENT: file was removed

core/include/Data/AcquisitionDataPacket.h removed 0 -25

NO CONTENT: file was removed

core/include/Data/AcquisitionRequest.h removed 0 -40

NO CONTENT: file was removed

core/include/Data/ArrayData.h removed 0 -374

NO CONTENT: file was removed

core/include/Data/ArrayDataIterator.h removed 0 -74

NO CONTENT: file was removed

core/include/Data/DataProviderParameters.h removed 0 -18

NO CONTENT: file was removed

core/include/Data/DataSeries.h removed 0 -400

NO CONTENT: file was removed

core/include/Data/DataSeriesIterator.h removed 0 -78

NO CONTENT: file was removed

core/include/Data/DataSeriesMergeHelper.h removed 0 -83

NO CONTENT: file was removed

core/include/Data/IDataProvider.h removed 0 -81

NO CONTENT: file was removed

core/include/Data/IDataSeries.h removed 0 -113

NO CONTENT: file was removed

core/include/Data/ScalarSeries.h removed 0 -27

NO CONTENT: file was removed

core/include/Data/SqpIterator.h removed 0 -112

NO CONTENT: file was removed

core/include/Data/SqpRange.h removed 0 -58

NO CONTENT: file was removed

core/include/Data/VariableRequest.h removed 0 -28

NO CONTENT: file was removed

core/include/Data/VectorSeries.h removed 0 -34

NO CONTENT: file was removed

core/include/DataSource/DataSourceItemAction.h removed 0 -52

NO CONTENT: file was removed

core/include/Network/NetworkController.h removed 0 -53

NO CONTENT: file was removed

core/include/Settings/ISqpSettingsBindable.h removed 0 -21

NO CONTENT: file was removed

core/include/Settings/SqpSettingsDefs.h removed 0 -22

NO CONTENT: file was removed

core/include/Time/TimeController.h removed 0 -42

NO CONTENT: file was removed

core/include/Variable/Variable.h removed 0 -83

NO CONTENT: file was removed

core/include/Variable/VariableAcquisitionWorker.h removed 0 -66

NO CONTENT: file was removed

core/include/Variable/VariableCacheController.h removed 0 -45

NO CONTENT: file was removed

core/include/Variable/VariableCacheStrategy.h removed 0 -37

NO CONTENT: file was removed

core/include/Variable/VariableCacheStrategyFactory.h removed 0 -44

NO CONTENT: file was removed

core/include/Variable/VariableController.h removed 0 -130

NO CONTENT: file was removed

core/include/Variable/VariableModel.h removed 0 -95

NO CONTENT: file was removed

core/include/Variable/VariableSingleThresholdCacheStrategy.h removed 0 -32

NO CONTENT: file was removed

core/include/Variable/VariableSynchronizationGroup.h removed 0 -38

NO CONTENT: file was removed

core/meson.build removed 0 -63

NO CONTENT: file was removed

core/src/Common/DateUtils.cpp removed 0 -13

NO CONTENT: file was removed

core/src/Common/StringUtils.cpp removed 0 -30

NO CONTENT: file was removed

core/src/Data/ArrayDataIterator.cpp removed 0 -77

NO CONTENT: file was removed

core/src/Data/DataSeriesIterator.cpp removed 0 -83

NO CONTENT: file was removed

core/src/Data/ScalarSeries.cpp removed 0 -31

NO CONTENT: file was removed

core/src/Data/VectorSeries.cpp removed 0 -85

NO CONTENT: file was removed

core/src/DataSource/DataSourceItemAction.cpp removed 0 -44

NO CONTENT: file was removed

core/src/Network/NetworkController.cpp removed 0 -148

NO CONTENT: file was removed

core/src/Settings/SqpSettingsDefs.cpp removed 0 -18

NO CONTENT: file was removed

core/src/Time/TimeController.cpp removed 0 -29

NO CONTENT: file was removed

core/src/Variable/Variable.cpp removed 0 -315

NO CONTENT: file was removed

core/src/Variable/VariableAcquisitionWorker.cpp removed 0 -322

NO CONTENT: file was removed

core/src/Variable/VariableCacheController.cpp removed 0 -225

NO CONTENT: file was removed

core/src/Variable/VariableController.cpp removed 0 -842

	1	NO CONTENT: file was removed			NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (842 lines changed) Show them Hide them

core/src/Variable/VariableModel.cpp removed 0 -293

NO CONTENT: file was removed

core/src/Variable/VariableSynchronizationGroup.cpp removed 0 -32

NO CONTENT: file was removed

core/tests/Common/TestStringUtils.cpp removed 0 -50

NO CONTENT: file was removed

core/tests/Data/TestDataSeries.cpp removed 0 -636

	1	NO CONTENT: file was removed			NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (636 lines changed) Show them Hide them

core/tests/Data/TestOneDimArrayData.cpp removed 0 -181

NO CONTENT: file was removed

core/tests/Data/TestTwoDimArrayData.cpp removed 0 -240

NO CONTENT: file was removed

core/tests/Variable/TestVariable.cpp removed 0 -177

NO CONTENT: file was removed

core/tests/Variable/TestVariableCacheController.cpp removed 0 -333

NO CONTENT: file was removed

core/tests/Variable/TestVariableController.cpp removed 0 -74

NO CONTENT: file was removed

core/tests/Variable/TestVariableSync.cpp removed 0 -310

NO CONTENT: file was removed

core/tests/meson.build removed 0 -20

NO CONTENT: file was removed

gui/include/Common/ColorUtils.h removed 0 -19

NO CONTENT: file was removed

gui/include/DataSource/DataSourceTreeWidgetHelper.h removed 0 -23

NO CONTENT: file was removed

gui/include/DataSource/DataSourceTreeWidgetItem.h removed 0 -37

NO CONTENT: file was removed

gui/include/DataSource/DataSourceWidget.h removed 0 -42

NO CONTENT: file was removed

gui/include/Settings/SqpSettingsDialog.h removed 0 -40

NO CONTENT: file was removed

gui/include/Settings/SqpSettingsGeneralWidget.h removed 0 -32

NO CONTENT: file was removed

gui/include/TimeWidget/TimeWidget.h removed 0 -32

NO CONTENT: file was removed

gui/include/Variable/RenameVariableDialog.h removed 0 -32

NO CONTENT: file was removed

gui/include/Variable/VariableInspectorWidget.h removed 0 -56

NO CONTENT: file was removed

gui/include/Variable/VariableMenuHeaderWidget.h removed 0 -37

NO CONTENT: file was removed

gui/include/Visualization/IGraphSynchronizer.h removed 0 -24

NO CONTENT: file was removed

gui/include/Visualization/IVariableContainer.h removed 0 -22

NO CONTENT: file was removed

gui/include/Visualization/IVisualizationWidget.h removed 0 -25

NO CONTENT: file was removed

gui/include/Visualization/IVisualizationWidgetVisitor.h removed 0 -28

NO CONTENT: file was removed

gui/include/Visualization/QCustomPlotSynchronizer.h removed 0 -26

NO CONTENT: file was removed

gui/include/Visualization/VisualizationDefs.h removed 0 -10

NO CONTENT: file was removed

gui/include/Visualization/VisualizationGraphHelper.h removed 0 -39

NO CONTENT: file was removed

gui/include/Visualization/VisualizationGraphRenderingDelegate.h removed 0 -31

NO CONTENT: file was removed

gui/include/Visualization/VisualizationGraphWidget.h removed 0 -98

NO CONTENT: file was removed

gui/include/Visualization/VisualizationTabWidget.h removed 0 -57

NO CONTENT: file was removed

gui/include/Visualization/VisualizationZoneWidget.h removed 0 -60

NO CONTENT: file was removed

gui/include/Visualization/operations/FindVariableOperation.h removed 0 -42

NO CONTENT: file was removed

gui/include/Visualization/operations/GenerateVariableMenuOperation.h removed 0 -48

NO CONTENT: file was removed

gui/include/Visualization/operations/MenuBuilder.h removed 0 -61

NO CONTENT: file was removed

gui/include/Visualization/operations/RemoveVariableOperation.h removed 0 -41

NO CONTENT: file was removed

gui/include/Visualization/operations/RescaleAxeOperation.h removed 0 -42

NO CONTENT: file was removed

gui/meson.build removed 0 -80

NO CONTENT: file was removed

gui/resources/icones/dataSourceComponent.png removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

gui/resources/icones/dataSourceNode.png removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

gui/resources/icones/dataSourceProduct.png removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

gui/resources/icones/dataSourceRoot.png removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

gui/resources/icones/delete.png removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

gui/resources/icones/down.png removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

gui/resources/icones/next.png removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

gui/resources/icones/openInspector.png removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

gui/resources/icones/plot.png removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

gui/resources/icones/previous.png removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

gui/resources/icones/sciqlop2PNG_1024.png removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

gui/resources/icones/unplot.png removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

gui/resources/icones/up.png removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

gui/resources/sqpguiresources.qrc removed 0 -16

NO CONTENT: file was removed

gui/src/Common/ColorUtils.cpp removed 0 -29

NO CONTENT: file was removed

gui/src/DataSource/DataSourceTreeWidgetHelper.cpp removed 0 -36

NO CONTENT: file was removed

gui/src/DataSource/DataSourceTreeWidgetItem.cpp removed 0 -176

NO CONTENT: file was removed

gui/src/DataSource/DataSourceWidget.cpp removed 0 -100

NO CONTENT: file was removed

gui/src/Settings/SqpSettingsDialog.cpp removed 0 -66

NO CONTENT: file was removed

gui/src/Settings/SqpSettingsGeneralWidget.cpp removed 0 -51

NO CONTENT: file was removed

gui/src/TimeWidget/TimeWidget.cpp removed 0 -50

NO CONTENT: file was removed

gui/src/Variable/RenameVariableDialog.cpp removed 0 -63

NO CONTENT: file was removed

gui/src/Variable/VariableInspectorWidget.cpp removed 0 -239

NO CONTENT: file was removed

gui/src/Variable/VariableMenuHeaderWidget.cpp removed 0 -38

NO CONTENT: file was removed

gui/src/Visualization/QCustomPlotSynchronizer.cpp removed 0 -30

NO CONTENT: file was removed

gui/src/Visualization/VisualizationGraphHelper.cpp removed 0 -204

NO CONTENT: file was removed

gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp removed 0 -275

NO CONTENT: file was removed

gui/src/Visualization/VisualizationGraphWidget.cpp removed 0 -356

NO CONTENT: file was removed

gui/src/Visualization/VisualizationTabWidget.cpp removed 0 -129

NO CONTENT: file was removed

gui/src/Visualization/VisualizationWidget.cpp removed 0 -172

NO CONTENT: file was removed

gui/src/Visualization/VisualizationZoneWidget.cpp removed 0 -302

NO CONTENT: file was removed

gui/src/Visualization/operations/FindVariableOperation.cpp removed 0 -72

NO CONTENT: file was removed

gui/src/Visualization/operations/GenerateVariableMenuOperation.cpp removed 0 -216

NO CONTENT: file was removed

gui/src/Visualization/operations/MenuBuilder.cpp removed 0 -58

NO CONTENT: file was removed

gui/src/Visualization/operations/RemoveVariableOperation.cpp removed 0 -70

NO CONTENT: file was removed

gui/src/Visualization/operations/RescaleAxeOperation.cpp removed 0 -69

NO CONTENT: file was removed

gui/ui/Settings/SqpSettingsDialog.ui removed 0 -84

NO CONTENT: file was removed

gui/ui/Settings/SqpSettingsGeneralWidget.ui removed 0 -74

NO CONTENT: file was removed

gui/ui/SidePane/SqpSidePane.ui removed 0 -42

NO CONTENT: file was removed

gui/ui/TimeWidget/TimeWidget.ui removed 0 -98

NO CONTENT: file was removed

gui/ui/Variable/RenameVariableDialog.ui removed 0 -90

NO CONTENT: file was removed

gui/ui/Variable/VariableMenuHeaderWidget.ui removed 0 -31

NO CONTENT: file was removed

gui/ui/Visualization/VisualizationGraphWidget.ui removed 0 -51

NO CONTENT: file was removed

gui/ui/Visualization/VisualizationTabWidget.ui removed 0 -73

NO CONTENT: file was removed

gui/ui/Visualization/VisualizationZoneWidget.ui removed 0 -117

NO CONTENT: file was removed

meson.build removed 0 -36

NO CONTENT: file was removed

plugins/amda/CMakeLists.txt removed 0 -167

NO CONTENT: file was removed

plugins/amda/cmake/Findsciqlop-amda.cmake removed 0 -22

NO CONTENT: file was removed

plugins/amda/include/AmdaDefs.h removed 0 -17

NO CONTENT: file was removed

plugins/amda/include/AmdaGlobal.h removed 0 -12

NO CONTENT: file was removed

plugins/amda/include/AmdaParser.h removed 0 -23

NO CONTENT: file was removed

plugins/amda/include/AmdaPlugin.h removed 0 -29

NO CONTENT: file was removed

plugins/amda/include/AmdaProvider.h removed 0 -44

NO CONTENT: file was removed

plugins/amda/include/AmdaResultParser.h removed 0 -21

NO CONTENT: file was removed

plugins/amda/meson.build removed 0 -73

NO CONTENT: file was removed

plugins/amda/resources/amda.json removed 0 -3

NO CONTENT: file was removed

plugins/amda/resources/amdaresources.qrc removed 0 -6

NO CONTENT: file was removed

plugins/amda/resources/samples/AmdaSample.json removed 0 -22288

	1	NO CONTENT: file was removed			NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (22288 lines changed) Show them Hide them

plugins/amda/resources/samples/AmdaSampleV2.json removed 0 -29129

	1	NO CONTENT: file was removed			NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (29129 lines changed) Show them Hide them

plugins/amda/src/AmdaDefs.cpp removed 0 -7

NO CONTENT: file was removed

plugins/amda/src/AmdaParser.cpp removed 0 -125

NO CONTENT: file was removed

plugins/amda/src/AmdaPlugin.cpp removed 0 -74

NO CONTENT: file was removed

plugins/amda/src/AmdaProvider.cpp removed 0 -284

NO CONTENT: file was removed

plugins/amda/src/AmdaResultParser.cpp removed 0 -225

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaAcquisition/AmdaData-2012-01-01-12-00-00_2012-01-03-12-00-00.txt removed 0 -10802

	1	NO CONTENT: file was removed			NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (10802 lines changed) Show them Hide them

plugins/amda/tests-resources/TestAmdaParser/TwoRootsFile.json removed 0 -4

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaParser/ValidFile1.json removed 0 -63

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaParser/WrongRootKey.json removed 0 -5

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaParser/WrongRootType.json removed 0 -3

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/FileNotFound.txt removed 0 -3

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/NaNValue.txt removed 0 -64

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/NaNX.txt removed 0 -64

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/NoUnit.txt removed 0 -60

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/TooManyValues.txt removed 0 -64

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/ValidScalar1.txt removed 0 -71

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/ValidVector1.txt removed 0 -71

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/WrongDate.txt removed 0 -64

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/WrongUnit.txt removed 0 -64

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/WrongValue.txt removed 0 -64

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/FileNotFound.txt removed 0 -3

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/NaNValue.txt removed 0 -6

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/NaNX.txt removed 0 -6

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/NoUnit.txt removed 0 -2

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/TooManyValues.txt removed 0 -6

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/ValidScalar1.txt removed 0 -13

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/ValidVector1.txt removed 0 -12

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/WrongDate.txt removed 0 -6

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/WrongUnit.txt removed 0 -6

NO CONTENT: file was removed

plugins/amda/tests-resources/TestAmdaResultParser/amdaV1/WrongValue.txt removed 0 -6

NO CONTENT: file was removed

plugins/amda/tests/TestAmdaAcquisition.cpp removed 0 -197

NO CONTENT: file was removed

plugins/amda/tests/TestAmdaParser.cpp removed 0 -176

NO CONTENT: file was removed

plugins/amda/tests/TestAmdaResultParser.cpp removed 0 -281

NO CONTENT: file was removed

plugins/meson.build removed 0 -2

NO CONTENT: file was removed

plugins/mockplugin/CMakeLists.txt removed 0 -160

NO CONTENT: file was removed

plugins/mockplugin/cmake/Findsciqlop-mockplugin.cmake removed 0 -22

NO CONTENT: file was removed

plugins/mockplugin/include/CosinusProvider.h removed 0 -36

NO CONTENT: file was removed

plugins/mockplugin/include/MockPlugin.h removed 0 -29

NO CONTENT: file was removed

plugins/mockplugin/include/MockPluginGlobal.h removed 0 -12

NO CONTENT: file was removed

plugins/mockplugin/meson.build removed 0 -45

NO CONTENT: file was removed

plugins/mockplugin/resources/mockplugin.json removed 0 -3

NO CONTENT: file was removed

plugins/mockplugin/src/CosinusProvider.cpp removed 0 -115

NO CONTENT: file was removed

plugins/mockplugin/src/MockPlugin.cpp removed 0 -79

NO CONTENT: file was removed

plugins/mockplugin/tests-resources/TestCosinusAcquisition/Cosinus_100Hz_20170101_1200_20170101_1300.txt removed 0 -360000

	1	NO CONTENT: file was removed			NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (360000 lines changed) Show them Hide them

plugins/mockplugin/tests/TestCosinusAcquisition.cpp removed 0 -191

NO CONTENT: file was removed

General Comments 5

there are 2 general comments from older versions, show them

perrinel

v3 |

|

Pull request updated. Auto status change to "Under Review"

Changed commits:
  * 1 added
  * 0 removed

Changed files:
  * M core/CMakeLists.txt

perrinel

v3 |

|

Status change > Approved

note

perrinel

v3 |

|

Pull request merged and closed

No TODOs yet

		Pull request merged and closed
		Status change > Approved
		Pull request updated. Auto status change to \|under_review\|...
`v2 Wed, 07 Jun 2017 16:57:22`
		Pull request updated. Auto status change to \|under_review\|...
`v1 Wed, 07 Jun 2017 16:52:07`
		Auto status change to \|new_status\|...

In pull request description:

No Ticket data found.

In commit messages:

137 - in 1 commit

	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