HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1478:6e3f56cd8c8b

PySide2 bindings + some GUI clean...

jeandet -

r1478:6e3f56cd8c8b

parent child

Context file:

r1478:6e3f56cd8c8b

app/PySide2-bindings/CMakeLists.txt +1 -1

             find_package(PythonLibs 3 REQUIRED)
             find_package(PythonInterp 3 REQUIRED)
             find_package(PySide2  REQUIRED)
             find_package(Shiboken2  REQUIRED)
             include(PythonInfo)
             find_python_site_packages(PYTHON_SITE_PACKAGES)
             set(BINDINGS_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
             set(BINDINGS_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}")
             configure_file("${BINDINGS_SRC_DIR}/bindings.xml" "${BINDINGS_BUILD_DIR}/bindings.xml" COPYONLY)
             configure_file("${BINDINGS_SRC_DIR}/main.py" "${BINDINGS_BUILD_DIR}/main.py" COPYONLY)
             execute_process(COMMAND "${PYTHON_EXECUTABLE}" "${BINDINGS_SRC_DIR}/src_list.py" cmake "${BINDINGS_BUILD_DIR}" OUTPUT_VARIABLE BINDINGS_SOURCE)
             set_property(SOURCE ${BINDINGS_SOURCE} PROPERTY SKIP_AUTOGEN ON)
             list(APPEND BINDINGS_INCLUDE_DIRS
                 ${PYTHON_INCLUDE_DIRS}
                 ${Qt5Core_INCLUDE_DIRS}
                 ${Qt5Widgets_INCLUDE_DIRS}
                 ${Qt5Gui_INCLUDE_DIRS}
                 ${CMAKE_CURRENT_SOURCE_DIR}/../../gui/include
                 ${CMAKE_CURRENT_SOURCE_DIR}/../../core/include
                 ${CMAKE_CURRENT_SOURCE_DIR}/../../core/external/TimeSeries/include
                 )
             list(REMOVE_DUPLICATES BINDINGS_INCLUDE_DIRS)
             foreach(DIR ${BINDINGS_INCLUDE_DIRS})
                 list(APPEND BINDINGS_INCLUDE_DIRS_ARGS "-I${DIR}")
             endforeach()
             set(SHIBOKEN_OPTIONS --generator-set=shiboken
                 --enable-parent-ctor-heuristic
                 --enable-return-value-heuristic
                 --use-isnull-as-nb_nonzero
                 --avoid-protected-hack
                 --enable-pyside-extensions
                 -std=c++17)
             add_custom_command(
                     OUTPUT ${BINDINGS_SOURCE}
                     COMMAND Shiboken2::shiboken2 ${SHIBOKEN_OPTIONS}
                          ${BINDINGS_INCLUDE_DIRS_ARGS}
                         --typesystem-paths=${PYSIDE_TYPESYSTEMS}
                         --output-directory=${CMAKE_CURRENT_BINARY_DIR}
                         ${CMAKE_CURRENT_SOURCE_DIR}/bindings.h ${CMAKE_CURRENT_SOURCE_DIR}/bindings.xml
                     DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/bindings.xml"
                     IMPLICIT_DEPENDS CXX "${CMAKE_CURRENT_SOURCE_DIR}/bindings.h"
                     WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
                     COMMENT "Generating Python bindings with shiboken2")
             include_directories(
                 ${PYSIDE_INCLUDE_DIR}/QtCore
                 ${PYSIDE_INCLUDE_DIR}/QtGui
                 ${PYSIDE_INCLUDE_DIR}/QtWidgets)
             include_directories(
                         ${PYTHON_SITE_PACKAGES}/numpy/core/include/
                         ${PYTHON_INCLUDE_DIRS}
                         ${SHIBOKEN_INCLUDE_DIR}
                         ${PYSIDE_INCLUDE_DIR}
                         ${PYSIDE_INCLUDE_DIR}/QtCore
                         ${PYSIDE_INCLUDE_DIR}/QtGui
                         ${PYSIDE_INCLUDE_DIR}/QtWidgets)
-            add_library(SciQLopBindings MODULE ${BINDINGS_SOURCE} numpy_wrappers.h)
+            add_library(SciQLopBindings MODULE ${BINDINGS_SOURCE} numpy_wrappers.h PyDataProvider.h)
             set_target_properties(
                 SciQLopBindings
                 PROPERTIES
                     PREFIX ""
                     OUTPUT_NAME "SciQLopBindings"
                 )
             target_link_libraries(SciQLopBindings sciqlopapp)
             target_link_libraries(SciQLopBindings Shiboken2::libshiboken)
             target_link_libraries(SciQLopBindings PySide2::pyside2)
             add_executable(debug_sciqlop_app main.cpp )
             find_package (Python3 COMPONENTS Development)
             target_link_libraries(debug_sciqlop_app PRIVATE Python3::Python)

app/PySide2-bindings/PyDataProvider.h +77 -4

@@ -1,16 +1,89
1	#pragma once	1	#pragma once
		2	#include <Data/DataProviderParameters.h>
2	#include <Data/IDataProvider.h>	3	#include <Data/IDataProvider.h>
		4	#include <DataSource/DataSourceController.h>
		5	#include <DataSource/DataSourceItem.h>
		6	#include <DataSource/DataSourceItemAction.h>
		7	#include <QPair>
		8	#include <SqpApplication.h>
		9	// must be included last because of Python/Qt definition of slots
		10	#include "numpy_wrappers.h"
		11
		12	struct Product
		13	{
		14	QString path;
		15	std::vector<std::string> components;
		16	QMap<QString, QString> metadata;
		17	Product() = default;
		18	explicit Product(const QString& path, const std::vector<std::string>& components,
		19	const QMap<QString, QString>& metadata)
		20	: path { path }, components { components }, metadata { metadata }
		21	{
		22	}
		23	virtual ~Product() = default;
		24	};
3		25
4	class PyDataProvider : public IDataProvider	26	class PyDataProvider : public IDataProvider
5	{	27	{
6	public:	28	public:
7	PyDataProvider() {}	29	PyDataProvider()
		30	{
		31	auto& dataSourceController = sqpApp->dataSourceController();
		32	dataSourceController.registerProvider(this);
		33	}
8		34
9	virtual TimeSeries::ITimeSerie getData(const std::string& key, double start_time, double stop_time)	35	virtual ~PyDataProvider() {}
10	{}
11		36
12	virtual TimeSeries::ITimeSerie* getData(const DataProviderParameters& parameters)	37	virtual QPair<NpArray, NpArray> getData(
		38	const std::string& key, double start_time, double stop_time)
13	{	39	{
		40	(void)key, (void)start_time, (void)stop_time;
		41	return {};
		42	}
		43
		44	virtual TimeSeries::ITimeSerie* getData(const DataProviderParameters& parameters) override
		45	{
		46	if (parameters.m_Data.contains("name"))
		47	{
		48	auto data = getData(parameters.m_Data["name"].toString().toStdString(),
		49	parameters.m_Range.m_TStart, parameters.m_Range.m_TEnd);
		50	// TODO add shape/type switch
		51	return new ScalarTimeSerie { data.first.to_std_vect(), data.second.to_std_vect() };
		52	}
14	return nullptr;	53	return nullptr;
15	}	54	}
		55
		56
		57	inline void register_products(const QVector<Product*>& products)
		58	{
		59	auto& dataSourceController = sqpApp->dataSourceController();
		60	auto id = this->id();
		61	auto data_source_name = this->name();
		62	std::for_each(std::cbegin(products), std::cend(products),
		63	[&id, &dataSourceController](const Product* product) {
		64	dataSourceController.setDataSourceItem(id, product->path, product->metadata);
		65	});
		66	}
16	};	67	};
		68
		69
		70	struct Providers
		71	{
		72	Providers() = default;
		73	virtual ~Providers() = default;
		74	inline void register_provider(PyDataProvider* provider)
		75	{
		76	auto& dataSourceController = sqpApp->dataSourceController();
		77	dataSourceController.setDataProvider(
		78	provider->id(), std::unique_ptr<IDataProvider>(provider));
		79	}
		80	};
		81
		82
		83	inline ScalarTimeSerie test_PyDataProvider(PyDataProvider& prov)
		84	{
		85	auto v = prov.getData("", 0., 0.);
		86	ScalarTimeSerie s;
		87	s.set_data(v.first.to_std_vect(), v.second.to_std_vect());
		88	return s;
		89	}

app/PySide2-bindings/bindings.xml +22 -3

             <?xml version="1.0"?>
             <typesystem package="SciQLopBindings">
                 <load-typesystem name="typesystem_core.xml" generate="no" />
                 <load-typesystem name="typesystem_gui.xml" generate="no" />
                 <load-typesystem name="typesystem_widgets.xml" generate="no" />
                 <primitive-type name="std::string"/>
                 <primitive-type name="std::size_t"/>
                 <container-type name="std::vector" type="vector">
                     <include file-name="vector" location="global"/>
                     <conversion-rule>
                         <native-to-target>
                             %INTYPE::size_type vectorSize = %in.size();
                             PyObject* %out = PyList_New((int) vectorSize);
                             for (%INTYPE::size_type idx = 0; idx &lt; vectorSize; ++idx) {
                                 %INTYPE_0 cppItem(%in[idx]);
                                 PyList_SET_ITEM(%out, idx, %CONVERTTOPYTHON[%INTYPE_0](cppItem));
                             }
                             return %out;
                         </native-to-target>
                         <target-to-native>
                             <add-conversion type="PySequence">
                                 Shiboken::AutoDecRef seq(PySequence_Fast(%in, 0));
                                 int vectorSize = PySequence_Fast_GET_SIZE(seq.object());
                                 %out.reserve(vectorSize);
                                 for (int idx = 0; idx &lt; vectorSize; ++idx ) {
                                     PyObject* pyItem = PySequence_Fast_GET_ITEM(seq.object(), idx);
                                     %OUTTYPE_0 cppItem = %CONVERTTOCPP[%OUTTYPE_0](pyItem);
                                     %out.push_back(cppItem);
                                 }
                             </add-conversion>
                         </target-to-native>
                     </conversion-rule>
                 </container-type>
+                <object-type name="PyDataProvider" />
+                <object-type name="Product" />
                 <object-type name="MainWindow" />
                 <object-type name="SqpApplication">
                     <modify-function signature="SqpApplication(int&amp;,char**)" access="private"/>
                 </object-type>
-                <object-type name="PyDataProvider" />
+                <object-type name="Providers">
-                <function signature="SqpApplication_ctor()"/>
+                    <modify-function  signature="register_provider(PyDataProvider*)">
+                      <modify-argument index="1">
+                          <define-ownership owner="c++" />
+                      </modify-argument>
+                    </modify-function>
+                </object-type>
+                <function signature="SqpApplication_ctor()" return-type="SqpApplication*"/>
+                <add-function signature="SqpApplication_ctor(PySequence)" return-type="SqpApplication*">
+                    <inject-code class="target">
+                        static int argc;
+                        static char **argv;
+                        Shiboken::listToArgcArgv(%1, &amp;argc, &amp;argv, "PySideApp");
+                        auto retval = new SqpApplication(argc,argv);
+                        %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](retval);
+                    </inject-code>
+                </add-function>
                 <function signature="init_resources()"/>
                 <primitive-type name="NpArray" target-lang-api-name="PyObject">
                   <include file-name="numpy_wrappers.h" location="local"/>
                   <conversion-rule>
                       <native-to-target>
-                      return %in.py_object();
+                      auto result = %in.py_object();
+                      return result;
                       </native-to-target>
                       <target-to-native>
                         <add-conversion type="PyObject" check="NpArray::isNpArray(%in)">
                         %out = %OUTTYPE(%in);
                         </add-conversion>
                       </target-to-native>
                     </conversion-rule>
                 </primitive-type>
                 <function signature="load_plugins(const SqpApplication&amp;)"/>
                 <object-type name="ScalarTimeSerie">
                     <add-function signature="ScalarTimeSerie(NpArray&amp;,NpArray&amp;)" return-type="ScalarTimeSerie">
                         <inject-code class="target">
                             %BEGIN_ALLOW_THREADS
                             %0 = new ScalarTimeSerieWrapper();
                             %0.set_data(%1.to_std_vect(),%2.to_std_vect());
                             %END_ALLOW_THREADS
                         </inject-code>
                     </add-function>
                     <add-function signature="size()" return-type="int" access="public" static="no">
                         <inject-code class="target">
                             %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME();
                             %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
                         </inject-code>
                     </add-function>
                 </object-type>
+                <function signature="test_PyDataProvider(PyDataProvider&amp;)"/>
                 <function signature="test_np_array(NpArray&amp;)"/>
             </typesystem>

