HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r472:6b7a5db1522f

Merge branch 'feature/SettingsWidget' into develop

Alexandre Leroux -

r472:6b7a5db1522f

parent child

Context file:

r472:6b7a5db1522f

Expand all files

core/include/CoreGlobal.h created 644 +12 0

@@ -0,0 +1,12
	1	#ifndef SCIQLOP_COREGLOBAL_H
	2	#define SCIQLOP_COREGLOBAL_H
	3
	4	#include <QtCore/QtGlobal>
	5
	6	#ifdef CORE_LIB
	7	#define SCIQLOP_CORE_EXPORT Q_DECL_EXPORT
	8	#else
	9	#define SCIQLOP_CORE_EXPORT Q_DECL_IMPORT
	10	#endif
	11
	12	#endif // SCIQLOP_COREGLOBAL_H

core/include/Settings/ISqpSettingsBindable.h created 644 +21 0

@@ -0,0 +1,21
	1	#ifndef SCIQLOP_ISQPSETTINGSBINDABLE_H
	2	#define SCIQLOP_ISQPSETTINGSBINDABLE_H
	3
	4	#include <QSettings>
	5
	6	/**
	7	* @brief The ISqpSettingsBindable interface represents an object that can bind a variable
	8	*/
	9	class ISqpSettingsBindable {
	10
	11	public:
	12	virtual ~ISqpSettingsBindable() = default;
	13
	14	/// Loads settings into the object
	15	virtual void loadSettings() = 0;
	16
	17	/// Saves settings from the object
	18	virtual void saveSettings() const = 0;
	19	};
	20
	21	#endif // SCIQLOP_ISQPSETTINGSBINDABLE_H

core/include/Settings/SqpSettingsDefs.h created 644 +18 0

@@ -0,0 +1,18
	1	#ifndef SCIQLOP_SQPSETTINGSDEFS_H
	2	#define SCIQLOP_SQPSETTINGSDEFS_H
	3
	4	#include "CoreGlobal.h"
	5
	6	#include <QString>
	7
	8	// //////////////// //
	9	// General settings //
	10	// //////////////// //
	11
	12	extern SCIQLOP_CORE_EXPORT const QString GENERAL_TOLERANCE_AT_INIT_KEY;
	13	extern SCIQLOP_CORE_EXPORT const double GENERAL_TOLERANCE_AT_INIT_DEFAULT_VALUE;
	14
	15	extern SCIQLOP_CORE_EXPORT const QString GENERAL_TOLERANCE_AT_UPDATE_KEY;
	16	extern SCIQLOP_CORE_EXPORT const double GENERAL_TOLERANCE_AT_UPDATE_DEFAULT_VALUE;
	17
	18	#endif // SCIQLOP_SQPSETTINGSDEFS_H

core/src/Settings/SqpSettingsDefs.cpp created 644 +7 0

@@ -0,0 +1,7
	1	#include "Settings/SqpSettingsDefs.h"
	2
	3	const QString GENERAL_TOLERANCE_AT_INIT_KEY = QStringLiteral("toleranceInit");
	4	const double GENERAL_TOLERANCE_AT_INIT_DEFAULT_VALUE = 0.2;
	5
	6	const QString GENERAL_TOLERANCE_AT_UPDATE_KEY = QStringLiteral("toleranceUpdate");
	7	const double GENERAL_TOLERANCE_AT_UPDATE_DEFAULT_VALUE = 0.2;

gui/include/Settings/SqpSettingsDialog.h created 644 +40 0

@@ -0,0 +1,40
	1	#ifndef SCIQLOP_SQPSETTINGSDIALOG_H
	2	#define SCIQLOP_SQPSETTINGSDIALOG_H
	3
	4	#include "Settings/ISqpSettingsBindable.h"
	5
	6	#include <QDialog>
	7
	8	namespace Ui {
	9	class SqpSettingsDialog;
	10	} // Ui
	11
	12	/**
	13	* @brief The SqpSettingsDialog class represents the dialog in which the parameters of SciQlop are
	14	* set
	15	*/
	16	class SqpSettingsDialog : public QDialog, public ISqpSettingsBindable {
	17	Q_OBJECT
	18
	19	public:
	20	explicit SqpSettingsDialog(QWidget *parent = 0);
	21	virtual ~SqpSettingsDialog() noexcept;
	22
	23	/// @sa ISqpSettingsBindable::loadSettings()
	24	void loadSettings() override final;
	25
	26	/// @sa ISqpSettingsBindable::saveSettings()
	27	void saveSettings() const override final;
	28
	29	/**
	30	* Registers a widget into the dialog
	31	* @param name the name under which the widget will appear in the dialog
	32	* @param widget the widget to register
	33	*/
	34	void registerWidget(const QString &name, QWidget *widget) noexcept;
	35
	36	private:
	37	Ui::SqpSettingsDialog *ui;
	38	};
	39
	40	#endif // SCIQLOP_SQPSETTINGSDIALOG_H

gui/include/Settings/SqpSettingsGeneralWidget.h created 644 +32 0

@@ -0,0 +1,32
	1	#ifndef SCIQLOP_SQPSETTINGSGENERALWIDGET_H
	2	#define SCIQLOP_SQPSETTINGSGENERALWIDGET_H
	3
	4	#include "Settings/ISqpSettingsBindable.h"
	5
	6	#include <QWidget>
	7
	8	namespace Ui {
	9	class SqpSettingsGeneralWidget;
	10	} // Ui
	11
	12	/**
	13	* @brief The SqpSettingsGeneralWidget class represents the general settings of SciQlop
	14	*/
	15	class SqpSettingsGeneralWidget : public QWidget, public ISqpSettingsBindable {
	16	Q_OBJECT
	17
	18	public:
	19	explicit SqpSettingsGeneralWidget(QWidget *parent = 0);
	20	virtual ~SqpSettingsGeneralWidget() noexcept;
	21
	22	/// @sa ISqpSettingsBindable::loadSettings()
	23	void loadSettings() override final;
	24
	25	/// @sa ISqpSettingsBindable::saveSettings()
	26	void saveSettings() const override final;
	27
	28	private:
	29	Ui::SqpSettingsGeneralWidget *ui;
	30	};
	31
	32	#endif // SCIQLOP_SQPSETTINGSGENERALWIDGET_H

gui/src/Settings/SqpSettingsDialog.cpp created 644 +66 0