app/PySide2-bindings/main.cpp +13 0

             #include <fstream>
             #include <iostream>
             #define PY_SSIZE_T_CLEAN
             #define Py_DEBUG
             #include <Python.h>
+            wchar_t** decode_argv(int argc, char** argv)
+            {
+                wchar_t** _argv = static_cast<wchar_t**>(PyMem_Malloc(sizeof(wchar_t*) * argc));
+                for (int i = 0; i < argc; i++)
+                {
+                    wchar_t* arg = Py_DecodeLocale(argv[i], NULL);
+                    _argv[i] = arg;
+                }
+                return _argv;
+            }
             int main(int argc, char** argv)
             {
                 wchar_t* program = Py_DecodeLocale(argv[0], NULL);
                 if (program == NULL)
                 {
                     fprintf(stderr, "Fatal error: cannot decode argv[0]\n");
                     exit(1);
                 }
                 Py_SetProgramName(program); /* optional but recommended */
                 Py_Initialize();
+                PySys_SetArgv(argc, decode_argv(argc, argv));
                 std::ifstream t(argv[1]);
                 std::string str((std::istreambuf_iterator<char>(t)), std::istreambuf_iterator<char>());
                 PyRun_SimpleString(str.data());
                 if (Py_FinalizeEx() < 0)
                 {
                     exit(120);
                 }
                 PyMem_RawFree(program);
                 return 0;
             }

app/PySide2-bindings/main.py +2 -1

             # This Python file uses the following encoding: utf-8
             import os
             print(os.getcwd())
             import sys
             from PySide2.QtWidgets import QApplication, QMainWindow, QDockWidget
             from PySide2.QtCore import QSize, Qt
             from PySide2 import QtGui
             import os
+            sys.path.append(os.getcwd())
             from SciQLopBindings import SqpApplication, MainWindow, init_resources, load_plugins, SqpApplication_ctor
             from qtconsole.rich_ipython_widget import RichJupyterWidget
             from qtconsole.inprocess import QtInProcessKernelManager
             class IPythonWidget(RichJupyterWidget):
                 """Live IPython console widget.
                 .. image:: img/IPythonWidget.png
                 :param custom_banner: Custom welcome message to be printed at the top of
                    the console.
                 """
                 def __init__(self, parent=None, custom_banner=None, *args, **kwargs):
                     if parent is not None:
                         kwargs["parent"] = parent
                     super(IPythonWidget, self).__init__(*args, **kwargs)
                     if custom_banner is not None:
                         self.banner = custom_banner
                     self.setWindowTitle(self.banner)
                     self.kernel_manager = kernel_manager = QtInProcessKernelManager()
                     kernel_manager.start_kernel()
                     self.kernel_client = kernel_client = self._kernel_manager.client()
                     kernel_client.start_channels()
                     def stop():
                         kernel_client.stop_channels()
                         kernel_manager.shutdown_kernel()
                     self.exit_requested.connect(stop)
                 def sizeHint(self):
                     """Return a reasonable default size for usage in :class:`PlotWindow`"""
                     return QSize(500, 300)
                 def pushVariables(self, variable_dict):
                     """ Given a dictionary containing name / value pairs, push those
                     variables to the IPython console widget.
                     :param variable_dict: Dictionary of variables to be pushed to the
                         console's interactive namespace (```{variable_name: object, …}```)
                     """
                     self.kernel_manager.kernel.shell.push(variable_dict)
             class IPythonDockWidget(QDockWidget):
                 """Dock Widget including a :class:`IPythonWidget` inside
                 a vertical layout.
                 .. image:: img/IPythonDockWidget.png
                 :param available_vars: Dictionary of variables to be pushed to the
                     console's interactive namespace: ``{"variable_name": object, …}``
                 :param custom_banner: Custom welcome message to be printed at the top of
                     the console
                 :param title: Dock widget title
                 :param parent: Parent :class:`qt.QMainWindow` containing this
                     :class:`qt.QDockWidget`
                 """
                 def __init__(self, parent=None, available_vars=None, custom_banner=None,
                              title="Console"):
                     super(IPythonDockWidget, self).__init__(title, parent)
                     self.ipyconsole = IPythonWidget(custom_banner=custom_banner)
                     self.layout().setContentsMargins(0, 0, 0, 0)
                     self.setWidget(self.ipyconsole)
                     if available_vars is not None:
                         self.ipyconsole.pushVariables(available_vars)
                     self.ipyconsole.pushVariables({"blah":self})
                 def showEvent(self, event):
                     """Make sure this widget is raised when it is shown
                     (when it is first created as a tab in PlotWindow or when it is shown
                     again after hiding).
                     """
                     self.raise_()
             def print_process_id():
                 print ('Process ID is:', os.getpid())
             if __name__ == "__main__":
                 init_resources()
-                app = SqpApplication_ctor()
+                app = SqpApplication_ctor(sys.argv)
                 QtGui.qApp = app
                 load_plugins(app)
                 main_window = MainWindow()
                 term = IPythonDockWidget(available_vars={"app":app, "main_window":main_window}, custom_banner="SciQLop IPython Console ")
                 main_window.addDockWidget(Qt.BottomDockWidgetArea, term)
                 main_window.show()
                 sys.exit(app.exec_())

app/PySide2-bindings/numpy_wrappers.h +17 -16

             #ifndef NUMPY_WRAPPERS_H
             #define NUMPY_WRAPPERS_H
             #include <Data/ScalarTimeSerie.h>
             #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
             #if defined(slots) && (defined(__GNUC__) || defined(_MSC_VER) || defined(__clang__))
             #pragma push_macro("slots")
             #undef slots
             extern "C"
             {
             /*
              * Python 2 uses the "register" keyword, which is deprecated in C++ 11
              * and forbidden in C++17.
              */
             #if defined(__clang__)
             #pragma clang diagnostic push
             #pragma clang diagnostic ignored "-Wdeprecated-register"
             #endif
             #include <Python.h>
             #include <numpy/arrayobject.h>
             #if defined(__clang__)
             #pragma clang diagnostic pop
             #endif
             }
             #else
             #include <Python.h>
             #include <numpy/arrayobject.h>
             #endif
             #include <assert.h>
+            #include <map>
             inline int init_numpy()
             {
                 import_array(); // PyError if not successful
                 return 0;
             }
             const static int numpy_initialized = init_numpy();
             template <typename dest_type = PyObject>
             struct PyObjectWrapper
             {
             private:
-                PyObject* _py_obj;
+                PyObject* _py_obj = nullptr;
                 void inc_refcount()
                 {
-                    if (_py_obj)
+                    Py_XINCREF(_py_obj);
-                        Py_IncRef(_py_obj);
                 }
                 void dec_refcount()
                 {
-                    if (_py_obj)
+                    Py_XDECREF(_py_obj);
-                        Py_DecRef(_py_obj);
+                    _py_obj = nullptr;
                 }
             public:
                 PyObjectWrapper() : _py_obj { nullptr } {}
-                PyObjectWrapper(const PyObjectWrapper& other) : _py_obj { other._py_obj } { inc_refcount(); };
+                PyObjectWrapper(const PyObjectWrapper& other) : _py_obj { other._py_obj } { inc_refcount(); }
-                PyObjectWrapper(PyObjectWrapper&& other) : _py_obj { other._py_obj }
+                PyObjectWrapper(PyObjectWrapper&& other) : _py_obj { other._py_obj } { inc_refcount(); }
+                explicit PyObjectWrapper(PyObject* obj) : _py_obj { obj }
                 {
-                    other._py_obj = nullptr;
+                    inc_refcount();
                 }
-                PyObjectWrapper(PyObject* obj) : _py_obj { obj } { inc_refcount(); }
                 ~PyObjectWrapper() { dec_refcount(); }
                 PyObjectWrapper& operator=(PyObjectWrapper&& other)
                 {
+                    dec_refcount();
                     this->_py_obj = other._py_obj;
-                    other._py_obj = nullptr;
+                    inc_refcount();
                     return *this;
                 }
                 PyObjectWrapper& operator=(const PyObjectWrapper& other)
                 {
                     dec_refcount();
                     this->_py_obj = other._py_obj;
                     inc_refcount();
                     return *this;
                 }
                 PyObject* py_object() { return _py_obj; }
                 inline dest_type* get() { return reinterpret_cast<dest_type*>(_py_obj); }
                 inline bool is_null() { return _py_obj == nullptr; }
             };
             struct NpArray
             {
             private:
                 PyObjectWrapper<PyArrayObject> _py_obj;
                 NpArray(NpArray& other) = delete;
                 NpArray(const NpArray& other) = delete;
                 NpArray(const NpArray&& other) = delete;
             public:
                 static bool isNpArray(PyObject* obj)
                 {
-                    return obj && PyArray_Check(reinterpret_cast<PyArrayObject*>(obj))
+                    auto arr = reinterpret_cast<PyArrayObject*>(obj);
-                        && PyArray_IS_C_CONTIGUOUS(reinterpret_cast<PyArrayObject*>(obj));
+                    auto is_c_aray = obj && PyArray_Check(arr) && PyArray_ISCARRAY(arr);
+                    return is_c_aray;
                 }
                 NpArray() : _py_obj { nullptr } {}
-                NpArray(NpArray&& other) : _py_obj { std::move(other._py_obj) } {}
+                NpArray(NpArray&& other) : _py_obj { other._py_obj } {}
                 explicit NpArray(PyObject* obj) : _py_obj { obj }
                 {
-                    std::cout << "NpArray ctor" << std::endl;
                     assert(isNpArray(obj));
                     assert(PyArray_ISFLOAT(_py_obj.get()));
                 }
                 NpArray& operator=(const NpArray& other)
                 {
                     this->_py_obj = other._py_obj;
                     return *this;
                 }
                 NpArray& operator=(NpArray&& other)
                 {
-                    this->_py_obj = std::move(other._py_obj);
+                    this->_py_obj = other._py_obj;
                     return *this;
                 }
                 std::vector<std::size_t> shape()
                 {
                     std::vector<std::size_t> shape;
                     if (!_py_obj.is_null())
                     {
                         if (int ndim = PyArray_NDIM(_py_obj.get()); ndim > 0)
                         {
                             if (ndim < 10)
                             {
                                 shape.resize(ndim);
                                 std::copy_n(PyArray_SHAPE(_py_obj.get()), ndim, std::begin(shape));
                             }
                         }
                     }
                     return shape;
                 }
                 std::size_t flat_size()
                 {
                     auto s = this->shape();
                     return std::accumulate(std::cbegin(s), std::cend(s), 0);
                 }
                 double data(std::size_t pos)
                 {
                     if (!_py_obj.is_null())
                     {
                         return reinterpret_cast<double*>(PyArray_DATA(_py_obj.get()))[pos];
                     }
                     return nan("NAN");
                 }
                 std::vector<double> to_std_vect()
                 {
                     auto sz = flat_size();
                     std::vector<double> v(sz);
                     auto d_ptr = reinterpret_cast<double*>(PyArray_DATA(_py_obj.get()));
                     std::copy(d_ptr, d_ptr + sz, std::begin(v));
                     return v;
                 }
                 PyObject* py_object() { return _py_obj.py_object(); }
             };
             inline int test_np_array(NpArray& arr)
             {
                 auto shape = arr.shape();
                 std::cout << "len(shape)=" << shape.size() << std::endl;
                 std::for_each(std::cbegin(shape), std::cend(shape), [](auto sz) {
                     static int i = 0;
                     std::cout << "shape[" << i++ << "]=" << sz << std::endl;
                 });
                 auto flatsize = std::accumulate(std::cbegin(shape), std::cend(shape), 0);
                 for (auto i = 0; i < flatsize; i++)
                 {
                     std::cout << "data[" << i << "]=" << arr.data(i) << std::endl;
                 }
                 return 1;
             }
             #endif //#ifndef NUMPY_WRAPPERS_H

app/include/toolbar.h +1 -1

             #ifndef TOOLBAR_H
             #define TOOLBAR_H
             #include <Data/DateTimeRange.h>
             #include <QAction>
             #include <QActionGroup>
             #include <QObject>
             #include <QToolBar>
             #include <QWidget>
             #include <TimeWidget/TimeWidget.h>
-            // @TODO remove this, shouldn't need to include SqpApplication to get PlotsInteractionMode
+            // TODO remove this, shouldn't need to include SqpApplication to get PlotsInteractionMode
             #include <SqpApplication.h>
             class ToolBar : public QToolBar
             {
                 Q_OBJECT
             public:
                 explicit ToolBar(QWidget* parent = nullptr);
                 QAction* timeRange;
                 QAction* pointerMode;
                 QAction* zoomMode;
                 QAction* organizationMode;
                 QAction* zonesMode;
                 QAction* cursorsActn;
                 QAction* cataloguesActn;
                 TimeWidgetAction* timeWidget;
             signals:
                 void setPlotsInteractionMode(SqpApplication::PlotsInteractionMode);
                 void setPlotsCursorMode(SqpApplication::PlotsCursorMode);
                 void timeUpdated(DateTimeRange time);
                 void showCataloguesBrowser();
             };
             #endif // TOOLBAR_H