@@ -0,0 +1,66
	1	#include "Settings/SqpSettingsDialog.h"
	2	#include "ui_SqpSettingsDialog.h"
	3
	4	namespace {
	5
	6	/**
	7	* Performs a bind operation on widgets that can be binded to SciQlop settings
	8	* @param widgets
	9	* @param bind the bind operation
	10	* @sa ISqpSettingsBindable
	11	*/
	12	template <typename BindMethod>
	13	void processBind(const QStackedWidget &widgets, BindMethod bind)
	14	{
	15	auto count = widgets.count();
	16	for (auto i = 0; i < count; ++i) {
	17	// Performs operation if widget is an ISqpSettingsBindable
	18	if (auto sqpSettingsWidget = dynamic_cast<ISqpSettingsBindable *>(widgets.widget(i))) {
	19	bind(*sqpSettingsWidget);
	20	}
	21	}
	22	}
	23
	24	} // namespace
	25
	26	SqpSettingsDialog::SqpSettingsDialog(QWidget *parent)
	27	: QDialog{parent}, ui{new Ui::SqpSettingsDialog}
	28	{
	29	ui->setupUi(this);
	30
	31	// Connection to change the current page to the selection of an entry in the list
	32	connect(ui->listWidget, &QListWidget::currentRowChanged, ui->stackedWidget,
	33	&QStackedWidget::setCurrentIndex);
	34	}
	35
	36	SqpSettingsDialog::~SqpSettingsDialog() noexcept
	37	{
	38	delete ui;
	39	}
	40
	41	void SqpSettingsDialog::loadSettings()
	42	{
	43	// Performs load on all widgets that can be binded to SciQlop settings
	44	processBind(*ui->stackedWidget,
	45	[](ISqpSettingsBindable &bindable) { bindable.loadSettings(); });
	46	}
	47
	48	void SqpSettingsDialog::saveSettings() const
	49	{
	50	// Performs save on all widgets that can be binded to SciQlop settings
	51	processBind(*ui->stackedWidget,
	52	[](ISqpSettingsBindable &bindable) { bindable.saveSettings(); });
	53	}
	54
	55	void SqpSettingsDialog::registerWidget(const QString &name, QWidget *widget) noexcept
	56	{
	57	auto newItem = new QListWidgetItem{ui->listWidget};
	58	newItem->setText(name);
	59
	60	ui->stackedWidget->addWidget(widget);
	61
	62	// Selects widget if it's the first in the dialog
	63	if (ui->listWidget->count() == 1) {
	64	ui->listWidget->setCurrentItem(newItem);
	65	}
	66	}

gui/src/Settings/SqpSettingsGeneralWidget.cpp created 644 +45 0

@@ -0,0 +1,45
	1	#include "Settings/SqpSettingsGeneralWidget.h"
	2
	3	#include "Settings/SqpSettingsDefs.h"
	4
	5	#include "ui_SqpSettingsGeneralWidget.h"
	6
	7	SqpSettingsGeneralWidget::SqpSettingsGeneralWidget(QWidget *parent)
	8	: QWidget{parent}, ui{new Ui::SqpSettingsGeneralWidget}
	9	{
	10	ui->setupUi(this);
	11	}
	12
	13	SqpSettingsGeneralWidget::~SqpSettingsGeneralWidget() noexcept
	14	{
	15	delete ui;
	16	}
	17
	18	void SqpSettingsGeneralWidget::loadSettings()
	19	{
	20	QSettings settings{};
	21
	22	auto loadTolerance = [&settings](const QString &key, double defaultValue) {
	23	// Tolerance is converted to percent
	24	auto toleranceValue = settings.value(key, defaultValue).toDouble();
	25	return toleranceValue * 100.;
	26	};
	27
	28	ui->toleranceInitSpinBox->setValue(
	29	loadTolerance(GENERAL_TOLERANCE_AT_INIT_KEY, GENERAL_TOLERANCE_AT_INIT_DEFAULT_VALUE));
	30	ui->toleranceUpdateSpinBox->setValue(
	31	loadTolerance(GENERAL_TOLERANCE_AT_UPDATE_KEY, GENERAL_TOLERANCE_AT_UPDATE_DEFAULT_VALUE));
	32	}
	33
	34	void SqpSettingsGeneralWidget::saveSettings() const
	35	{
	36	QSettings settings{};
	37
	38	auto saveTolerance = [&settings](const QString &key, double value) {
	39	// Tolerance is converted from percent
	40	settings.setValue(key, value * 0.01);
	41	};
	42
	43	saveTolerance(GENERAL_TOLERANCE_AT_INIT_KEY, ui->toleranceInitSpinBox->value());
	44	saveTolerance(GENERAL_TOLERANCE_AT_UPDATE_KEY, ui->toleranceUpdateSpinBox->value());
	45	}

gui/ui/Settings/SqpSettingsDialog.ui created 644 +84 0

@@ -0,0 +1,84
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<ui version="4.0">
	3	<class>SqpSettingsDialog</class>
	4	<widget class="QDialog" name="SqpSettingsDialog">
	5	<property name="geometry">
	6	<rect>
	7	<x>0</x>
	8	<y>0</y>
	9	<width>572</width>
	10	<height>394</height>
	11	</rect>
	12	</property>
	13	<property name="windowTitle">
	14	<string>SciQlop Settings</string>
	15	</property>
	16	<layout class="QGridLayout" name="gridLayout">
	17	<item row="0" column="0">
	18	<widget class="QListWidget" name="listWidget">
	19	<property name="sizePolicy">
	20	<sizepolicy hsizetype="Minimum" vsizetype="Expanding">
	21	<horstretch>0</horstretch>
	22	<verstretch>0</verstretch>
	23	</sizepolicy>
	24	</property>
	25	</widget>
	26	</item>
	27	<item row="0" column="1">
	28	<widget class="QStackedWidget" name="stackedWidget">
	29	<property name="sizePolicy">
	30	<sizepolicy hsizetype="Expanding" vsizetype="Preferred">
	31	<horstretch>0</horstretch>
	32	<verstretch>0</verstretch>
	33	</sizepolicy>
	34	</property>
	35	</widget>
	36	</item>
	37	<item row="1" column="0" colspan="2">
	38	<widget class="QDialogButtonBox" name="buttonBox">
	39	<property name="orientation">
	40	<enum>Qt::Horizontal</enum>
	41	</property>
	42	<property name="standardButtons">
	43	<set>QDialogButtonBox::Cancel\|QDialogButtonBox::Ok</set>
	44	</property>
	45	</widget>
	46	</item>
	47	</layout>
	48	</widget>
	49	<resources/>
	50	<connections>
	51	<connection>
	52	<sender>buttonBox</sender>
	53	<signal>accepted()</signal>
	54	<receiver>SqpSettingsDialog</receiver>
	55	<slot>accept()</slot>
	56	<hints>
	57	<hint type="sourcelabel">
	58	<x>248</x>
	59	<y>254</y>
	60	</hint>
	61	<hint type="destinationlabel">
	62	<x>157</x>
	63	<y>274</y>
	64	</hint>
	65	</hints>
	66	</connection>
	67	<connection>
	68	<sender>buttonBox</sender>
	69	<signal>rejected()</signal>
	70	<receiver>SqpSettingsDialog</receiver>
	71	<slot>reject()</slot>
	72	<hints>
	73	<hint type="sourcelabel">
	74	<x>316</x>
	75	<y>260</y>
	76	</hint>
	77	<hint type="destinationlabel">
	78	<x>286</x>
	79	<y>274</y>
	80	</hint>
	81	</hints>
	82	</connection>
	83	</connections>
	84	</ui>

gui/ui/Settings/SqpSettingsGeneralWidget.ui created 644 +86 0

@@ -0,0 +1,86
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<ui version="4.0">
	3	<class>SqpSettingsGeneralWidget</class>
	4	<widget class="QWidget" name="SqpSettingsGeneralWidget">
	5	<property name="geometry">
	6	<rect>
	7	<x>0</x>
	8	<y>0</y>
	9	<width>343</width>
	10	<height>300</height>
	11	</rect>
	12	</property>
	13	<property name="windowTitle">
	14	<string>Form</string>
	15	</property>
	16	<layout class="QGridLayout" name="gridLayout">
	17	<item row="0" column="0">
	18	<widget class="QLabel" name="toleranceInitLabel">
	19	<property name="text">
	20	<string>Tolerance on first acquisition:</string>
	21	</property>
	22	</widget>
	23	</item>
	24	<item row="0" column="1">
	25	<widget class="QDoubleSpinBox" name="toleranceInitSpinBox">
	26	<property name="sizePolicy">
	27	<sizepolicy hsizetype="Minimum" vsizetype="Fixed">
	28	<horstretch>0</horstretch>
	29	<verstretch>0</verstretch>
	30	</sizepolicy>
	31	</property>
	32	<property name="suffix">
	33	<string> %</string>
	34	</property>
	35	<property name="minimum">
	36	<double>0.000000000000000</double>
	37	</property>
	38	<property name="maximum">
	39	<double>500.000000000000000</double>
	40	</property>
	41	</widget>
	42	</item>
	43	<item row="1" column="0">
	44	<widget class="QLabel" name="toleranceUpdateLabel">
	45	<property name="text">
	46	<string>Tolerance when updating acquisition:</string>
	47	</property>
	48	</widget>
	49	</item>
	50	<item row="1" column="1">
	51	<widget class="QDoubleSpinBox" name="toleranceUpdateSpinBox">
	52	<property name="sizePolicy">
	53	<sizepolicy hsizetype="Minimum" vsizetype="Fixed">
	54	<horstretch>0</horstretch>
	55	<verstretch>0</verstretch>
	56	</sizepolicy>
	57	</property>
	58	<property name="suffix">
	59	<string> %</string>
	60	</property>
	61	<property name="minimum">
	62	<double>0.000000000000000</double>
	63	</property>
	64	<property name="maximum">
	65	<double>500.000000000000000</double>
	66	</property>
	67	</widget>
	68	</item>
	69	<item row="2" column="0">
	70	<spacer name="verticalSpacer">
	71	<property name="orientation">
	72	<enum>Qt::Vertical</enum>
	73	</property>
	74	<property name="sizeHint" stdset="0">
	75	<size>
	76	<width>20</width>
	77	<height>40</height>
	78	</size>
	79	</property>
	80	</spacer>
	81	</item>
	82	</layout>
	83	</widget>
	84	<resources/>
	85	<connections/>
	86	</ui>