app/src/MainWindow.cpp +4 -77

             /*------------------------------------------------------------------------------
             -- 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 <Catalogue/CatalogueController.h>
             #include <Catalogue2/browser.h>
             #include <DataSource/DataSourceController.h>
+            #include <DataSource/DataSourceItem.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 "toolbar.h"
             #include <QAction>
             #include <QCloseEvent>
             #include <QDate>
             #include <QDir>
             #include <QFileDialog>
             #include <QMessageBox>
             #include <QToolBar>
             #include <QToolButton>
             #include <memory.h>
             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_GeneralSettingsWidget { new SqpSettingsGeneralWidget { mainWindow } }
-                        , m_LastOpenRightInspectorSize {}
-                        , m_GeneralSettingsWidget { new SqpSettingsGeneralWidget { mainWindow } }
                         , m_SettingsDialog { new SqpSettingsDialog { mainWindow } }
                         , m_CatalogExplorer { new CataloguesBrowser { 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;
                 /// Catalogue dialog. MainWindow has the ownership
                 CataloguesBrowser* m_CatalogExplorer;
                 bool checkDataToSave(QWidget* parentWidget);
             };
             MainWindow::MainWindow(QWidget* parent)
                     : QMainWindow { parent }
                     , m_Ui { new Ui::MainWindow }
                     , impl { spimpl::make_unique_impl<MainWindowPrivate>(this) }
             {
                 m_Ui->setupUi(this);
                 setWindowTitle(QString("SciQLop v%1").arg(SCIQLOP_VERSION));
-                m_Ui->splitter->setCollapsible(LEFTINSPECTORSIDEPANESPLITTERINDEX, false);
-                m_Ui->splitter->setCollapsible(RIGHTINSPECTORSIDEPANESPLITTERINDEX, false);
-                // impl->m_CatalogExplorer->setVisualizationWidget(m_Ui->view);
-                auto spacerLeftTop = new QWidget {};
-                spacerLeftTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
-                auto spacerLeftBottom = new QWidget {};
-                spacerLeftBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
-                auto spacerRightTop = new QWidget {};
-                spacerRightTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
-                auto spacerRightBottom = new QWidget {};
-                spacerRightBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
-                auto openInspector = [this](bool checked, bool right, auto action) {
-                    action->setIcon(
-                        QIcon { (checked ^ 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);
-                };
                 // //////////////// //
                 // Menu and Toolbar //
                 // //////////////// //
                 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 = new ToolBar(this);
                 this->addToolBar(mainToolBar);
                 connect(mainToolBar, &ToolBar::setPlotsInteractionMode, sqpApp,
                     &SqpApplication::setPlotsInteractionMode);
                 connect(mainToolBar, &ToolBar::setPlotsCursorMode, sqpApp, &SqpApplication::setPlotsCursorMode);
                 connect(mainToolBar, &ToolBar::showCataloguesBrowser,
                     [this]() { impl->m_CatalogExplorer->show(); });
                 // //////// //
                 // Settings //
                 // //////// //
                 // Registers "general settings" widget to the settings dialog
                 impl->m_SettingsDialog->registerWidget(
                     QStringLiteral("General"), impl->m_GeneralSettingsWidget);
                 // /////////// //
                 // Connections //
                 // /////////// //
                 // Widgets / controllers connections
                 // DataSource
-                connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem*)),
+                connect(&sqpApp->dataSourceController(), &DataSourceController::dataSourceItemSet,
-                    m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem*)));
+                    m_Ui->dataSourceWidget, &DataSourceWidget::addDataSource);
                 // Time
                 //    connect(timeWidget, SIGNAL(timeUpdated(DateTimeRange)), &sqpApp->timeController(),
                 //        SLOT(onTimeToUpdate(DateTimeRange)));
                 connect(mainToolBar, &ToolBar::timeUpdated, &sqpApp->timeController(),
                     &TimeController::setDateTimeRange);
                 // 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);
             }
             MainWindow::~MainWindow() {}
             void MainWindow::changeEvent(QEvent* e)
             {
                 QMainWindow::changeEvent(e);
                 switch (e->type())
                 {
                     case QEvent::LanguageChange:
                         m_Ui->retranslateUi(this);
                         break;
                     default:
                         break;
                 }
             }
             void MainWindow::closeEvent(QCloseEvent* event)
             {
                 if (!impl->checkDataToSave(this))
                 {
                     event->ignore();
                 }
                 else
                 {
                     event->accept();
                 }
             }
             void MainWindow::keyPressEvent(QKeyEvent* event)
             {
                 switch (event->key())
                 {
                     case Qt::Key_F11:
                         if (this->isFullScreen())
                         {
                             this->showNormal();
                         }
                         else
                         {
                             this->showFullScreen();
                         }
                         break;
                     default:
                         break;
                 }
             }
             bool MainWindow::MainWindowPrivate::checkDataToSave(QWidget* parentWidget)
             {
                 //    auto hasChanges = sqpApp->catalogueController().hasChanges();
                 //    if (hasChanges)
                 //    {
                 //        // There are some unsaved changes
                 //        switch (QMessageBox::question(parentWidget, tr("Save changes"),
                 //            tr("The catalogue controller has unsaved changes.\nDo you want to save them ?"),
                 //            QMessageBox::SaveAll | QMessageBox::Discard | QMessageBox::Cancel,
                 //            QMessageBox::SaveAll))
                 //        {
                 //            case QMessageBox::SaveAll:
                 //                sqpApp->catalogueController().saveAll();
                 //                break;
                 //            case QMessageBox::Discard:
                 //                break;
                 //            case QMessageBox::Cancel:
                 //            default:
                 //                return false;
                 //        }
                 //    }
                 return true;
             }

app/ui/MainWindow.ui +26 -93

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>MainWindow</class>
              <widget class="QMainWindow" name="MainWindow">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>800</width>
                 <height>600</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>SciQlop</string>
               </property>
               <property name="dockNestingEnabled">
                <bool>true</bool>
               </property>
-              <widget class="QWidget" name="centralWidget">
+              <widget class="VisualizationWidget" name="view">
                <property name="enabled">
                 <bool>true</bool>
                </property>
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="maximumSize">
                 <size>
                  <width>16777215</width>
                  <height>16777215</height>
                 </size>
                </property>
-               <layout class="QHBoxLayout" name="horizontalLayout">
-                <property name="spacing">
-                 <number>0</number>
-                </property>
-                <property name="leftMargin">
-                 <number>0</number>
-                </property>
-                <property name="topMargin">
-                 <number>0</number>
-                </property>
-                <property name="rightMargin">
-                 <number>0</number>
-                </property>
-                <property name="bottomMargin">
-                 <number>0</number>
-                </property>
-                <item>
-                 <widget class="QSplitter" name="splitter">
-                  <property name="orientation">
-                   <enum>Qt::Horizontal</enum>
-                  </property>
-                  <widget class="QWidget" name="leftMainInspectorWidget" native="true">
-                   <layout class="QVBoxLayout" name="verticalLayout">
-                    <property name="spacing">
-                     <number>0</number>
-                    </property>
-                    <property name="leftMargin">
-                     <number>0</number>
-                    </property>
-                    <property name="topMargin">
-                     <number>0</number>
-                    </property>
-                    <property name="rightMargin">
-                     <number>0</number>
-                    </property>
-                    <property name="bottomMargin">
-                     <number>0</number>
-                    </property>
-                    <item>
-                     <widget class="DataSourceWidget" name="dataSourceWidget" native="true"/>
-                    </item>
-                    <item>
-                     <widget class="QWidget" name="dateTimeWidget" native="true"/>
-                    </item>
-                    <item>
-                     <widget class="VariableInspectorWidget" name="variableInspectorWidget" native="true"/>
-                    </item>
-                   </layout>
-                  </widget>
-                  <widget class="VisualizationWidget" name="view" native="true">
-                   <property name="sizePolicy">
-                    <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
-                     <horstretch>0</horstretch>
-                     <verstretch>0</verstretch>
-                    </sizepolicy>
-                   </property>
-                  </widget>
-                  <widget class="QWidget" name="rightMainInspectorWidget" native="true">
-                   <layout class="QVBoxLayout" name="verticalLayout_3">
-                    <property name="spacing">
-                     <number>0</number>
-                    </property>
-                    <property name="leftMargin">
-                     <number>0</number>
-                    </property>
-                    <property name="topMargin">
-                     <number>0</number>
-                    </property>
-                    <property name="rightMargin">
-                     <number>0</number>
-                    </property>
-                    <property name="bottomMargin">
-                     <number>0</number>
-                    </property>
-                    <item>
-                     <widget class="QWidget" name="commonPropertyInspectorWidget" native="true"/>
-                    </item>
-                    <item>
-                     <widget class="QTreeWidget" name="catalogWidget">
-                      <column>
-                       <property name="text">
-                        <string notr="true">Name</string>
-                       </property>
-                      </column>
-                     </widget>
-                    </item>
-                   </layout>
-                  </widget>
-                 </widget>
-                </item>
-               </layout>
               </widget>
               <widget class="QMenuBar" name="menuBar">
                <property name="geometry">
                 <rect>
                  <x>0</x>
                  <y>0</y>
                  <width>800</width>
-                 <height>27</height>
+                 <height>24</height>
                 </rect>
                </property>
                <property name="sizePolicy">
                 <sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="minimumSize">
                 <size>
                  <width>0</width>
                  <height>0</height>
                 </size>
                </property>
                <property name="nativeMenuBar">
                 <bool>true</bool>
                </property>
               </widget>
               <widget class="QStatusBar" name="statusBar"/>
+              <widget class="QDockWidget" name="dockWidget">
+               <property name="features">
+                <set>QDockWidget::DockWidgetMovable</set>
+               </property>
+               <property name="windowTitle">
+                <string>Products</string>
+               </property>
+               <attribute name="dockWidgetArea">
+                <number>1</number>
+               </attribute>
+               <widget class="DataSourceWidget" name="dataSourceWidget"/>
+              </widget>
+              <widget class="QDockWidget" name="dockWidget_2">
+               <property name="features">
+                <set>QDockWidget::DockWidgetMovable</set>
+               </property>
+               <property name="windowTitle">
+                <string>Variables</string>
+               </property>
+               <attribute name="dockWidgetArea">
+                <number>1</number>
+               </attribute>
+               <widget class="VariableInspectorWidget" name="variableInspectorWidget"/>
+              </widget>
              </widget>
              <layoutdefault spacing="6" margin="11"/>
              <customwidgets>
               <customwidget>
                <class>VisualizationWidget</class>
                <extends>QWidget</extends>
                <header location="global">Visualization/VisualizationWidget.h</header>
                <container>1</container>
               </customwidget>
               <customwidget>
                <class>DataSourceWidget</class>
                <extends>QWidget</extends>
                <header location="global">DataSource/DataSourceWidget.h</header>
                <container>1</container>
               </customwidget>
               <customwidget>
                <class>VariableInspectorWidget</class>
                <extends>QWidget</extends>
                <header location="global">Variable/VariableInspectorWidget.h</header>
                <container>1</container>
               </customwidget>
              </customwidgets>
              <resources/>
              <connections/>
             </ui>

core +1 -1

	@@ -1,1 +1,1
	1	Subproject commit c4e273750e74336d1d125c02989c922f2032e489		1	Subproject commit 9ff5f48e3d71ce2d3a8b2156f778f3f9be3ea389

gui/src/DataSource/DataSourceTreeWidgetItem.cpp +1 -1

             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <DataSource/DataSourceTreeWidgetItem.h>
             #include <QAction>
             Q_LOGGING_CATEGORY(LOG_DataSourceTreeWidgetItem, "DataSourceTreeWidgetItem")
             namespace {
             // Column indexes
             const auto NAME_COLUMN = 0;
             /**
              * Generates the full name of an item.
              *
              * The full name of an item is its name possibly suffixed by the name of its plugin, in case there
              * are items of the same name in its relatives
              * @param item the item for which to generate the complete name
              * @return the complete name of the item
              */
             QString completeName(const DataSourceItem &item)
             {
                 auto name = item.name();
                 if (item.type() == DataSourceItemType::NODE) {
                     return name;
                 }
                 auto parentItem = item.parentItem();
                 if (!parentItem) {
                     return name;
                 }
                 // Finds in item's relatives items that have the same name
                 bool foundSameName = false;
                 for (auto i = 0, count = parentItem->childCount(); i < count && !foundSameName; ++i) {
                     auto child = parentItem->child(i);
                     foundSameName = child != &item
                                     && QString::compare(child->name(), item.name(), Qt::CaseInsensitive) == 0;
                 }
                 // If the name of the item is not unique, it is completed by the plugin suffix
                 return foundSameName
                            ? QString{"%1 (%2)"}.arg(name, item.data(DataSourceItem::PLUGIN_DATA_KEY).toString())
                            : name;
             }
             QIcon itemIcon(const DataSourceItem *dataSource)
             {
                 if (dataSource) {
                     auto dataSourceType = dataSource->type();
                     switch (dataSourceType) {
                         case DataSourceItemType::NODE: {
                             return dataSource->isRoot() ? QIcon{":/icones/dataSourceRoot.png"}
                                                         : QIcon{":/icones/dataSourceNode.png"};
                         }
                         case DataSourceItemType::PRODUCT:
                             return QIcon{":/icones/dataSourceProduct.png"};
                         case DataSourceItemType::COMPONENT:
                             return QIcon{":/icones/dataSourceComponent.png"};
                         default:
                             // No action
                             break;
                     }
                     qCWarning(LOG_DataSourceTreeWidgetItem())
                         << QObject::tr("Can't set data source icon : unknown data source type");
                 }
                 else {
                     qCCritical(LOG_DataSourceTreeWidgetItem())
                         << QObject::tr("Can't set data source icon : the data source is null");
                 }
                 // Default cases
                 return QIcon{};
             }
             /// @return the tooltip text for a variant. The text depends on whether the data is a simple variant
             /// or a list of variants
             QString tooltipValue(const QVariant &variant) noexcept
             {
                 // If the variant is a list of variants, the text of the tooltip is of the form: {val1, val2,
                 // ...}
                 if (variant.canConvert<QVariantList>()) {
                     auto valueString = QStringLiteral("{");
                     auto variantList = variant.value<QVariantList>();
                     for (auto it = variantList.cbegin(), end = variantList.cend(); it != end; ++it) {
                         valueString.append(it->toString());
                         if (std::distance(it, end) != 1) {
                             valueString.append(", ");
                         }
                     }
                     valueString.append(QStringLiteral("}"));
                     return valueString;
                 }
                 else {
                     return variant.toString();
                 }
             }
             QString itemTooltip(const DataSourceItem *dataSource) noexcept
             {
                 // The tooltip displays all item's data
                 if (dataSource) {
                     auto result = QString{};
                     const auto &data = dataSource->data();
                     for (auto it = data.cbegin(), end = data.cend(); it != end; ++it) {
                         result.append(QString{"<b>%1:</b> %2<br/>"}.arg(it.key(), tooltipValue(it.value())));
                     }
                     return result;
                 }
                 else {
                     qCCritical(LOG_DataSourceTreeWidgetItem())
                         << QObject::tr("Can't set data source tooltip : the data source is null");
                     return QString{};
                 }
             }
             } // namespace
             struct DataSourceTreeWidgetItem::DataSourceTreeWidgetItemPrivate {
                 explicit DataSourceTreeWidgetItemPrivate(const DataSourceItem *data)
                         : m_Data{data}, m_Name{completeName(*m_Data)}
                 {
                 }
                 /// Model used to retrieve data source information
                 const DataSourceItem *m_Data;
                 /// Name displayed
                 QString m_Name;
                 /// Actions associated to the item. The parent of the item (QTreeWidget) takes the ownership of
                 /// the actions
-                QList<QAction *> m_Actions;
+                QList<QAction *> m_Actions; //TODO check if no memory leak here
             };
             DataSourceTreeWidgetItem::DataSourceTreeWidgetItem(const DataSourceItem *data, int type)
                     : DataSourceTreeWidgetItem{nullptr, data, type}
             {
             }
             DataSourceTreeWidgetItem::DataSourceTreeWidgetItem(QTreeWidget *parent, const DataSourceItem *data,
                                                                int type)
                     : QTreeWidgetItem{parent, type},
                       impl{spimpl::make_unique_impl<DataSourceTreeWidgetItemPrivate>(data)}
             {
                 // Sets the icon and the tooltip depending on the data source
                 setIcon(0, itemIcon(impl->m_Data));
                 setToolTip(0, itemTooltip(impl->m_Data));
                 // Generates tree actions based on the item actions
                 auto createTreeAction = [this, &parent](const auto &itemAction) {
                     auto treeAction = new QAction{itemAction->name(), parent};
                     // Executes item action when tree action is triggered
                     QObject::connect(treeAction, &QAction::triggered, itemAction,
                                      &DataSourceItemAction::execute);
                     return treeAction;
                 };
                 auto itemActions = impl->m_Data->actions();
                 std::transform(std::cbegin(itemActions), std::cend(itemActions),
                                std::back_inserter(impl->m_Actions), createTreeAction);
                 // Sets the flags of the items
                 auto flags = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
                 if (data->type() == DataSourceItemType::COMPONENT
                     || data->type() == DataSourceItemType::PRODUCT) {
                     flags |= Qt::ItemIsDragEnabled;
                 }
                 setFlags(flags);
             }
             const DataSourceItem *DataSourceTreeWidgetItem::data() const
             {
                 return impl->m_Data;
             }
             QVariant DataSourceTreeWidgetItem::data(int column, int role) const
             {
                 if (role == Qt::DisplayRole) {
                     if (impl->m_Data) {
                         switch (column) {
                             case NAME_COLUMN:
                                 return impl->m_Name;
                             default:
                                 // No action
                                 break;
                         }
                         qCWarning(LOG_DataSourceTreeWidgetItem())
                             << QObject::tr("Can't get data (unknown column %1)").arg(column);
                     }
                     else {
                         qCCritical(LOG_DataSourceTreeWidgetItem()) << QObject::tr("Can't get data (null item)");
                     }
                     return QVariant{};
                 }
                 else {
                     return QTreeWidgetItem::data(column, role);
                 }
             }
             void DataSourceTreeWidgetItem::setData(int column, int role, const QVariant &value)
             {
                 // Data can't be changed by edition
                 if (role != Qt::EditRole) {
                     QTreeWidgetItem::setData(column, role, value);
                 }
             }
             QList<QAction *> DataSourceTreeWidgetItem::actions() const noexcept
             {
                 return impl->m_Actions;
             }

gui/src/DataSource/DataSourceWidget.cpp +18 -17

             #include <DataSource/DataSourceWidget.h>
             #include <ui_DataSourceWidget.h>
             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceTreeWidgetHelper.h>
             #include <DataSource/DataSourceTreeWidgetItem.h>
             #include <QMenu>
-            namespace {
+            namespace
+            {
             /// Number of columns displayed in the tree
             const auto TREE_NB_COLUMNS = 1;
             /// Header labels for the tree
             const auto TREE_HEADER_LABELS = QStringList { QObject::tr("Name") };
             /**
              * Creates the item associated to a data source
              * @param dataSource the data source for which to create the item
              * @return the new item
              */
             DataSourceTreeWidgetItem* createTreeWidgetItem(DataSourceItem* dataSource)
             {
                 // Creates item for the data source
                 auto item = new DataSourceTreeWidgetItem { dataSource };
                 // Generates items for the children of the data source
-                for (auto i = 0; i < dataSource->childCount(); ++i) {
+                std::for_each(dataSource->cbegin(), dataSource->cend(),
-                    item->addChild(createTreeWidgetItem(dataSource->child(i)));
+                    [&item](const std::unique_ptr<DataSourceItem>& child) {
+                        item->addChild(createTreeWidgetItem(child.get()));
+                    });
                 return item;
             }
             } // namespace
             DataSourceWidget::DataSourceWidget(QWidget* parent)
-                    : QWidget{parent},
+                    : QWidget { parent }
-                      ui{new Ui::DataSourceWidget},
+                    , ui { new Ui::DataSourceWidget }
-                      m_Root{
+                    , m_Root { std::make_unique<DataSourceItem>(
-                          std::make_unique<DataSourceItem>(DataSourceItemType::NODE, QStringLiteral("Sources"))}
+                          DataSourceItemType::NODE, QStringLiteral("Sources")) }
             {
                 ui->setupUi(this);
                 // Set tree properties
                 ui->treeWidget->setColumnCount(TREE_NB_COLUMNS);
                 ui->treeWidget->setHeaderLabels(TREE_HEADER_LABELS);
                 ui->treeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
                 // Connection to show a menu when right clicking on the tree
                 connect(ui->treeWidget, &QTreeWidget::customContextMenuRequested, this,
                     &DataSourceWidget::onTreeMenuRequested);
                 // Connection to filter tree
                 connect(ui->filterLineEdit, &QLineEdit::textChanged, this, &DataSourceWidget::filterChanged);
                 // First init
                 updateTreeWidget();
             }
             DataSourceWidget::~DataSourceWidget() noexcept
             {
                 delete ui;
             }
             void DataSourceWidget::addDataSource(DataSourceItem* dataSource) noexcept
             {
                 // Merges the data source (without taking its root)
-                if (dataSource) {
+                if (dataSource)
-                    for (auto i = 0, count = dataSource->childCount(); i < count; ++i) {
-                        m_Root->merge(*dataSource->child(i));
+                    std::for_each(std::cbegin(*dataSource), std::cend(*dataSource),
+                        [this](const auto& child) { this->m_Root->merge(*child.get()); });
                     updateTreeWidget();
                 }
             }
             void DataSourceWidget::updateTreeWidget() noexcept
             {
                 ui->treeWidget->clear();
                 auto rootItem = createTreeWidgetItem(m_Root.get());
                 ui->treeWidget->addTopLevelItem(rootItem);
                 rootItem->setExpanded(true);
                 // Sorts tree
                 ui->treeWidget->setSortingEnabled(true);
                 ui->treeWidget->sortByColumn(0, Qt::AscendingOrder);
             }
             void DataSourceWidget::filterChanged(const QString& text) noexcept
             {
                 auto validateItem = [&text](const DataSourceTreeWidgetItem& item) {
                     auto regExp = QRegExp { text, Qt::CaseInsensitive, QRegExp::Wildcard };
                     // An item is valid if any of its metadata validates the text filter
                     auto itemMetadata = item.data()->data();
                     auto itemMetadataEnd = itemMetadata.cend();
                     auto acceptFilter
                         = [&regExp](const auto& variant) { return variant.toString().contains(regExp); };
                     return std::find_if(itemMetadata.cbegin(), itemMetadataEnd, acceptFilter)
                         != itemMetadataEnd;
                 };
                 // Applies filter on tree widget
                 DataSourceTreeWidgetHelper::filter(*ui->treeWidget, validateItem);
             }
             void DataSourceWidget::onTreeMenuRequested(const QPoint& pos) noexcept
             {
                 // Retrieves the selected item in the tree, and build the menu from its actions
-                if (auto selectedItem = dynamic_cast<DataSourceTreeWidgetItem *>(ui->treeWidget->itemAt(pos))) {
+                if (auto selectedItem = dynamic_cast<DataSourceTreeWidgetItem*>(ui->treeWidget->itemAt(pos)))
+                {
                     QMenu treeMenu {};
                     treeMenu.addActions(selectedItem->actions());
-                    if (!treeMenu.isEmpty()) {
+                    if (!treeMenu.isEmpty())
+                    {
                         treeMenu.exec(QCursor::pos());
                     }
                 }
             }

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

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationCursorItem.h"
             #include "Visualization/VisualizationDefs.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "Visualization/VisualizationMultiZoneSelectionDialog.h"
             #include "Visualization/VisualizationSelectionZoneItem.h"
             #include "Visualization/VisualizationSelectionZoneManager.h"
             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Actions/ActionsGuiController.h>
             #include <Actions/FilteringAction.h>
             #include <Common/MimeTypesDef.h>
             #include <Common/containers.h>
             #include <Data/DateTimeRangeHelper.h>
             #include <DragAndDrop/DragDropGuiController.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable2.h>
             #include <Variable/VariableController2.h>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
             namespace
             {
             /// Key pressed to enable drag&drop in all modes
             const auto DRAG_DROP_MODIFIER = Qt::AltModifier;
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::ControlModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ShiftModifier;
             /// Speed of a step of a wheel event for a pan, in percentage of the axis range
             const auto PAN_SPEED = 5;
             /// Key pressed to enable a calibration pan
             const auto VERTICAL_PAN_MODIFIER = Qt::AltModifier;
             /// Key pressed to enable multi selection of selection zones
             const auto MULTI_ZONE_SELECTION_MODIFIER = Qt::ControlModifier;
             /// Minimum size for the zoom box, in percentage of the axis range
             const auto ZOOM_BOX_MIN_SIZE = 0.8;
             /// Format of the dates appearing in the label of a cursor
             const auto CURSOR_LABELS_DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd\nhh:mm:ss:zzz");
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate
             {
                 explicit VisualizationGraphWidgetPrivate(const QString& name)
                         : m_Name { name }
                         , m_Flags { GraphFlag::EnableAll }
                         , m_IsCalibration { false }
                         , m_RenderingDelegate { nullptr }
                 {
                     m_plot = new QCustomPlot();
                     // Necessary for all platform since Qt::AA_EnableHighDpiScaling is enable.
                     m_plot->setPlottingHint(QCP::phFastPolylines, true);
                 }
                 void updateData(
                     PlottablesMap& plottables, std::shared_ptr<Variable2> variable, const DateTimeRange& range)
                 {
                     VisualizationGraphHelper::updateData(plottables, variable, range);
                     // Prevents that data has changed to update rendering
                     m_RenderingDelegate->onPlotUpdated();
                 }
                 QString m_Name;
                 // 1 variable -> n qcpplot
                 std::map<std::shared_ptr<Variable2>, PlottablesMap> m_VariableToPlotMultiMap;
                 GraphFlags m_Flags;
                 bool m_IsCalibration;
                 QCustomPlot* m_plot;
                 QPoint m_lastMousePos;
                 QCPRange m_lastXRange;
                 QCPRange m_lastYRange;
                 /// Delegate used to attach rendering features to the plot
                 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
                 QCPItemRect* m_DrawingZoomRect = nullptr;
                 QStack<QPair<QCPRange, QCPRange>> m_ZoomStack;
                 std::unique_ptr<VisualizationCursorItem> m_HorizontalCursor = nullptr;
                 std::unique_ptr<VisualizationCursorItem> m_VerticalCursor = nullptr;
                 VisualizationSelectionZoneItem* m_DrawingZone = nullptr;
                 VisualizationSelectionZoneItem* m_HoveredZone = nullptr;
                 QVector<VisualizationSelectionZoneItem*> m_SelectionZones;
                 bool m_HasMovedMouse = false; // Indicates if the mouse moved in a releaseMouse even
                 bool m_VariableAutoRangeOnInit = true;
                 inline void enterPlotDrag(const QPoint& position)
                 {
                     m_lastMousePos = m_plot->mapFromParent(position);
                     m_lastXRange = m_plot->xAxis->range();
                     m_lastYRange = m_plot->yAxis->range();
                 }
                 inline bool isDrawingZoomRect() { return m_DrawingZoomRect != nullptr; }
                 void updateZoomRect(const QPoint& newPos)
                 {
                     QPointF pos { m_plot->xAxis->pixelToCoord(newPos.x()),
                         m_plot->yAxis->pixelToCoord(newPos.y()) };
                     m_DrawingZoomRect->bottomRight->setCoords(pos);
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                 void applyZoomRect()
                 {
                     auto axisX = m_plot->axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = m_plot->axisRect()->axis(QCPAxis::atLeft);
                     auto newAxisXRange = QCPRange { m_DrawingZoomRect->topLeft->coords().x(),
                         m_DrawingZoomRect->bottomRight->coords().x() };
                     auto newAxisYRange = QCPRange { m_DrawingZoomRect->topLeft->coords().y(),
                         m_DrawingZoomRect->bottomRight->coords().y() };
                     removeDrawingRect();
                     if (newAxisXRange.size() > axisX->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0)
                         && newAxisYRange.size() > axisY->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0))
                     {
                         m_ZoomStack.push(qMakePair(axisX->range(), axisY->range()));
                         axisX->setRange(newAxisXRange);
                         axisY->setRange(newAxisYRange);
                         m_plot->replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 inline bool isDrawingZoneRect() { return m_DrawingZone != nullptr; }
                 void updateZoneRect(const QPoint& newPos)
                 {
                     m_DrawingZone->setEnd(m_plot->xAxis->pixelToCoord(newPos.x()));
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                 void startDrawingRect(const QPoint& pos)
                 {
                     removeDrawingRect();
                     auto axisPos = posToAxisPos(pos);
                     m_DrawingZoomRect = new QCPItemRect { m_plot };
                     QPen p;
                     p.setWidth(2);
                     m_DrawingZoomRect->setPen(p);
                     m_DrawingZoomRect->topLeft->setCoords(axisPos);
                     m_DrawingZoomRect->bottomRight->setCoords(axisPos);
                 }
                 void removeDrawingRect()
                 {
                     if (m_DrawingZoomRect)
                     {
                         m_plot->removeItem(m_DrawingZoomRect); // the item is deleted by QCustomPlot
                         m_DrawingZoomRect = nullptr;
                         m_plot->replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 void selectZone(const QPoint& pos)
                 {
                     auto zoneAtPos = selectionZoneAt(pos);
                     setSelectionZonesEditionEnabled(
                         sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones);
                 }
                 void startDrawingZone(const QPoint& pos)
                 {
                     endDrawingZone();
                     auto axisPos = posToAxisPos(pos);
                     m_DrawingZone = new VisualizationSelectionZoneItem { m_plot };
                     m_DrawingZone->setRange(axisPos.x(), axisPos.x());
                     m_DrawingZone->setEditionEnabled(false);
                 }
                 void endDrawingZone()
                 {
                     if (m_DrawingZone)
                     {
                         auto drawingZoneRange = m_DrawingZone->range();
                         if (qAbs(drawingZoneRange.m_TEnd - drawingZoneRange.m_TStart) > 0)
                         {
                             m_DrawingZone->setEditionEnabled(true);
                             addSelectionZone(m_DrawingZone);
                         }
                         else
                         {
                             m_plot->removeItem(m_DrawingZone);
                         }
                         m_plot->replot(QCustomPlot::rpQueuedReplot);
                         m_DrawingZone = nullptr;
                     }
                 }
                 void moveSelectionZone(const QPoint& destination)
                 {
                     /*
                      * I give up on this for now
-                     * @TODO implement this, the difficulty is that selection zones have their own
+                     * TODO implement this, the difficulty is that selection zones have their own
                      * event handling code which seems to rely on QCP GUI event handling propagation
                      * which was a realy bad design choice.
                      */
                 }
                 void setSelectionZonesEditionEnabled(bool value)
                 {
                     for (auto s : m_SelectionZones)
                     {
                         s->setEditionEnabled(value);
                     }
                 }
                 void addSelectionZone(VisualizationSelectionZoneItem* zone) { m_SelectionZones << zone; }
                 VisualizationSelectionZoneItem* selectionZoneAt(const QPoint& pos) const
                 {
                     VisualizationSelectionZoneItem* selectionZoneItemUnderCursor = nullptr;
                     auto minDistanceToZone = -1;
                     for (auto zone : m_SelectionZones)
                     {
                         auto distanceToZone = zone->selectTest(pos, false);
                         if ((minDistanceToZone < 0 || distanceToZone <= minDistanceToZone)
                             && distanceToZone >= 0 && distanceToZone < m_plot->selectionTolerance())
                         {
                             selectionZoneItemUnderCursor = zone;
                         }
                     }
                     return selectionZoneItemUnderCursor;
                 }
                 QVector<VisualizationSelectionZoneItem*> selectionZonesAt(
                     const QPoint& pos, const QCustomPlot& plot) const
                 {
                     QVector<VisualizationSelectionZoneItem*> zones;
                     for (auto zone : m_SelectionZones)
                     {
                         auto distanceToZone = zone->selectTest(pos, false);
                         if (distanceToZone >= 0 && distanceToZone < plot.selectionTolerance())
                         {
                             zones << zone;
                         }
                     }
                     return zones;
                 }
                 void moveSelectionZoneOnTop(VisualizationSelectionZoneItem* zone, QCustomPlot& plot)
                 {
                     if (!m_SelectionZones.isEmpty() && m_SelectionZones.last() != zone)
                     {
                         zone->moveToTop();
                         m_SelectionZones.removeAll(zone);
                         m_SelectionZones.append(zone);
                     }
                 }
                 QPointF posToAxisPos(const QPoint& pos) const
                 {
                     auto axisX = m_plot->axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = m_plot->axisRect()->axis(QCPAxis::atLeft);
                     return QPointF { axisX->pixelToCoord(pos.x()), axisY->pixelToCoord(pos.y()) };
                 }
                 bool pointIsInAxisRect(const QPointF& axisPoint, QCustomPlot& plot) const
                 {
                     auto axisX = plot.axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = plot.axisRect()->axis(QCPAxis::atLeft);
                     return axisX->range().contains(axisPoint.x()) && axisY->range().contains(axisPoint.y());
                 }
                 inline QCPRange _pixDistanceToRange(double pos1, double pos2, QCPAxis* axis)
                 {
                     if (axis->scaleType() == QCPAxis::stLinear)
                     {
                         auto diff = axis->pixelToCoord(pos1) - axis->pixelToCoord(pos2);
                         return QCPRange { axis->range().lower + diff, axis->range().upper + diff };
                     }
                     else
                     {
                         auto diff = axis->pixelToCoord(pos1) / axis->pixelToCoord(pos2);
                         return QCPRange { axis->range().lower * diff, axis->range().upper * diff };
                     }
                 }
                 void setRange(const DateTimeRange& newRange, bool updateVar = true)
                 {
                     this->m_plot->xAxis->setRange(newRange.m_TStart, newRange.m_TEnd);
                     if (updateVar)
                     {
                         for (auto it = m_VariableToPlotMultiMap.begin(), end = m_VariableToPlotMultiMap.end();
                              it != end; it = m_VariableToPlotMultiMap.upper_bound(it->first))
                         {
                             sqpApp->variableController().asyncChangeRange(it->first, newRange);
                         }
                     }
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                 void setRange(const QCPRange& newRange)
                 {
                     auto graphRange = DateTimeRange { newRange.lower, newRange.upper };
                     setRange(graphRange);
                 }
                 void rescaleY() { m_plot->yAxis->rescale(true); }
                 std::tuple<double, double> moveGraph(const QPoint& destination)
                 {
                     auto currentPos = m_plot->mapFromParent(destination);
                     auto xAxis = m_plot->axisRect()->rangeDragAxis(Qt::Horizontal);
                     auto yAxis = m_plot->axisRect()->rangeDragAxis(Qt::Vertical);
                     auto oldXRange = xAxis->range();
                     auto oldYRange = yAxis->range();
                     double dx = xAxis->pixelToCoord(m_lastMousePos.x()) - xAxis->pixelToCoord(currentPos.x());
                     xAxis->setRange(m_lastXRange.lower + dx, m_lastXRange.upper + dx);
                     if (yAxis->scaleType() == QCPAxis::stLinear)
                     {
                         double dy
                             = yAxis->pixelToCoord(m_lastMousePos.y()) - yAxis->pixelToCoord(currentPos.y());
                         yAxis->setRange(m_lastYRange.lower + dy, m_lastYRange.upper + dy);
                     }
                     else
                     {
                         double dy
                             = yAxis->pixelToCoord(m_lastMousePos.y()) / yAxis->pixelToCoord(currentPos.y());
                         yAxis->setRange(m_lastYRange.lower * dy, m_lastYRange.upper * dy);
                     }
                     auto newXRange = xAxis->range();
                     auto newYRange = yAxis->range();
                     setRange(xAxis->range());
                     // m_lastMousePos = currentPos;
                     return { newXRange.lower - oldXRange.lower, newYRange.lower - oldYRange.lower };
                 }
                 void zoom(double factor, int center, Qt::Orientation orientation)
                 {
                     QCPAxis* axis = m_plot->axisRect()->rangeZoomAxis(orientation);
                     axis->scaleRange(factor, axis->pixelToCoord(center));
                     if (orientation == Qt::Horizontal)
                         setRange(axis->range());
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                 void transform(const DateTimeRangeTransformation& tranformation)
                 {
                     auto graphRange = m_plot->xAxis->range();
                     DateTimeRange range { graphRange.lower, graphRange.upper };
                     range = range.transform(tranformation);
                     setRange(range);
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                 void move(double dx, double dy)
                 {
                     auto xAxis = m_plot->axisRect()->rangeDragAxis(Qt::Horizontal);
                     auto yAxis = m_plot->axisRect()->rangeDragAxis(Qt::Vertical);
                     xAxis->setRange(QCPRange(xAxis->range().lower + dx, xAxis->range().upper + dx));
                     yAxis->setRange(QCPRange(yAxis->range().lower + dy, yAxis->range().upper + dy));
                     setRange(xAxis->range());
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
                 void move(double factor, Qt::Orientation orientation)
                 {
                     auto oldRange = m_plot->xAxis->range();
                     QCPAxis* axis = m_plot->axisRect()->rangeDragAxis(orientation);
                     if (m_plot->xAxis->scaleType() == QCPAxis::stLinear)
                     {
                         double rg = (axis->range().upper - axis->range().lower) * (factor / 10);
                         axis->setRange(axis->range().lower + (rg), axis->range().upper + (rg));
                     }
                     else if (m_plot->xAxis->scaleType() == QCPAxis::stLogarithmic)
                     {
                         int start = 0, stop = 0;
                         double diff = 0.;
                         if (factor > 0.0)
                         {
                             stop = m_plot->width() * factor / 10;
                             start = 2 * m_plot->width() * factor / 10;
                         }
                         if (factor < 0.0)
                         {
                             factor *= -1.0;
                             start = m_plot->width() * factor / 10;
                             stop = 2 * m_plot->width() * factor / 10;
                         }
                         diff = axis->pixelToCoord(start) / axis->pixelToCoord(stop);
                         axis->setRange(m_plot->axisRect()->rangeDragAxis(orientation)->range().lower * diff,
                             m_plot->axisRect()->rangeDragAxis(orientation)->range().upper * diff);
                     }
                     if (orientation == Qt::Horizontal)
                         setRange(axis->range());
                     m_plot->replot(QCustomPlot::rpQueuedReplot);
                 }
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString& name, QWidget* parent)
                     : VisualizationDragWidget { parent }
                     , ui { new Ui::VisualizationGraphWidget }
                     , impl { spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name) }
             {
                 ui->setupUi(this);
                 this->layout()->addWidget(impl->m_plot);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 // The delegate must be initialized after the ui as it uses the plot
                 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*this);
                 // Init the cursors
                 impl->m_HorizontalCursor = std::make_unique<VisualizationCursorItem>(&plot());
                 impl->m_HorizontalCursor->setOrientation(Qt::Horizontal);
                 impl->m_VerticalCursor = std::make_unique<VisualizationCursorItem>(&plot());
                 impl->m_VerticalCursor->setOrientation(Qt::Vertical);
                 this->setFocusPolicy(Qt::WheelFocus);
                 this->setMouseTracking(true);
                 impl->m_plot->setAttribute(Qt::WA_TransparentForMouseEvents);
                 impl->m_plot->setContextMenuPolicy(Qt::CustomContextMenu);
                 impl->m_plot->setParent(this);
                 connect(&sqpApp->variableController(), &VariableController2::variableDeleted, this,
                     &VisualizationGraphWidget::variableDeleted);
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
             VisualizationZoneWidget* VisualizationGraphWidget::parentZoneWidget() const noexcept
             {
                 auto parent = parentWidget();
                 while (parent != nullptr && !qobject_cast<VisualizationZoneWidget*>(parent))
                 {
                     parent = parent->parentWidget();
                 }
                 return qobject_cast<VisualizationZoneWidget*>(parent);
             }
             VisualizationWidget* VisualizationGraphWidget::parentVisualizationWidget() const
             {
                 auto parent = parentWidget();
                 while (parent != nullptr && !qobject_cast<VisualizationWidget*>(parent))
                 {
                     parent = parent->parentWidget();
                 }
                 return qobject_cast<VisualizationWidget*>(parent);
             }
             void VisualizationGraphWidget::setFlags(GraphFlags flags)
             {
                 impl->m_Flags = std::move(flags);
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable2> variable, DateTimeRange range)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *impl->m_plot);
                 // Sets graph properties
                 impl->m_RenderingDelegate->setGraphProperties(*variable, createdPlottables);
                 impl->m_VariableToPlotMultiMap.insert({ variable, std::move(createdPlottables) });
                 setGraphRange(range);
                 // If the variable already has its data loaded, load its units and its range in the graph
                 if (variable->data() != nullptr)
                 {
                     impl->m_RenderingDelegate->setAxesUnits(*variable);
                 }
                 else
                 {
                     auto context = new QObject { this };
                     connect(
                         variable.get(), &Variable2::updated, context, [this, variable, context, range](QUuid) {
                             this->impl->m_RenderingDelegate->setAxesUnits(*variable);
                             this->impl->m_plot->replot(QCustomPlot::rpQueuedReplot);
                             delete context;
                         });
                 }
-                //@TODO this is bad! when variable is moved to another graph it still fires
+                //TODO this is bad! when variable is moved to another graph it still fires
                 // even if this has been deleted
                 connect(variable.get(), &Variable2::updated, this, &VisualizationGraphWidget::variableUpdated);
                 this->onUpdateVarDisplaying(variable, range); // My bullshit
                 emit variableAdded(variable);
             }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable2> variable) noexcept
             {
                 // Each component associated to the variable :
                 // - is removed from qcpplot (which deletes it)
                 // - is no longer referenced in the map
                 auto variableIt = impl->m_VariableToPlotMultiMap.find(variable);
                 if (variableIt != impl->m_VariableToPlotMultiMap.cend())
                 {
                     emit variableAboutToBeRemoved(variable);
                     auto& plottablesMap = variableIt->second;
                     for (auto plottableIt = plottablesMap.cbegin(), plottableEnd = plottablesMap.cend();
                          plottableIt != plottableEnd;)
                     {
                         impl->m_plot->removePlottable(plottableIt->second);
                         plottableIt = plottablesMap.erase(plottableIt);
                     }
                     impl->m_VariableToPlotMultiMap.erase(variableIt);
                 }
                 // Updates graph
                 impl->m_plot->replot(QCustomPlot::rpQueuedReplot);
             }
             std::vector<std::shared_ptr<Variable2>> VisualizationGraphWidget::variables() const
             {
                 auto variables = std::vector<std::shared_ptr<Variable2>> {};
                 for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap);
                      it != std::cend(impl->m_VariableToPlotMultiMap); ++it)
                 {
                     variables.push_back(it->first);
                 }
                 return variables;
             }
             void VisualizationGraphWidget::setYRange(std::shared_ptr<Variable2> variable)
             {
                 if (!variable)
                 {
                     qCCritical(LOG_VisualizationGraphWidget()) << "Can't set y-axis range: variable is null";
                     return;
                 }
                 VisualizationGraphHelper::setYAxisRange(variable, *impl->m_plot);
             }
             DateTimeRange VisualizationGraphWidget::graphRange() const noexcept
             {
                 auto graphRange = impl->m_plot->xAxis->range();
                 return DateTimeRange { graphRange.lower, graphRange.upper };
             }
             void VisualizationGraphWidget::setGraphRange(
                 const DateTimeRange& range, bool updateVar, bool forward)
             {
                 impl->setRange(range, updateVar);
                 if (forward)
                 {
                     emit this->setrange_sig(this->graphRange(), true, false);
                 }
             }
             void VisualizationGraphWidget::setAutoRangeOnVariableInitialization(bool value)
             {
                 impl->m_VariableAutoRangeOnInit = value;
             }
             QVector<DateTimeRange> VisualizationGraphWidget::selectionZoneRanges() const
             {
                 QVector<DateTimeRange> ranges;
                 for (auto zone : impl->m_SelectionZones)
                 {
                     ranges << zone->range();
                 }
                 return ranges;
             }
             void VisualizationGraphWidget::addSelectionZones(const QVector<DateTimeRange>& ranges)
             {
                 for (const auto& range : ranges)
                 {
                     // note: ownership is transfered to QCustomPlot
                     auto zone = new VisualizationSelectionZoneItem(&plot());
                     zone->setRange(range.m_TStart, range.m_TEnd);
                     impl->addSelectionZone(zone);
                 }
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             VisualizationSelectionZoneItem* VisualizationGraphWidget::addSelectionZone(
                 const QString& name, const DateTimeRange& range)
             {
                 // note: ownership is transfered to QCustomPlot
                 auto zone = new VisualizationSelectionZoneItem(&plot());
                 zone->setName(name);
                 zone->setRange(range.m_TStart, range.m_TEnd);
                 impl->addSelectionZone(zone);
                 plot().replot(QCustomPlot::rpQueuedReplot);
                 return zone;
             }
             void VisualizationGraphWidget::removeSelectionZone(VisualizationSelectionZoneItem* selectionZone)
             {
                 parentVisualizationWidget()->selectionZoneManager().setSelected(selectionZone, false);
                 if (impl->m_HoveredZone == selectionZone)
                 {
                     impl->m_HoveredZone = nullptr;
                     setCursor(Qt::ArrowCursor);
                 }
                 impl->m_SelectionZones.removeAll(selectionZone);
                 plot().removeItem(selectionZone);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::undoZoom()
             {
                 auto zoom = impl->m_ZoomStack.pop();
                 auto axisX = plot().axisRect()->axis(QCPAxis::atBottom);
                 auto axisY = plot().axisRect()->axis(QCPAxis::atLeft);
                 axisX->setRange(zoom.first);
                 axisY->setRange(zoom.second);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::zoom(
                 double factor, int center, Qt::Orientation orientation, bool forward)
             {
                 impl->zoom(factor, center, orientation);
                 if (forward && orientation == Qt::Horizontal)
                     emit this->setrange_sig(this->graphRange(), true, false);
             }
             void VisualizationGraphWidget::move(double factor, Qt::Orientation orientation, bool forward)
             {
                 impl->move(factor, orientation);
                 if (forward)
                     emit this->setrange_sig(this->graphRange(), true, false);
             }
             void VisualizationGraphWidget::move(double dx, double dy, bool forward)
             {
                 impl->move(dx, dy);
                 if (forward)
                     emit this->setrange_sig(this->graphRange(), true, false);
             }
             void VisualizationGraphWidget::transform(
                 const DateTimeRangeTransformation& tranformation, bool forward)
             {
                 impl->transform(tranformation);
                 if (forward)
                     emit this->setrange_sig(this->graphRange(), true, false);
             }
             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(Variable2& variable) const
             {
                 auto isSpectrogram
                     = [](auto& variable) { return variable.type() == DataSeriesType::SPECTROGRAM; };
                 // - A spectrogram series can't be dropped on graph with existing plottables
                 // - No data series can be dropped on graph with existing spectrogram series
                 return isSpectrogram(variable)
                     ? impl->m_VariableToPlotMultiMap.empty()
                     : std::none_of(impl->m_VariableToPlotMultiMap.cbegin(),
                           impl->m_VariableToPlotMultiMap.cend(),
                           [isSpectrogram](const auto& entry) { return isSpectrogram(*entry.first); });
             }
             bool VisualizationGraphWidget::contains(Variable2& 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 impl->m_Name;
             }
             QMimeData* VisualizationGraphWidget::mimeData(const QPoint& position) const
             {
                 auto mimeData = new QMimeData;
                 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(position);
                 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
                     && selectionZoneItemUnderCursor)
                 {
                     mimeData->setData(MIME_TYPE_TIME_RANGE,
                         TimeController::mimeDataForTimeRange(selectionZoneItemUnderCursor->range()));
                     mimeData->setData(MIME_TYPE_SELECTION_ZONE,
                         TimeController::mimeDataForTimeRange(selectionZoneItemUnderCursor->range()));
                 }
                 else
                 {
                     mimeData->setData(MIME_TYPE_GRAPH, QByteArray {});
                     auto timeRangeData = TimeController::mimeDataForTimeRange(graphRange());
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
                 }
                 return mimeData;
             }
             QPixmap VisualizationGraphWidget::customDragPixmap(const QPoint& dragPosition)
             {
                 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(dragPosition);
                 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
                     && selectionZoneItemUnderCursor)
                 {
                     auto zoneTopLeft = selectionZoneItemUnderCursor->topLeft->pixelPosition();
                     auto zoneBottomRight = selectionZoneItemUnderCursor->bottomRight->pixelPosition();
                     auto zoneSize = QSizeF { qAbs(zoneBottomRight.x() - zoneTopLeft.x()),
                         qAbs(zoneBottomRight.y() - zoneTopLeft.y()) }
                                         .toSize();
                     auto pixmap = QPixmap(zoneSize);
                     render(&pixmap, QPoint(), QRegion { QRect { zoneTopLeft.toPoint(), zoneSize } });
                     return pixmap;
                 }
                 return QPixmap();
             }
             bool VisualizationGraphWidget::isDragAllowed() const
             {
                 return true;
             }
             void VisualizationGraphWidget::highlightForMerge(bool highlighted)
             {
                 if (highlighted)
                 {
                     plot().setBackground(QBrush(QColor("#BBD5EE")));
                 }
                 else
                 {
                     plot().setBackground(QBrush(Qt::white));
                 }
                 plot().update();
             }
             void VisualizationGraphWidget::addVerticalCursor(double time)
             {
                 impl->m_VerticalCursor->setPosition(time);
                 impl->m_VerticalCursor->setVisible(true);
                 auto text
                     = DateUtils::dateTime(time).toString(CURSOR_LABELS_DATETIME_FORMAT).replace(' ', '\n');
                 impl->m_VerticalCursor->setLabelText(text);
             }
             void VisualizationGraphWidget::addVerticalCursorAtViewportPosition(double position)
             {
                 impl->m_VerticalCursor->setAbsolutePosition(position);
                 impl->m_VerticalCursor->setVisible(true);
                 auto axis = plot().axisRect()->axis(QCPAxis::atBottom);
                 auto text
                     = DateUtils::dateTime(axis->pixelToCoord(position)).toString(CURSOR_LABELS_DATETIME_FORMAT);
                 impl->m_VerticalCursor->setLabelText(text);
             }
             void VisualizationGraphWidget::removeVerticalCursor()
             {
                 impl->m_VerticalCursor->setVisible(false);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::addHorizontalCursor(double value)
             {
                 impl->m_HorizontalCursor->setPosition(value);
                 impl->m_HorizontalCursor->setVisible(true);
                 impl->m_HorizontalCursor->setLabelText(QString::number(value));
             }
             void VisualizationGraphWidget::addHorizontalCursorAtViewportPosition(double position)
             {
                 impl->m_HorizontalCursor->setAbsolutePosition(position);
                 impl->m_HorizontalCursor->setVisible(true);
                 auto axis = plot().axisRect()->axis(QCPAxis::atLeft);
                 impl->m_HorizontalCursor->setLabelText(QString::number(axis->pixelToCoord(position)));
             }
             void VisualizationGraphWidget::removeHorizontalCursor()
             {
                 impl->m_HorizontalCursor->setVisible(false);
                 plot().replot(QCustomPlot::rpQueuedReplot);
             }
             void VisualizationGraphWidget::closeEvent(QCloseEvent* event)
             {
                 Q_UNUSED(event);
                 for (auto i : impl->m_SelectionZones)
                 {
                     parentVisualizationWidget()->selectionZoneManager().setSelected(i, false);
                 }
                 // Prevents that all variables will be removed from graph when it will be closed
                 for (auto& variableEntry : impl->m_VariableToPlotMultiMap)
                 {
                     emit variableAboutToBeRemoved(variableEntry.first);
                 }
             }
             void VisualizationGraphWidget::enterEvent(QEvent* event)
             {
                 Q_UNUSED(event);
                 impl->m_RenderingDelegate->showGraphOverlay(true);
             }
             void VisualizationGraphWidget::leaveEvent(QEvent* event)
             {
                 Q_UNUSED(event);
                 impl->m_RenderingDelegate->showGraphOverlay(false);
                 if (auto parentZone = parentZoneWidget())
                 {
                     parentZone->notifyMouseLeaveGraph(this);
                 }
                 else
                 {
                     qCWarning(LOG_VisualizationGraphWidget()) << "leaveEvent: No parent zone widget";
                 }
                 if (impl->m_HoveredZone)
                 {
                     impl->m_HoveredZone->setHovered(false);
                     impl->m_HoveredZone = nullptr;
                 }
             }
             void VisualizationGraphWidget::wheelEvent(QWheelEvent* event)
             {
                 double factor;
                 double wheelSteps = event->delta() / 120.0; // a single step delta is +/-120 usually
                 if (event->modifiers() == Qt::ControlModifier)
                 {
                     if (event->orientation() == Qt::Vertical) // mRangeZoom.testFlag(Qt::Vertical))
                     {
                         setCursor(Qt::SizeVerCursor);
                         factor = pow(impl->m_plot->axisRect()->rangeZoomFactor(Qt::Vertical), wheelSteps);
                         zoom(factor, event->pos().y(), Qt::Vertical);
                     }
                 }
                 else if (event->modifiers() == Qt::ShiftModifier)
                 {
                     if (event->orientation() == Qt::Vertical) // mRangeZoom.testFlag(Qt::Vertical))
                     {
                         setCursor(Qt::SizeHorCursor);
                         factor = pow(impl->m_plot->axisRect()->rangeZoomFactor(Qt::Horizontal), wheelSteps);
                         zoom(factor, event->pos().x(), Qt::Horizontal);
                     }
                 }
                 else
                 {
                     move(wheelSteps, Qt::Horizontal);
                 }
                 event->accept();
             }
             void VisualizationGraphWidget::mouseMoveEvent(QMouseEvent* event)
             {
                 if (impl->isDrawingZoomRect())
                 {
                     impl->updateZoomRect(event->pos());
                 }
                 else if (impl->isDrawingZoneRect())
                 {
                     impl->updateZoneRect(event->pos());
                 }
                 else if (event->buttons() == Qt::LeftButton)
                 {
                     if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::None)
                     {
                         auto [dx, dy] = impl->moveGraph(event->pos());
                         emit this->setrange_sig(this->graphRange(), true, false);
                     }
                     else if (sqpApp->plotsInteractionMode()
                         == SqpApplication::PlotsInteractionMode::SelectionZones)
                     {
                         auto posInPlot = this->impl->m_plot->mapFromParent(event->pos());
                         if (auto item = impl->m_plot->itemAt(posInPlot))
                         {
                             if (qobject_cast<VisualizationSelectionZoneItem*>(item))
                             {
                                 QMouseEvent e { QEvent::MouseMove, posInPlot, event->button(), event->buttons(),
                                     event->modifiers() };
                                 sqpApp->sendEvent(this->impl->m_plot, &e);
                                 this->impl->m_plot->replot(QCustomPlot::rpImmediateRefresh);
                             }
                         }
                     }
                 }
                 else
                 {
                     impl->m_RenderingDelegate->updateTooltip(event);
                 }
                 // event->accept();
                 QWidget::mouseMoveEvent(event);
             }
             void VisualizationGraphWidget::mouseReleaseEvent(QMouseEvent* event)
             {
                 if (impl->isDrawingZoomRect())
                 {
                     auto oldRange = this->graphRange();
                     impl->applyZoomRect();
                     auto newRange = this->graphRange();
                     if (auto tf = DateTimeRangeHelper::computeTransformation(oldRange, newRange))
                         emit this->transform_sig(tf.value(), false);
                 }
                 else if (impl->isDrawingZoneRect())
                 {
                     impl->endDrawingZone();
                 }
                 else
                 {
                     setCursor(Qt::ArrowCursor);
                 }
                 auto posInPlot = this->impl->m_plot->mapFromParent(event->pos());
                 if (auto item = impl->m_plot->itemAt(posInPlot))
                 {
                     if (qobject_cast<VisualizationSelectionZoneItem*>(item))
                     {
                         QMouseEvent e { QEvent::MouseButtonRelease, posInPlot, event->button(),
                             event->buttons(), event->modifiers() };
                         sqpApp->sendEvent(this->impl->m_plot, &e);
                     }
                 }
                 event->accept();
             }
             void VisualizationGraphWidget::mousePressEvent(QMouseEvent* event)
             {
                 if (event->button() == Qt::RightButton)
                 {
                     onGraphMenuRequested(event->pos());
                 }
                 else
                 {
                     auto selectedZone = impl->selectionZoneAt(event->pos());
                     switch (sqpApp->plotsInteractionMode())
                     {
                         case SqpApplication::PlotsInteractionMode::DragAndDrop:
                             break;
                         case SqpApplication::PlotsInteractionMode::SelectionZones:
                             impl->setSelectionZonesEditionEnabled(true);
                             if ((event->modifiers() == Qt::ControlModifier) && (selectedZone != nullptr))
                             {
                                 auto alreadySelectedZones
                                     = parentVisualizationWidget()->selectionZoneManager().selectedItems();
                                 selectedZone->setAssociatedEditedZones(alreadySelectedZones);
                                 if (SciQLop::containers::contains(alreadySelectedZones, selectedZone))
                                 {
                                     alreadySelectedZones.removeOne(selectedZone);
                                 }
                                 else
                                 {
                                     alreadySelectedZones.append(selectedZone);
                                 }
                                 parentVisualizationWidget()->selectionZoneManager().select(
                                     alreadySelectedZones);
                             }
                             else
                             {
                                 if (!selectedZone)
                                 {
                                     parentVisualizationWidget()->selectionZoneManager().clearSelection();
                                     impl->startDrawingZone(event->pos());
                                 }
                                 else
                                 {
                                     parentVisualizationWidget()->selectionZoneManager().select(
                                         { selectedZone });
                                 }
                             }
                             {
                                 auto posInPlot = this->impl->m_plot->mapFromParent(event->pos());
                                 if (auto item = impl->m_plot->itemAt(posInPlot))
                                 {
                                     if (qobject_cast<VisualizationSelectionZoneItem*>(item))
                                     {
                                         QMouseEvent e { QEvent::MouseButtonPress, posInPlot, event->button(),
                                             event->buttons(), event->modifiers() };
                                         sqpApp->sendEvent(this->impl->m_plot, &e);
                                     }
                                 }
                             }
                             break;
                         case SqpApplication::PlotsInteractionMode::ZoomBox:
                             impl->startDrawingRect(event->pos());
                             break;
                         default:
                             if (auto item = impl->m_plot->itemAt(event->pos()))
                             {
                                 emit impl->m_plot->itemClick(item, event);
                                 if (qobject_cast<VisualizationSelectionZoneItem*>(item))
                                 {
                                     setCursor(Qt::ClosedHandCursor);
                                     impl->enterPlotDrag(event->pos());
                                 }
                             }
                             else
                             {
                                 setCursor(Qt::ClosedHandCursor);
                                 impl->enterPlotDrag(event->pos());
                             }
                     }
                 }
                 // event->accept();
                 QWidget::mousePressEvent(event);
             }
             void VisualizationGraphWidget::mouseDoubleClickEvent(QMouseEvent* event)
             {
                 impl->m_RenderingDelegate->onMouseDoubleClick(event);
             }
             void VisualizationGraphWidget::keyReleaseEvent(QKeyEvent* event)
             {
                 switch (event->key())
                 {
                     case Qt::Key_Control:
                         event->accept();
                         break;
                     case Qt::Key_Shift:
                         event->accept();
                         break;
                     default:
                         QWidget::keyReleaseEvent(event);
                         break;
                 }
                 setCursor(Qt::ArrowCursor);
                 // event->accept();
             }
             void VisualizationGraphWidget::keyPressEvent(QKeyEvent* event)
             {
                 switch (event->key())
                 {
                     case Qt::Key_Control:
                         setCursor(Qt::CrossCursor);
                         break;
                     case Qt::Key_Shift:
                         break;
                     case Qt::Key_M:
                         impl->rescaleY();
                         impl->m_plot->replot(QCustomPlot::rpQueuedReplot);
                         break;
                     case Qt::Key_Left:
                         if (event->modifiers() != Qt::ControlModifier)
                         {
                             move(-0.1, Qt::Horizontal);
                         }
                         else
                         {
                             zoom(2, this->width() / 2, Qt::Horizontal);
                         }
                         break;
                     case Qt::Key_Right:
                         if (event->modifiers() != Qt::ControlModifier)
                         {
                             move(0.1, Qt::Horizontal);
                         }
                         else
                         {
                             zoom(0.5, this->width() / 2, Qt::Horizontal);
                         }
                         break;
                     case Qt::Key_Up:
                         if (event->modifiers() != Qt::ControlModifier)
                         {
                             move(0.1, Qt::Vertical);
                         }
                         else
                         {
                             zoom(0.5, this->height() / 2, Qt::Vertical);
                         }
                         break;
                     case Qt::Key_Down:
                         if (event->modifiers() != Qt::ControlModifier)
                         {
                             move(-0.1, Qt::Vertical);
                         }
                         else
                         {
                             zoom(2, this->height() / 2, Qt::Vertical);
                         }
                         break;
                     default:
                         QWidget::keyPressEvent(event);
                         break;
                 }
             }
             QCustomPlot& VisualizationGraphWidget::plot() const noexcept
             {
                 return *impl->m_plot;
             }
             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 (!impl->m_ZoomStack.isEmpty())
                 {
                     if (!graphMenu.isEmpty())
                     {
                         graphMenu.addSeparator();
                     }
                     graphMenu.addAction(tr("Undo Zoom"), [this]() { undoZoom(); });
                 }
                 // Selection Zone Actions
                 auto selectionZoneItem = impl->selectionZoneAt(pos);
                 if (selectionZoneItem)
                 {
                     auto selectedItems = parentVisualizationWidget()->selectionZoneManager().selectedItems();
                     selectedItems.removeAll(selectionZoneItem);
                     selectedItems.prepend(selectionZoneItem); // Put the current selection zone first
                     auto zoneActions = sqpApp->actionsGuiController().selectionZoneActions();
                     if (!zoneActions.isEmpty() && !graphMenu.isEmpty())
                     {
                         graphMenu.addSeparator();
                     }
                     QHash<QString, QMenu*> subMenus;
                     QHash<QString, bool> subMenusEnabled;
                     QHash<QString, FilteringAction*> filteredMenu;
                     for (auto zoneAction : zoneActions)
                     {
                         auto isEnabled = zoneAction->isEnabled(selectedItems);
                         auto menu = &graphMenu;
                         QString menuPath;
                         for (auto subMenuName : zoneAction->subMenuList())
                         {
                             menuPath += '/';
                             menuPath += subMenuName;
                             if (!subMenus.contains(menuPath))
                             {
                                 menu = menu->addMenu(subMenuName);
                                 subMenus[menuPath] = menu;
                                 subMenusEnabled[menuPath] = isEnabled;
                             }
                             else
                             {
                                 menu = subMenus.value(menuPath);
                                 if (isEnabled)
                                 {
                                     // The sub menu is enabled if at least one of its actions is enabled
                                     subMenusEnabled[menuPath] = true;
                                 }
                             }
                         }
                         FilteringAction* filterAction = nullptr;
                         if (sqpApp->actionsGuiController().isMenuFiltered(zoneAction->subMenuList()))
                         {
                             filterAction = filteredMenu.value(menuPath);
                             if (!filterAction)
                             {
                                 filterAction = new FilteringAction { this };
                                 filteredMenu[menuPath] = filterAction;
                                 menu->addAction(filterAction);
                             }
                         }
                         auto action = menu->addAction(zoneAction->name());
                         action->setEnabled(isEnabled);
                         action->setShortcut(zoneAction->displayedShortcut());
                         QObject::connect(action, &QAction::triggered,
                             [zoneAction, selectedItems]() { zoneAction->execute(selectedItems); });
                         if (filterAction && zoneAction->isFilteringAllowed())
                         {
                             filterAction->addActionToFilter(action);
                         }
                     }
                     for (auto it = subMenus.cbegin(); it != subMenus.cend(); ++it)
                     {
                         it.value()->setEnabled(subMenusEnabled[it.key()]);
                     }
                 }
                 if (!graphMenu.isEmpty())
                 {
                     graphMenu.exec(QCursor::pos());
                 }
             }
             void VisualizationGraphWidget::onMouseDoubleClick(QMouseEvent* event) noexcept
             {
                 impl->m_RenderingDelegate->onMouseDoubleClick(event);
             }
             void VisualizationGraphWidget::onMouseMove(QMouseEvent* event) noexcept
             {
                 // Handles plot rendering when mouse is moving
                 impl->m_RenderingDelegate->updateTooltip(event);
                 auto axisPos = impl->posToAxisPos(event->pos());
                 // Zoom box and zone drawing
                 if (impl->m_DrawingZoomRect)
                 {
                     impl->m_DrawingZoomRect->bottomRight->setCoords(axisPos);
                 }
                 else if (impl->m_DrawingZone)
                 {
                     impl->m_DrawingZone->setEnd(axisPos.x());
                 }
                 // Cursor
                 if (auto parentZone = parentZoneWidget())
                 {
                     if (impl->pointIsInAxisRect(axisPos, plot()))
                     {
                         parentZone->notifyMouseMoveInGraph(event->pos(), axisPos, this);
                     }
                     else
                     {
                         parentZone->notifyMouseLeaveGraph(this);
                     }
                 }
                 // Search for the selection zone under the mouse
                 auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos());
                 if (selectionZoneItemUnderCursor && !impl->m_DrawingZone
                     && sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones)
                 {
                     // Sets the appropriate cursor shape
                     auto cursorShape = selectionZoneItemUnderCursor->curshorShapeForPosition(event->pos());
                     setCursor(cursorShape);
                     // Manages the hovered zone
                     if (selectionZoneItemUnderCursor != impl->m_HoveredZone)
                     {
                         if (impl->m_HoveredZone)
                         {
                             impl->m_HoveredZone->setHovered(false);
                         }
                         selectionZoneItemUnderCursor->setHovered(true);
                         impl->m_HoveredZone = selectionZoneItemUnderCursor;
                         plot().replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 else
                 {
                     // There is no zone under the mouse or the interaction mode is not "selection zones"
                     if (impl->m_HoveredZone)
                     {
                         impl->m_HoveredZone->setHovered(false);
                         impl->m_HoveredZone = nullptr;
                     }
                     setCursor(Qt::ArrowCursor);
                 }
                 impl->m_HasMovedMouse = true;
                 VisualizationDragWidget::mouseMoveEvent(event);
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent* event) noexcept
             {
                 // Processes event only if the wheel occurs on axis rect
                 if (!dynamic_cast<QCPAxisRect*>(impl->m_plot->layoutElementAt(event->posF())))
                 {
                     return;
                 }
                 auto value = event->angleDelta().x() + event->angleDelta().y();
                 if (value != 0)
                 {
                     auto direction = value > 0 ? 1.0 : -1.0;
                     auto isZoomX = event->modifiers().testFlag(HORIZONTAL_ZOOM_MODIFIER);
                     auto isZoomY = event->modifiers().testFlag(VERTICAL_ZOOM_MODIFIER);
                     impl->m_IsCalibration = event->modifiers().testFlag(VERTICAL_PAN_MODIFIER);
                     auto zoomOrientations = QFlags<Qt::Orientation> {};
                     zoomOrientations.setFlag(Qt::Horizontal, isZoomX);
                     zoomOrientations.setFlag(Qt::Vertical, isZoomY);
                     impl->m_plot->axisRect()->setRangeZoom(zoomOrientations);
                     if (!isZoomX && !isZoomY)
                     {
                         auto axis = plot().axisRect()->axis(QCPAxis::atBottom);
                         auto diff = direction * (axis->range().size() * (PAN_SPEED / 100.0));
                         axis->setRange(axis->range() + diff);
                         if (plot().noAntialiasingOnDrag())
                         {
                             plot().setNotAntialiasedElements(QCP::aeAll);
                         }
                         // plot().replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
             }
             void VisualizationGraphWidget::onMousePress(QMouseEvent* event) noexcept
             {
                 auto isDragDropClick = event->modifiers().testFlag(DRAG_DROP_MODIFIER);
                 auto isSelectionZoneMode
                     = sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones;
                 auto isLeftClick = event->buttons().testFlag(Qt::LeftButton);
                 if (!isDragDropClick && isLeftClick)
                 {
                     if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::ZoomBox)
                     {
                         // Starts a zoom box
                         impl->startDrawingRect(event->pos());
                     }
                     else if (isSelectionZoneMode && impl->m_DrawingZone == nullptr)
                     {
                         // Starts a new selection zone
                         auto zoneAtPos = impl->selectionZoneAt(event->pos());
                         if (!zoneAtPos)
                         {
                             impl->startDrawingZone(event->pos());
                         }
                     }
                 }
                 // Allows zone edition only in selection zone mode without drag&drop
                 impl->setSelectionZonesEditionEnabled(isSelectionZoneMode && !isDragDropClick);
                 // Selection / Deselection
                 if (isSelectionZoneMode)
                 {
                     auto isMultiSelectionClick = event->modifiers().testFlag(MULTI_ZONE_SELECTION_MODIFIER);
                     auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos());
                     if (selectionZoneItemUnderCursor && !selectionZoneItemUnderCursor->selected()
                         && !isMultiSelectionClick)
                     {
                         parentVisualizationWidget()->selectionZoneManager().select(
                             { selectionZoneItemUnderCursor });
                     }
                     else if (!selectionZoneItemUnderCursor && !isMultiSelectionClick && isLeftClick)
                     {
                         parentVisualizationWidget()->selectionZoneManager().clearSelection();
                     }
                     else
                     {
                         // No selection change
                     }
                     if (selectionZoneItemUnderCursor && isLeftClick)
                     {
                         selectionZoneItemUnderCursor->setAssociatedEditedZones(
                             parentVisualizationWidget()->selectionZoneManager().selectedItems());
                     }
                 }
                 impl->m_HasMovedMouse = false;
                 VisualizationDragWidget::mousePressEvent(event);
             }
             void VisualizationGraphWidget::onMouseRelease(QMouseEvent* event) noexcept
             {
                 if (impl->m_DrawingZoomRect)
                 {
                     auto axisX = plot().axisRect()->axis(QCPAxis::atBottom);
                     auto axisY = plot().axisRect()->axis(QCPAxis::atLeft);
                     auto newAxisXRange = QCPRange { impl->m_DrawingZoomRect->topLeft->coords().x(),
                         impl->m_DrawingZoomRect->bottomRight->coords().x() };
                     auto newAxisYRange = QCPRange { impl->m_DrawingZoomRect->topLeft->coords().y(),
                         impl->m_DrawingZoomRect->bottomRight->coords().y() };
                     impl->removeDrawingRect();
                     if (newAxisXRange.size() > axisX->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0)
                         && newAxisYRange.size() > axisY->range().size() * (ZOOM_BOX_MIN_SIZE / 100.0))
                     {
                         impl->m_ZoomStack.push(qMakePair(axisX->range(), axisY->range()));
                         axisX->setRange(newAxisXRange);
                         axisY->setRange(newAxisYRange);
                         plot().replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
                 impl->endDrawingZone();
                 // Selection / Deselection
                 auto isSelectionZoneMode
                     = sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones;
                 if (isSelectionZoneMode)
                 {
                     auto isMultiSelectionClick = event->modifiers().testFlag(MULTI_ZONE_SELECTION_MODIFIER);
                     auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos());
                     if (selectionZoneItemUnderCursor && event->button() == Qt::LeftButton
                         && !impl->m_HasMovedMouse)
                     {
                         auto zonesUnderCursor = impl->selectionZonesAt(event->pos(), plot());
                         if (zonesUnderCursor.count() > 1)
                         {
                             // There are multiple zones under the mouse.
                             // Performs the selection with a selection dialog.
                             VisualizationMultiZoneSelectionDialog dialog { this };
                             dialog.setZones(zonesUnderCursor);
                             dialog.move(mapToGlobal(event->pos() - QPoint(dialog.width() / 2, 20)));
                             dialog.activateWindow();
                             dialog.raise();
                             if (dialog.exec() == QDialog::Accepted)
                             {
                                 auto selection = dialog.selectedZones();
                                 if (!isMultiSelectionClick)
                                 {
                                     parentVisualizationWidget()->selectionZoneManager().clearSelection();
                                 }
                                 for (auto it = selection.cbegin(); it != selection.cend(); ++it)
                                 {
                                     auto zone = it.key();
                                     auto isSelected = it.value();
                                     parentVisualizationWidget()->selectionZoneManager().setSelected(
                                         zone, isSelected);
                                     if (isSelected)
                                     {
                                         // Puts the zone on top of the stack so it can be moved or resized
                                         impl->moveSelectionZoneOnTop(zone, plot());
                                     }
                                 }
                             }
                         }
                         else
                         {
                             if (!isMultiSelectionClick)
                             {
                                 parentVisualizationWidget()->selectionZoneManager().select(
                                     { selectionZoneItemUnderCursor });
                                 impl->moveSelectionZoneOnTop(selectionZoneItemUnderCursor, plot());
                             }
                             else
                             {
                                 parentVisualizationWidget()->selectionZoneManager().setSelected(
                                     selectionZoneItemUnderCursor,
                                     !selectionZoneItemUnderCursor->selected()
                                         || event->button() == Qt::RightButton);
                             }
                         }
                     }
                     else
                     {
                         // No selection change
                     }
                 }
             }
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
                 auto graphRange = impl->m_plot->xAxis->range();
                 auto dateTime = DateTimeRange { graphRange.lower, graphRange.upper };
                 for (auto& variableEntry : impl->m_VariableToPlotMultiMap)
                 {
                     auto variable = variableEntry.first;
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
                     if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range()))
                     {
                         impl->updateData(variableEntry.second, variable, variable->range());
                     }
                 }
             }
             void VisualizationGraphWidget::onUpdateVarDisplaying(
                 std::shared_ptr<Variable2> variable, const DateTimeRange& range)
             {
                 auto it = impl->m_VariableToPlotMultiMap.find(variable);
                 if (it != impl->m_VariableToPlotMultiMap.end())
                 {
                     impl->updateData(it->second, variable, range);
                 }
             }
             void VisualizationGraphWidget::variableUpdated(QUuid id)
             {
                 for (auto& [var, plotables] : impl->m_VariableToPlotMultiMap)
                 {
                     if (var->ID() == id)
                     {
                         impl->updateData(plotables, var, this->graphRange());
                     }
                 }
             }
             void VisualizationGraphWidget::variableDeleted(const std::shared_ptr<Variable2>& variable)
             {
                 this->removeVariable(variable);
             }

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