app/src/Main.cpp +5 -2

             /*------------------------------------------------------------------------------
             -- This file is a part of the QLop Software
             -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
             --
             -- This program is free software; you can redistribute it and/or modify
             -- it under the terms of the GNU General Public License as published by
             -- the Free Software Foundation; either version 2 of the License, or
             -- (at your option) any later version.
             --
             -- This program is distributed in the hope that it will be useful,
             -- but WITHOUT ANY WARRANTY; without even the implied warranty of
             -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
             -- GNU General Public License for more details.
             --
             -- You should have received a copy of the GNU General Public License
             -- along with this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "MainWindow.h"
             #include <QProcessEnvironment>
             #include <QThread>
             #include <SqpApplication.h>
             #include <qglobal.h>
             #include <Plugin/PluginManager.h>
             #include <QDir>
+            #include <QLoggingCategory>
+            Q_LOGGING_CATEGORY(LOG_Main, "Main")
             namespace {
             /// Name of the directory containing the plugins
             #if _WIN32 || _WIN64
             const auto PLUGIN_DIRECTORY_NAME = QStringLiteral("plugins");
             #endif
             } // namespace
             int main(int argc, char *argv[])
             {
                 SqpApplication a{argc, argv};
                 SqpApplication::setOrganizationName("LPP");
                 SqpApplication::setOrganizationDomain("lpp.fr");
                 SqpApplication::setApplicationName("SciQLop");
                 MainWindow w;
                 w.show();
                 // Loads plugins
                 auto pluginDir = QDir{sqpApp->applicationDirPath()};
             #if _WIN32 || _WIN64
                 pluginDir.mkdir(PLUGIN_DIRECTORY_NAME);
                 pluginDir.cd(PLUGIN_DIRECTORY_NAME);
             #endif
             #if __unix || __APPLE
             #if __x86_64__ || __ppc64__
                 if (!pluginDir.cd("../lib64/SciQlop")) {
                     pluginDir.cd("../lib64/sciqlop");
                 }
             #else
                 if (!pluginDir.cd("../lib/SciQlop")) {
                     pluginDir.cd("../lib/sciqlop");
                 }
             #endif
             #endif
-                qCDebug(LOG_PluginManager())
+                qCDebug(LOG_Main()) << QObject::tr("Plugin directory: %1").arg(pluginDir.absolutePath());
-                    << QObject::tr("Plugin directory: %1").arg(pluginDir.absolutePath());
                 PluginManager pluginManager{};
                 pluginManager.loadPlugins(pluginDir);
                 return a.exec();
             }

app/src/MainWindow.cpp +42 -56

             /*------------------------------------------------------------------------------
             -- This file is a part of the SciQLop Software
             -- Copyright (C) 2017, Plasma Physics Laboratory - CNRS
             --
             -- This program is free software; you can redistribute it and/or modify
             -- it under the terms of the GNU General Public License as published by
             -- the Free Software Foundation; either version 2 of the License, or
             -- (at your option) any later version.
             --
             -- This program is distributed in the hope that it will be useful,
             -- but WITHOUT ANY WARRANTY; without even the implied warranty of
             -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
             -- GNU General Public License for more details.
             --
             -- You should have received a copy of the GNU General Public License
             -- along with this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "MainWindow.h"
             #include "ui_MainWindow.h"
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceWidget.h>
+            #include <Settings/SqpSettingsDialog.h>
+            #include <Settings/SqpSettingsGeneralWidget.h>
             #include <SidePane/SqpSidePane.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <TimeWidget/TimeWidget.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/VisualizationController.h>
             #include <QAction>
             #include <QDate>
             #include <QDateTime>
             #include <QDir>
             #include <QFileDialog>
             #include <QToolBar>
             #include <QToolButton>
             #include <memory.h>
-            //#include <omp.h>
-            //#include <network/filedownloader.h>
-            //#include <qlopdatabase.h>
-            //#include <qlopsettings.h>
-            //#include <qlopgui.h>
-            //#include <spacedata.h>
-            //#include "qlopcore.h"
-            //#include "qlopcodecmanager.h"
-            //#include "cdfcodec.h"
-            //#include "amdatxtcodec.h"
-            //#include <qlopplotmanager.h>
             #include "iostream"
             Q_LOGGING_CATEGORY(LOG_MainWindow, "MainWindow")
             namespace {
             const auto LEFTMAININSPECTORWIDGETSPLITTERINDEX = 0;
             const auto LEFTINSPECTORSIDEPANESPLITTERINDEX = 1;
             const auto VIEWPLITTERINDEX = 2;
             const auto RIGHTINSPECTORSIDEPANESPLITTERINDEX = 3;
             const auto RIGHTMAININSPECTORWIDGETSPLITTERINDEX = 4;
             }
             class MainWindow::MainWindowPrivate {
             public:
+                explicit MainWindowPrivate(MainWindow *mainWindow)
+                        : m_LastOpenLeftInspectorSize{},
+                          m_LastOpenRightInspectorSize{},
+                          m_GeneralSettingsWidget{new SqpSettingsGeneralWidget{mainWindow}},
+                          m_SettingsDialog{new SqpSettingsDialog{mainWindow}}
+                {
+                }
                 QSize m_LastOpenLeftInspectorSize;
                 QSize m_LastOpenRightInspectorSize;
+                /// General settings widget. MainWindow has the ownership
+                SqpSettingsGeneralWidget *m_GeneralSettingsWidget;
+                /// Settings dialog. MainWindow has the ownership
+                SqpSettingsDialog *m_SettingsDialog;
             };
             MainWindow::MainWindow(QWidget *parent)
                     : QMainWindow{parent},
                       m_Ui{new Ui::MainWindow},
-                      impl{spimpl::make_unique_impl<MainWindowPrivate>()}
+                      impl{spimpl::make_unique_impl<MainWindowPrivate>(this)}
             {
                 m_Ui->setupUi(this);
                 m_Ui->splitter->setCollapsible(LEFTINSPECTORSIDEPANESPLITTERINDEX, false);
                 m_Ui->splitter->setCollapsible(RIGHTINSPECTORSIDEPANESPLITTERINDEX, false);
                 auto leftSidePane = m_Ui->leftInspectorSidePane->sidePane();
                 auto openLeftInspectorAction = new QAction{QIcon{
                                                                ":/icones/previous.png",
                                                            },
                                                            tr("Show/hide the left inspector"), this};
                 auto spacerLeftTop = new QWidget{};
                 spacerLeftTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerLeftBottom = new QWidget{};
                 spacerLeftBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 leftSidePane->addWidget(spacerLeftTop);
                 leftSidePane->addAction(openLeftInspectorAction);
                 leftSidePane->addWidget(spacerLeftBottom);
                 auto rightSidePane = m_Ui->rightInspectorSidePane->sidePane();
                 auto openRightInspectorAction = new QAction{QIcon{
                                                                 ":/icones/next.png",
                                                             },
                                                             tr("Show/hide the right inspector"), this};
                 auto spacerRightTop = new QWidget{};
                 spacerRightTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerRightBottom = new QWidget{};
                 spacerRightBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 rightSidePane->addWidget(spacerRightTop);
                 rightSidePane->addAction(openRightInspectorAction);
                 rightSidePane->addWidget(spacerRightBottom);
                 openLeftInspectorAction->setCheckable(true);
                 openRightInspectorAction->setCheckable(true);
                 auto openInspector = [this](bool checked, bool right, auto action) {
                     action->setIcon(QIcon{(checked xor right) ? ":/icones/next.png" : ":/icones/previous.png"});
                     auto &lastInspectorSize
                         = right ? impl->m_LastOpenRightInspectorSize : impl->m_LastOpenLeftInspectorSize;
                     auto nextInspectorSize = right ? m_Ui->rightMainInspectorWidget->size()
                                                    : m_Ui->leftMainInspectorWidget->size();
                     // Update of the last opened geometry
                     if (checked) {
                         lastInspectorSize = nextInspectorSize;
                     }
                     auto startSize = lastInspectorSize;
                     auto endSize = startSize;
                     endSize.setWidth(0);
                     auto splitterInspectorIndex
                         = right ? RIGHTMAININSPECTORWIDGETSPLITTERINDEX : LEFTMAININSPECTORWIDGETSPLITTERINDEX;
                     auto currentSizes = m_Ui->splitter->sizes();
                     if (checked) {
                         // adjust sizes individually here, e.g.
                         currentSizes[splitterInspectorIndex] -= lastInspectorSize.width();
                         currentSizes[VIEWPLITTERINDEX] += lastInspectorSize.width();
                         m_Ui->splitter->setSizes(currentSizes);
                     }
                     else {
                         // adjust sizes individually here, e.g.
                         currentSizes[splitterInspectorIndex] += lastInspectorSize.width();
                         currentSizes[VIEWPLITTERINDEX] -= lastInspectorSize.width();
                         m_Ui->splitter->setSizes(currentSizes);
                     }
                 };
                 connect(openLeftInspectorAction, &QAction::triggered,
                         [openInspector, openLeftInspectorAction](bool checked) {
                             openInspector(checked, false, openLeftInspectorAction);
                         });
                 connect(openRightInspectorAction, &QAction::triggered,
                         [openInspector, openRightInspectorAction](bool checked) {
                             openInspector(checked, true, openRightInspectorAction);
                         });
+                // //// //
+                // Menu //
+                // //// //
                 this->menuBar()->addAction(tr("File"));
+                auto toolsMenu = this->menuBar()->addMenu(tr("Tools"));
+                toolsMenu->addAction(tr("Settings..."), [this]() {
+                    // Loads settings
+                    impl->m_SettingsDialog->loadSettings();
+                    // Open settings dialog and save settings if the dialog is accepted
+                    if (impl->m_SettingsDialog->exec() == QDialog::Accepted) {
+                        impl->m_SettingsDialog->saveSettings();
+                    }
+                });
                 auto mainToolBar = this->addToolBar(QStringLiteral("MainToolBar"));
                 auto timeWidget = new TimeWidget{};
                 mainToolBar->addWidget(timeWidget);
+                // //////// //
+                // Settings //
+                // //////// //
+                // Registers "general settings" widget to the settings dialog
+                impl->m_SettingsDialog->registerWidget(QStringLiteral("General"),
+                                                       impl->m_GeneralSettingsWidget);
+                // /////////// //
+                // Connections //
+                // /////////// //
                 // Controllers / controllers connections
                 connect(&sqpApp->timeController(), SIGNAL(timeUpdated(SqpDateTime)),
                         &sqpApp->variableController(), SLOT(onDateTimeOnSelection(SqpDateTime)));
                 // Widgets / controllers connections
                 // DataSource
                 connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem *)),
                         m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem *)));
                 // Time
                 connect(timeWidget, SIGNAL(timeUpdated(SqpDateTime)), &sqpApp->timeController(),
                         SLOT(onTimeToUpdate(SqpDateTime)));
                 // Visualization
                 connect(&sqpApp->visualizationController(),
                         SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), m_Ui->view,
                         SLOT(onVariableAboutToBeDeleted(std::shared_ptr<Variable>)));
                 connect(&sqpApp->visualizationController(),
                         SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpDateTime &)), m_Ui->view,
                         SLOT(onRangeChanged(std::shared_ptr<Variable>, const SqpDateTime &)));
                 // Widgets / widgets connections
                 // For the following connections, we use DirectConnection to allow each widget that can
                 // potentially attach a menu to the variable's menu to do so before this menu is displayed.
                 // The order of connections is also important, since it determines the order in which each
                 // widget will attach its menu
                 connect(
                     m_Ui->variableInspectorWidget,
                     SIGNAL(tableMenuAboutToBeDisplayed(QMenu *, const QVector<std::shared_ptr<Variable> > &)),
                     m_Ui->view, SLOT(attachVariableMenu(QMenu *, const QVector<std::shared_ptr<Variable> > &)),
                     Qt::DirectConnection);
-                /*    QLopGUI::registerMenuBar(menuBar());
-                    this->setWindowIcon(QIcon(":/sciqlopLOGO.svg"));
-                    this->m_progressWidget = new QWidget();
-                    this->m_progressLayout = new QVBoxLayout(this->m_progressWidget);
-                    this->m_progressWidget->setLayout(this->m_progressLayout);
-                    this->m_progressWidget->setWindowModality(Qt::WindowModal);
-                    m_progressThreadIds = (int*) malloc(OMP_THREADS*sizeof(int));
-                    for(int i=0;i<OMP_THREADS;i++)
-                        this->m_progress.append(new QProgressBar(this->m_progressWidget));
-                        this->m_progress.last()->setMinimum(0);
-                        this->m_progress.last()->setMaximum(100);
-                        this->m_progressLayout->addWidget(this->m_progress.last());
-                        this->m_progressWidget->hide();
-                        this->m_progressThreadIds[i] = -1;
-                    this->m_progressWidget->setWindowTitle("Loading File");
-                    const QList<QLopService*>ServicesToLoad=QList<QLopService*>()
-                            << QLopCore::self()
-                            << QLopPlotManager::self()
-                            << QLopCodecManager::self()
-                            << FileDownloader::self()
-                            << QLopDataBase::self()
-                            << SpaceData::self();
-                    CDFCodec::registerToManager();
-                    AMDATXTCodec::registerToManager();
-                    for(int i=0;i<ServicesToLoad.count();i++)
-                        qDebug()<<ServicesToLoad.at(i)->serviceName();
-                        ServicesToLoad.at(i)->initialize(); //must be called before getGUI
-                        QDockWidget* wdgt=ServicesToLoad.at(i)->getGUI();
-                        if(wdgt)
-                            wdgt->setAllowedAreas(Qt::AllDockWidgetAreas);
-                            this->addDockWidget(Qt::TopDockWidgetArea,wdgt);
-                        PythonQt::self()->getMainModule().addObject(ServicesToLoad.at(i)->serviceName(),(QObject*)ServicesToLoad.at(i));
-                    }*/
             }
             MainWindow::~MainWindow()
             {
             }
             void MainWindow::changeEvent(QEvent *e)
             {
                 QMainWindow::changeEvent(e);
                 switch (e->type()) {
                     case QEvent::LanguageChange:
                         m_Ui->retranslateUi(this);
                         break;
                     default:
                         break;
                 }
             }

core/CMakeLists.txt +3 0

             ## core - CMakeLists.txt
             STRING(TOLOWER ${CMAKE_PROJECT_NAME} LIBRARY_PREFFIX)
             SET(SQPCORE_LIBRARY_NAME "${LIBRARY_PREFFIX}_core${DEBUG_SUFFIX}")
             SET(SOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src/")
             SET(INCLUDES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include/")
             # Include core directory
             include_directories("${INCLUDES_DIR}")
             # Set a variable to display a warning in the version files.
             SET(SCIQLOP_CMAKE_GENERATION_WARNING "DON'T CHANGE THIS FILE. AUTOGENERATED BY CMAKE.")
             # Generate the version file from the cmake version variables. The version
             # variables are defined in the cmake/sciqlop_version.cmake file.
             CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/resources/Version.h.in"
                     "${INCLUDES_DIR}/Version.h")
             CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/resources/Version.cpp.in"
             	"${SOURCES_DIR}/Version.cpp")
             # Find dependent modules
             find_package(sciqlop-plugin)
             INCLUDE_DIRECTORIES(${SCIQLOP-PLUGIN_INCLUDE_DIR})
             #
             # Find Qt modules
             #
             SCIQLOP_FIND_QT(Core Network)
             #
             # Compile the library library
             #
+            ADD_DEFINITIONS(-DCORE_LIB)
             FILE (GLOB_RECURSE MODULE_SOURCES
                     ${INCLUDES_DIR}/*.h
                     ${SOURCES_DIR}/*.c
                     ${SOURCES_DIR}/*.cpp
             	${SOURCES_DIR}/*.h)
             ADD_LIBRARY(${SQPCORE_LIBRARY_NAME} ${MODULE_SOURCES})
             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)
             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
             IF(BUILD_SHARED_LIBS)
                     SET_TARGET_PROPERTIES(${SQPCORE_LIBRARY_NAME} PROPERTIES COMPILE_DEFINITIONS "SCIQLOP_EXPORT")
             ELSE()
                     TARGET_COMPILE_DEFINITIONS(${SQPCORE_LIBRARY_NAME} PUBLIC "SCIQLOP_STATIC_LIBRARIES")
             ENDIF()
             # Set the variable to parent scope so that the other projects can copy the
             # dependent shared libraries
             SCIQLOP_SET_TO_PARENT_SCOPE(SQPCORE_LIBRARY_NAME)
             # Copy extern shared libraries to the lib folder
             SCIQLOP_COPY_TO_TARGET(LIBRARY ${SQPCORE_LIBRARY_NAME} ${EXTERN_SHARED_LIBRARIES})
             # Add the files to the list of files to be analyzed
             LIST(APPEND CHECKSTYLE_INPUT_FILES ${MODULE_SOURCES})
             SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_INPUT_FILES)
             # Vera++ exclusion files
             LIST(APPEND CHECKSTYLE_EXCLUSION_FILES ${CMAKE_CURRENT_SOURCE_DIR}/vera-exclusions/exclusions.txt)
             SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_EXCLUSION_FILES)
             #
             # Compile the tests
             #
             IF(BUILD_TESTS)
             	INCLUDE_DIRECTORIES(${SOURCES_DIR})
             	FILE (GLOB_RECURSE TESTS_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/Test*.cpp)
             	FILE (GLOB_RECURSE TESTS_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/Test*.h)
                     SET( TEST_LIBRARIES ${SQPCORE_LIBRARY_NAME})
                     SET(TARGETS_COV)
             	FOREACH( testFile ${TESTS_SOURCES} )
                             GET_FILENAME_COMPONENT( testDirectory ${testFile} DIRECTORY )
             		GET_FILENAME_COMPONENT( testName ${testFile} NAME_WE )
             		# Add to the list of sources files all the sources in the same
             		# directory that aren't another test
             		FILE (GLOB currentTestSources
             			${testDirectory}/*.c
             			${testDirectory}/*.cpp
                                     ${testDirectory}/*.h)
                             LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES})
                             # LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS})
                             ADD_EXECUTABLE(${testName} ${testFile} ${currentTestSources})
                             set_property(TARGET ${testName} PROPERTY CXX_STANDARD 14)
                             set_property(TARGET ${testName} PROPERTY CXX_STANDARD_REQUIRED ON)
                             TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} )
                             qt5_use_modules(${testName} Test)
                             ADD_TEST( NAME ${testName} COMMAND ${testName} )
                             SCIQLOP_COPY_TO_TARGET(RUNTIME ${testName} ${EXTERN_SHARED_LIBRARIES})
                             set(Coverage_NAME ${testName})
                             if(UNIX)
                                 SETUP_TARGET_FOR_COVERAGE(TARGET ${testName}_coverage OUTPUT ${testFile}-path NAME ${testFile} EXECUTABLE ${testName})
                                 LIST( APPEND TARGETS_COV ${testName}_coverage)
                             endif(UNIX)
                     ENDFOREACH( testFile )
                     add_custom_target(coverage)
                     FOREACH( target_cov ${TARGETS_COV} )
                         add_custom_command(TARGET coverage PRE_BUILD COMMAND make ${target_cov})
                     ENDFOREACH( target_cov )
             	LIST(APPEND testFilesToFormat ${TESTS_SOURCES})
             	LIST(APPEND testFilesToFormat ${TESTS_HEADERS})
             	LIST(APPEND FORMATTING_INPUT_FILES ${testFilesToFormat})
                     SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
             ENDIF(BUILD_TESTS)
             #
             # Set the files that must be formatted by clang-format.
             #
             LIST (APPEND FORMATTING_INPUT_FILES ${MODULE_SOURCES})
             SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
             #
             # Set the directories that doxygen must browse to generate the
             # documentation.
             #
             # Source directories:
             LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/docs")
             LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
             SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_INPUT_DIRS)
             # Source directories to exclude from the documentation generation
             #LIST (APPEND DOXYGEN_EXCLUDE_PATTERNS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir/*")
             SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_EXCLUDE_PATTERNS)
             #
             # Set the directories with the sources to analyze and propagate the
             # modification to the parent scope
             #
             # Source directories to analyze:
             LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
             LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/tests")
             SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_INPUT_DIRS)
             # Source directories to exclude from the analysis
             #LIST (APPEND ANALYSIS_EXCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir")
             SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_EXCLUDE_DIRS)

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

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

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

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

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

             #ifndef SCIQLOP_DATASOURCECONTROLLER_H
             #define SCIQLOP_DATASOURCECONTROLLER_H
+            #include "CoreGlobal.h"
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             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
              * is the intermediate class that SciQlop has to use in the way to connect a data source. Please
              * first use register method to initialize a plugin specified by its metadata name (JSON 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 DataSourceController : public QObject {
+            class SCIQLOP_CORE_EXPORT DataSourceController : public QObject {
                 Q_OBJECT
             public:
                 explicit DataSourceController(QObject *parent = 0);
                 virtual ~DataSourceController();
                 /**
                  * Registers a data source. The method delivers a unique id that can be used afterwards to
                  * access to the data source properties (structure, connection parameters, data provider, etc.)
                  * @param dataSourceName the name of the data source
                  * @return the unique id with which the data source has been registered
                  */
                 QUuid registerDataSource(const QString &dataSourceName) noexcept;
                 /**
                  * 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
                  * @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();
                 void finalize();
             signals:
                 /// Signal emitted when a structure has been set for a data source
                 void dataSourceItemSet(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();
                 class DataSourceControllerPrivate;
                 spimpl::unique_impl_ptr<DataSourceControllerPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCECONTROLLER_H

core/include/DataSource/DataSourceItem.h +3 -1

             #ifndef SCIQLOP_DATASOURCEITEM_H
             #define SCIQLOP_DATASOURCEITEM_H
+            #include "CoreGlobal.h"
             #include <Common/spimpl.h>
             #include <QVariant>
             #include <QVector>
             class DataSourceItemAction;
             /**
              * Possible types of an item
              */
             enum class DataSourceItemType { NODE, PRODUCT, COMPONENT };
             /**
              * @brief The DataSourceItem class aims to represent a structure element of a data source.
              * A data source has a tree structure that is made up of a main DataSourceItem object (root)
              * containing other DataSourceItem objects (children).
              * For each DataSourceItem can be associated a set of data representing it.
              */
-            class DataSourceItem {
+            class SCIQLOP_CORE_EXPORT DataSourceItem {
             public:
                 /// Key associated with the name of the item
                 static const QString NAME_DATA_KEY;
                 explicit DataSourceItem(DataSourceItemType type, const QString &name);
                 explicit DataSourceItem(DataSourceItemType type, QVariantHash data = {});
                 /// @return the actions of the item as a vector
                 QVector<DataSourceItemAction *> actions() const noexcept;
                 /**
                  * Adds an action to the item. The item takes ownership of the action, and the action is
                  * automatically associated to the item
                  * @param action the action to add
                  */
                 void addAction(std::unique_ptr<DataSourceItemAction> action) noexcept;
                 /**
                  * Adds a child to the item. The item takes ownership of the child.
                  * @param child the child to add
                  */
                 void appendChild(std::unique_ptr<DataSourceItem> child) noexcept;
                 /**
                  * Returns the item's child associated to an index
                  * @param childIndex the index to search
                  * @return a pointer to the child if index is valid, nullptr otherwise
                  */
                 DataSourceItem *child(int childIndex) const noexcept;
                 int childCount() const noexcept;
                 /**
                  * Get the data associated to a key
                  * @param key the key to search
                  * @return the data found if key is valid, default QVariant otherwise
                  */
                 QVariant data(const QString &key) const noexcept;
                 /// Gets all data
                 QVariantHash data() const noexcept;
                 bool isRoot() const noexcept;
                 QString name() const noexcept;
                 /**
                  * Get the item's parent
                  * @return a pointer to the parent if it exists, nullptr if the item is a root
                  */
                 DataSourceItem *parentItem() const noexcept;
                 /**
                  * Sets or appends a value to a key
                  * @param key the key
                  * @param value the value
                  * @param append if true, the value is added to the values already existing for the key,
                  * otherwise it replaces the existing values
                  */
                 void setData(const QString &key, const QVariant &value, bool append = false) noexcept;
                 DataSourceItemType type() const noexcept;
                 bool operator==(const DataSourceItem &other);
                 bool operator!=(const DataSourceItem &other);
             private:
                 class DataSourceItemPrivate;
                 spimpl::unique_impl_ptr<DataSourceItemPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCEITEMMODEL_H

core/include/DataSource/DataSourceItemAction.h +3 -1

             #ifndef SCIQLOP_DATASOURCEITEMACTION_H
             #define SCIQLOP_DATASOURCEITEMACTION_H
+            #include "CoreGlobal.h"
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <functional>
             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSourceItemAction)
             class DataSourceItem;
             /**
              * @brief The DataSourceItemAction class represents an action on a data source item.
              *
              * An action is a function that will be executed when the slot execute() is called.
              */
-            class DataSourceItemAction : public QObject {
+            class SCIQLOP_CORE_EXPORT DataSourceItemAction : public QObject {
                 Q_OBJECT
             public:
                 /// Signature of the function associated to the action
                 using ExecuteFunction = std::function<void(DataSourceItem &dataSourceItem)>;
                 /**
                  * Ctor
                  * @param name the name of the action
                  * @param fun the function that will be called when the action is executed
                  * @sa execute()
                  */
                 explicit DataSourceItemAction(const QString &name, ExecuteFunction fun);
                 QString name() const noexcept;
                 /// Sets the data source item concerned by the action
                 void setDataSourceItem(DataSourceItem *dataSourceItem) noexcept;
             public slots:
                 /// Executes the action
                 void execute();
             private:
                 class DataSourceItemActionPrivate;
                 spimpl::unique_impl_ptr<DataSourceItemActionPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCEITEMACTION_H

core/include/Network/NetworkController.h +3 -1

             #ifndef SCIQLOP_NETWORKCONTROLLER_H
             #define SCIQLOP_NETWORKCONTROLLER_H
+            #include "CoreGlobal.h"
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             #include <functional>
             Q_DECLARE_LOGGING_CATEGORY(LOG_NetworkController)
             class QNetworkReply;
             class QNetworkRequest;
             /**
              * @brief The NetworkController class aims to handle all network connection of SciQlop.
              */
-            class NetworkController : public QObject {
+            class SCIQLOP_CORE_EXPORT NetworkController : public QObject {
                 Q_OBJECT
             public:
                 explicit NetworkController(QObject *parent = 0);
                 void initialize();
                 void finalize();
             public slots:
                 /// Execute request and call callback when the reply is finished. Identifier is attached to the
                 /// callback
                 void onProcessRequested(const QNetworkRequest &request, QUuid identifier,
                                         std::function<void(QNetworkReply *, QUuid)> callback);
                 /// Cancel the request of identifier
                 void onReplyCanceled(QUuid identifier);
             signals:
                 void replyFinished(QNetworkReply *reply, QUuid identifier);
                 void replyDownloadProgress(QUuid identifier, double progress);
             private:
                 void waitForFinish();
                 class NetworkControllerPrivate;
                 spimpl::unique_impl_ptr<NetworkControllerPrivate> impl;
             };
             #endif // SCIQLOP_NETWORKCONTROLLER_H

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

             #ifndef SCIQLOP_PLUGINMANAGER_H
             #define SCIQLOP_PLUGINMANAGER_H
+            #include "CoreGlobal.h"
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             class QDir;
             Q_DECLARE_LOGGING_CATEGORY(LOG_PluginManager)
             /**
              * @brief The PluginManager class aims to handle the plugins loaded dynamically into SciQLop.
              */
-            class PluginManager {
+            class SCIQLOP_CORE_EXPORT PluginManager {
             public:
                 explicit PluginManager();
                 /**
                  * Loads plugins into SciQlop. The loaded plugins are those located in the directory passed in
                  * parameter
                  * @param pluginDir the directory containing the plugins
                  */
                 void loadPlugins(const QDir &pluginDir);
                 /// @returns the number of plugins loaded
                 int nbPluginsLoaded() const noexcept;
             private:
                 class PluginManagerPrivate;
                 spimpl::unique_impl_ptr<PluginManagerPrivate> impl;
             };
             #endif // SCIQLOP_PLUGINMANAGER_H

core/include/Time/TimeController.h +3 -1

             #ifndef SCIQLOP_TIMECONTROLLER_H
             #define SCIQLOP_TIMECONTROLLER_H
+            #include "CoreGlobal.h"
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_TimeController)
             /**
              * @brief The TimeController class aims to handle the Time parameters notification in SciQlop.
              */
-            class TimeController : public QObject {
+            class SCIQLOP_CORE_EXPORT TimeController : public QObject {
                 Q_OBJECT
             public:
                 explicit TimeController(QObject *parent = 0);
                 SqpDateTime dateTime() const noexcept;
             signals:
                 /// Signal emitted to notify that time parameters has beed updated
                 void timeUpdated(SqpDateTime time);
             public slots:
                 /// Slot called when a new dateTime has been defined.
                 void onTimeToUpdate(SqpDateTime dateTime);
                 /// Slot called when the dateTime has to be notified. Call timeUpdated signal
                 void onTimeNotify();
             private:
                 class TimeControllerPrivate;
                 spimpl::unique_impl_ptr<TimeControllerPrivate> impl;
             };
             #endif // SCIQLOP_TIMECONTROLLER_H

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

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

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

             #ifndef SCIQLOP_VARIABLECACHECONTROLLER_H
             #define SCIQLOP_VARIABLECACHECONTROLLER_H
+            #include "CoreGlobal.h"
             #include <QLoggingCategory>
             #include <QObject>
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheController)
             class Variable;
-            Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheController)
             /// This class aims to store in the cache all of the dateTime already requested to the variable.
-            class VariableCacheController : public QObject {
+            class SCIQLOP_CORE_EXPORT VariableCacheController : public QObject {
                 Q_OBJECT
             public:
                 explicit VariableCacheController(QObject *parent = 0);
                 void addDateTime(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
                 /// Clears cache concerning a variable
                 void clear(std::shared_ptr<Variable> variable) noexcept;
                 /// Return all of the SqpDataTime part of the dateTime whose are not in the cache
                 QVector<SqpDateTime> provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
                                                                    const SqpDateTime &dateTime);
                 QVector<SqpDateTime> dateCacheList(std::shared_ptr<Variable> variable) const noexcept;
                 void displayCache(std::shared_ptr<Variable> variable) const;
             private:
                 class VariableCacheControllerPrivate;
                 spimpl::unique_impl_ptr<VariableCacheControllerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLECACHECONTROLLER_H

core/include/Variable/VariableController.h +3 -1

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

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

             #ifndef SCIQLOP_VARIABLEMODEL_H
             #define SCIQLOP_VARIABLEMODEL_H
+            #include "CoreGlobal.h"
             #include <Data/SqpDateTime.h>
             #include <QAbstractTableModel>
             #include <QLoggingCategory>
             #include <Common/MetaTypes.h>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableModel)
             enum VariableRoles { ProgressRole = Qt::UserRole };
             class IDataSeries;
             class Variable;
             /**
              * @brief The VariableModel class aims to hold the variables that have been created in SciQlop
              */
-            class VariableModel : public QAbstractTableModel {
+            class SCIQLOP_CORE_EXPORT VariableModel : public QAbstractTableModel {
                 Q_OBJECT
             public:
                 explicit VariableModel(QObject *parent = nullptr);
                 /**
                  * Creates a new variable in the model
                  * @param name the name of the new variable
                  * @param dateTime the dateTime of the new variable
                  * @param metadata the metadata associated to the new variable
                  * @return the pointer to the new variable
                  */
                 std::shared_ptr<Variable> createVariable(const QString &name, const SqpDateTime &dateTime,
                                                          const QVariantHash &metadata) noexcept;
                 /**
                  * Deletes a variable from the model, if it exists
                  * @param variable the variable to delete
                  */
                 void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
                 std::shared_ptr<Variable> variable(int index) const;
                 void setDataProgress(std::shared_ptr<Variable> variable, double progress);
                 // /////////////////////////// //
                 // QAbstractTableModel methods //
                 // /////////////////////////// //
                 virtual int columnCount(const QModelIndex &parent = QModelIndex{}) const override;
                 virtual int rowCount(const QModelIndex &parent = QModelIndex{}) const override;
                 virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
                 virtual QVariant headerData(int section, Qt::Orientation orientation,
                                             int role = Qt::DisplayRole) const override;
                 void abortProgress(const QModelIndex &index);
             signals:
                 void abortProgessRequested(std::shared_ptr<Variable> variable);
             private:
                 class VariableModelPrivate;
                 spimpl::unique_impl_ptr<VariableModelPrivate> impl;
             private slots:
                 /// Slot called when data of a variable has been updated
                 void onVariableUpdated() noexcept;
             };
             // Registers QVector<int> metatype so it can be used in VariableModel::dataChanged() signal
             SCIQLOP_REGISTER_META_TYPE(QVECTOR_INT_REGISTRY, QVector<int>)
             #endif // SCIQLOP_VARIABLEMODEL_H

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

             #ifndef SCIQLOP_VISUALIZATIONCONTROLLER_H
             #define SCIQLOP_VISUALIZATIONCONTROLLER_H
+            #include "CoreGlobal.h"
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationController)
             class DataSourceItem;
             class Variable;
             /**
              * @brief The VisualizationController class aims to make the link between SciQlop and its plugins.
              * This is the intermediate class that SciQlop has to use in the way to connect a data source.
              * Please first use register method to initialize a plugin specified by its metadata name (JSON
              * 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 VisualizationController : public QObject {
+            class SCIQLOP_CORE_EXPORT 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 SqpDateTime &range);
             public slots:
                 /// Manage init/end of the controller
                 void initialize();
                 void finalize();
             private:
                 void waitForFinish();
                 class VisualizationControllerPrivate;
                 spimpl::unique_impl_ptr<VisualizationControllerPrivate> impl;
             };
             #endif // SCIQLOP_VISUALIZATIONCONTROLLER_H

gui/src/Visualization/VisualizationGraphHelper.cpp +4 -4

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

gui/src/Visualization/VisualizationGraphWidget.cpp +16 -5

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

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

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

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages