From 90e991aec5fa6e6110ac4a973229a3892a72c00b 2017-10-25 14:31:39
From: Thibaud Rabillard <trabillard@itlink.fr>
Date: 2017-10-25 14:31:39
Subject: [PATCH] Format changes

---

diff --git a/gui/include/DragDropHelper.h b/gui/include/DragDropHelper.h
index d6b6284..95a9c45 100644
--- a/gui/include/DragDropHelper.h
+++ b/gui/include/DragDropHelper.h
@@ -1,5 +1,5 @@
-#ifndef DRAGDROPHELPER_H
-#define DRAGDROPHELPER_H
+#ifndef SCIQLOP_DRAGDROPHELPER_H
+#define SCIQLOP_DRAGDROPHELPER_H
 
 #include <Common/spimpl.h>
 #include <QWidget>
@@ -13,15 +13,14 @@ class QMimeData;
  * @brief Event filter class which manage the scroll of QScrollArea during a drag&drop operation.
  * @note A QScrollArea inside an other QScrollArea is not fully supported.
  */
-class DragDropScroller : public QObject
-{
+class DragDropScroller : public QObject {
     Q_OBJECT
 
 public:
-    DragDropScroller(QObject* parent = nullptr);
+    DragDropScroller(QObject *parent = nullptr);
 
-    void addScrollArea(QScrollArea* scrollArea);
-    void removeScrollArea(QScrollArea* scrollArea);
+    void addScrollArea(QScrollArea *scrollArea);
+    void removeScrollArea(QScrollArea *scrollArea);
 
 protected:
     bool eventFilter(QObject *obj, QEvent *event);
@@ -37,31 +36,30 @@ private slots:
 /**
  * @brief Helper class for drag&drop operations.
  */
-class DragDropHelper
-{
+class DragDropHelper {
 public:
-    DragDropHelper();
-    ~DragDropHelper();
-
     static const QString MIME_TYPE_GRAPH;
     static const QString MIME_TYPE_ZONE;
 
-    void setCurrentDragWidget(VisualizationDragWidget* dragWidget);
-    VisualizationDragWidget* getCurrentDragWidget() const;
+    DragDropHelper();
+    virtual ~DragDropHelper();
+
+    void setCurrentDragWidget(VisualizationDragWidget *dragWidget);
+    VisualizationDragWidget *getCurrentDragWidget() const;
 
     QWidget &placeHolder() const;
-    void insertPlaceHolder(QVBoxLayout* layout, int index);
+    void insertPlaceHolder(QVBoxLayout *layout, int index);
     void removePlaceHolder();
     bool isPlaceHolderSet() const;
 
-    void addDragDropScrollArea(QScrollArea* scrollArea);
-    void removeDragDropScrollArea(QScrollArea* scrollArea);
+    void addDragDropScrollArea(QScrollArea *scrollArea);
+    void removeDragDropScrollArea(QScrollArea *scrollArea);
 
-    QUrl imageTemporaryUrl(const QImage& image) const;
+    QUrl imageTemporaryUrl(const QImage &image) const;
 
 private:
     class DragDropHelperPrivate;
     spimpl::unique_impl_ptr<DragDropHelperPrivate> impl;
 };
 
-#endif // DRAGDROPHELPER_H
+#endif // SCIQLOP_DRAGDROPHELPER_H
diff --git a/gui/include/SqpApplication.h b/gui/include/SqpApplication.h
index d7049ba..1027e29 100644
--- a/gui/include/SqpApplication.h
+++ b/gui/include/SqpApplication.h
@@ -45,7 +45,7 @@ public:
     VariableController &variableController() noexcept;
     VisualizationController &visualizationController() noexcept;
 
-      /// Accessors for the differents sciqlop helpers
+    /// Accessors for the differents sciqlop helpers
     DragDropHelper &dragDropHelper() noexcept;
 
 private:
diff --git a/gui/include/Visualization/VisualizationDragDropContainer.h b/gui/include/Visualization/VisualizationDragDropContainer.h
index 5f9e9bd..8520c0c 100644
--- a/gui/include/Visualization/VisualizationDragDropContainer.h
+++ b/gui/include/Visualization/VisualizationDragDropContainer.h
@@ -1,28 +1,27 @@
 #ifndef VISUALIZATIONDRAGDROPCONTAINER_H
 #define VISUALIZATIONDRAGDROPCONTAINER_H
 
-#include <QWidget>
-#include <QVBoxLayout>
-#include <QMimeData>
 #include <Common/spimpl.h>
+#include <QMimeData>
+#include <QVBoxLayout>
+#include <QWidget>
 
 class VisualizationDragWidget;
 
-class VisualizationDragDropContainer : public QWidget
-{
+class VisualizationDragDropContainer : public QWidget {
     Q_OBJECT
 
 signals:
-    void dropOccured(int dropIndex, const QMimeData* mimeData);
+    void dropOccured(int dropIndex, const QMimeData *mimeData);
 
 public:
-    VisualizationDragDropContainer(QWidget* parent = nullptr);
+    VisualizationDragDropContainer(QWidget *parent = nullptr);
 
-    void addDragWidget(VisualizationDragWidget* dragWidget);
-    void insertDragWidget(int index, VisualizationDragWidget* dragWidget);
+    void addDragWidget(VisualizationDragWidget *dragWidget);
+    void insertDragWidget(int index, VisualizationDragWidget *dragWidget);
 
-    void setAcceptedMimeTypes(const QStringList& mimeTypes);
-    void setMergeAllowedMimeTypes(const QStringList& mimeTypes);
+    void setAcceptedMimeTypes(const QStringList &mimeTypes);
+    void setMergeAllowedMimeTypes(const QStringList &mimeTypes);
 
     int countDragWidget() const;
 
@@ -33,13 +32,11 @@ protected:
     void dropEvent(QDropEvent *event);
 
 private:
-
-
     class VisualizationDragDropContainerPrivate;
     spimpl::unique_impl_ptr<VisualizationDragDropContainerPrivate> impl;
 
 private slots:
-    void startDrag(VisualizationDragWidget* dragWidget, const QPoint& dragPosition);
+    void startDrag(VisualizationDragWidget *dragWidget, const QPoint &dragPosition);
 };
 
 #endif // VISUALIZATIONDRAGDROPCONTAINER_H
diff --git a/gui/include/Visualization/VisualizationDragWidget.h b/gui/include/Visualization/VisualizationDragWidget.h
index 46e038f..b723cb0 100644
--- a/gui/include/Visualization/VisualizationDragWidget.h
+++ b/gui/include/Visualization/VisualizationDragWidget.h
@@ -1,18 +1,17 @@
 #ifndef VISUALIZATIONDRAGWIDGET_H
 #define VISUALIZATIONDRAGWIDGET_H
 
-#include <QWidget>
-#include <QMimeData>
 #include <Common/spimpl.h>
+#include <QMimeData>
+#include <QWidget>
 
-class VisualizationDragWidget : public QWidget
-{
+class VisualizationDragWidget : public QWidget {
     Q_OBJECT
 
 public:
-    VisualizationDragWidget(QWidget* parent = nullptr);
+    VisualizationDragWidget(QWidget *parent = nullptr);
 
-    virtual QMimeData* mimeData() const = 0;
+    virtual QMimeData *mimeData() const = 0;
     virtual bool isDragAllowed() const = 0;
 
 protected:
@@ -24,7 +23,7 @@ private:
     spimpl::unique_impl_ptr<VisualizationDragWidgetPrivate> impl;
 
 signals:
-    void dragDetected(VisualizationDragWidget* dragWidget, const QPoint& dragPosition);
+    void dragDetected(VisualizationDragWidget *dragWidget, const QPoint &dragPosition);
 };
 
 #endif // VISUALIZATIONDRAGWIDGET_H
diff --git a/gui/include/Visualization/VisualizationGraphWidget.h b/gui/include/Visualization/VisualizationGraphWidget.h
index c8f0adc..b0e85c7 100644
--- a/gui/include/Visualization/VisualizationGraphWidget.h
+++ b/gui/include/Visualization/VisualizationGraphWidget.h
@@ -33,7 +33,7 @@ public:
     explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
     virtual ~VisualizationGraphWidget();
 
-    VisualizationZoneWidget* parentZoneWidget() const noexcept;
+    VisualizationZoneWidget *parentZoneWidget() const noexcept;
 
     /// If acquisition isn't enable, requestDataLoading signal cannot be emit
     void enableAcquisition(bool enable);
@@ -44,7 +44,7 @@ public:
     void removeVariable(std::shared_ptr<Variable> variable) noexcept;
 
     /// Returns the list of all variables used in the graph
-    QList<std::shared_ptr<Variable>> variables() const;
+    QList<std::shared_ptr<Variable> > variables() const;
 
     void setYRange(const SqpRange &range);
     SqpRange graphRange() const noexcept;
@@ -57,7 +57,7 @@ public:
     QString name() const override;
 
     // VisualisationDragWidget
-    QMimeData* mimeData() const override;
+    QMimeData *mimeData() const override;
     bool isDragAllowed() const override;
 
 signals:
diff --git a/gui/include/Visualization/VisualizationTabWidget.h b/gui/include/Visualization/VisualizationTabWidget.h
index 49a1769..4df7113 100644
--- a/gui/include/Visualization/VisualizationTabWidget.h
+++ b/gui/include/Visualization/VisualizationTabWidget.h
@@ -6,8 +6,8 @@
 #include <Common/spimpl.h>
 
 #include <QLoggingCategory>
-#include <QWidget>
 #include <QMimeData>
+#include <QWidget>
 
 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationTabWidget)
 
@@ -39,13 +39,14 @@ public:
     VisualizationZoneWidget *createZone(std::shared_ptr<Variable> variable);
 
     /**
-     * Creates a zone using a list of variables. The variables will be displayed in a new graph of the new
-     * zone. The zone is inserted at the specified index.
+     * Creates a zone using a list of variables. The variables will be displayed in a new graph of
+     * the new zone. The zone is inserted at the specified index.
      * @param variables the variables for which to create the zone
      * @param index The index where the zone should be inserted in the layout
      * @return the pointer to the created zone
      */
-    VisualizationZoneWidget *createZone(const QList<std::shared_ptr<Variable>>& variables, int index);
+    VisualizationZoneWidget *createZone(const QList<std::shared_ptr<Variable> > &variables,
+                                        int index);
 
     /**
      * Creates a zone which is empty (no variables). The zone is inserted at the specified index.
diff --git a/gui/include/Visualization/VisualizationZoneWidget.h b/gui/include/Visualization/VisualizationZoneWidget.h
index a2dac14..3700489 100644
--- a/gui/include/Visualization/VisualizationZoneWidget.h
+++ b/gui/include/Visualization/VisualizationZoneWidget.h
@@ -15,7 +15,7 @@ Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationZoneWidget)
 
 namespace Ui {
 class VisualizationZoneWidget;
-} // Ui
+} // namespace Ui
 
 class Variable;
 class VisualizationGraphWidget;
@@ -30,7 +30,7 @@ public:
     /// Adds a graph widget
     void addGraph(VisualizationGraphWidget *graphWidget);
 
-     /// Inserts a graph widget
+    /// Inserts a graph widget
     void insertGraph(int index, VisualizationGraphWidget *graphWidget);
 
     /**
@@ -57,7 +57,8 @@ public:
      * @param index The index where the graph should be inserted in the layout
      * @return the pointer to the created graph
      */
-    VisualizationGraphWidget *createGraph(const QList<std::shared_ptr<Variable>> variables, int index);
+    VisualizationGraphWidget *createGraph(const QList<std::shared_ptr<Variable> > variables,
+                                          int index);
 
     // IVisualizationWidget interface
     void accept(IVisualizationWidgetVisitor *visitor) override;
@@ -66,7 +67,7 @@ public:
     QString name() const override;
 
     // VisualisationDragWidget
-    QMimeData* mimeData() const override;
+    QMimeData *mimeData() const override;
     bool isDragAllowed() const override;
 
 protected:
@@ -83,7 +84,7 @@ private slots:
     /// Slot called when a variable is about to be removed from a graph contained in the zone
     void onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable);
 
-    void dropMimeData(int index, const QMimeData* mimeData);
+    void dropMimeData(int index, const QMimeData *mimeData);
 };
 
 #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H
diff --git a/gui/src/DragDropHelper.cpp b/gui/src/DragDropHelper.cpp
index b327352..c0568d8 100644
--- a/gui/src/DragDropHelper.cpp
+++ b/gui/src/DragDropHelper.cpp
@@ -1,14 +1,14 @@
 #include "DragDropHelper.h"
-#include "Visualization/VisualizationDragWidget.h"
 #include "SqpApplication.h"
+#include "Visualization/VisualizationDragWidget.h"
 
-#include <QDragMoveEvent>
+#include <QDir>
 #include <QDragEnterEvent>
-#include <QScrollBar>
+#include <QDragMoveEvent>
 #include <QScrollArea>
-#include <QVBoxLayout>
+#include <QScrollBar>
 #include <QTimer>
-#include <QDir>
+#include <QVBoxLayout>
 
 const QString DragDropHelper::MIME_TYPE_GRAPH = "scqlop/graph";
 const QString DragDropHelper::MIME_TYPE_ZONE = "scqlop/zone";
@@ -18,108 +18,97 @@ const int SCROLL_ZONE_SIZE = 50;
 
 struct DragDropScroller::DragDropScrollerPrivate {
 
-    QList<QScrollArea*> m_scrollAreas;
-    QScrollArea* m_currentScrollArea = nullptr;
-    std::unique_ptr<QTimer> m_timer = nullptr;
+    QList<QScrollArea *> m_ScrollAreas;
+    QScrollArea *m_CurrentScrollArea = nullptr;
+    std::unique_ptr<QTimer> m_Timer = nullptr;
 
 
-    enum class ScrollDirection {up, down, unknown};
-    ScrollDirection m_direction = ScrollDirection::unknown;
+    enum class ScrollDirection { up, down, unknown };
+    ScrollDirection m_Direction = ScrollDirection::unknown;
 
-    explicit DragDropScrollerPrivate()
-        : m_timer{std::make_unique<QTimer>()}
+    explicit DragDropScrollerPrivate() : m_Timer{std::make_unique<QTimer>()}
     {
-        m_timer->setInterval(0);
+        m_Timer->setInterval(0);
     }
 };
 
-DragDropScroller::DragDropScroller(QObject* parent)
-    : QObject{parent},  impl{spimpl::make_unique_impl<DragDropScrollerPrivate>()}
+DragDropScroller::DragDropScroller(QObject *parent)
+        : QObject{parent}, impl{spimpl::make_unique_impl<DragDropScrollerPrivate>()}
 {
-    connect(impl->m_timer.get(), &QTimer::timeout, this, &DragDropScroller::onTimer);
+    connect(impl->m_Timer.get(), &QTimer::timeout, this, &DragDropScroller::onTimer);
 }
 
-void DragDropScroller::addScrollArea(QScrollArea* scrollArea)
+void DragDropScroller::addScrollArea(QScrollArea *scrollArea)
 {
-    impl->m_scrollAreas << scrollArea;
+    impl->m_ScrollAreas << scrollArea;
     scrollArea->viewport()->setAcceptDrops(true);
 }
 
-void DragDropScroller::removeScrollArea(QScrollArea* scrollArea)
+void DragDropScroller::removeScrollArea(QScrollArea *scrollArea)
 {
-    impl->m_scrollAreas.removeAll(scrollArea);
+    impl->m_ScrollAreas.removeAll(scrollArea);
     scrollArea->viewport()->setAcceptDrops(false);
 }
 
 bool DragDropScroller::eventFilter(QObject *obj, QEvent *event)
 {
-    if (event->type() == QEvent::DragMove)
-    {
-        auto w = static_cast<QWidget*>(obj);
+    if (event->type() == QEvent::DragMove) {
+        auto w = static_cast<QWidget *>(obj);
 
-        if (impl->m_currentScrollArea && impl->m_currentScrollArea->isAncestorOf(w))
-        {
-            auto moveEvent = static_cast<QDragMoveEvent*>(event);
+        if (impl->m_CurrentScrollArea && impl->m_CurrentScrollArea->isAncestorOf(w)) {
+            auto moveEvent = static_cast<QDragMoveEvent *>(event);
 
             auto pos = moveEvent->pos();
-            if (impl->m_currentScrollArea->viewport() != w)
-            {
+            if (impl->m_CurrentScrollArea->viewport() != w) {
                 auto globalPos = w->mapToGlobal(moveEvent->pos());
-                pos = impl->m_currentScrollArea->viewport()->mapFromGlobal(globalPos);
+                pos = impl->m_CurrentScrollArea->viewport()->mapFromGlobal(globalPos);
             }
 
-            auto isInTopZone = pos.y() > impl->m_currentScrollArea->viewport()->size().height() - SCROLL_ZONE_SIZE;
+            auto isInTopZone = pos.y() > impl->m_CurrentScrollArea->viewport()->size().height()
+                                             - SCROLL_ZONE_SIZE;
             auto isInBottomZone = pos.y() < SCROLL_ZONE_SIZE;
 
-            if (!isInTopZone && !isInBottomZone)
-            {
-                impl->m_direction = DragDropScrollerPrivate::ScrollDirection::unknown;
-                impl->m_timer->stop();
+            if (!isInTopZone && !isInBottomZone) {
+                impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
+                impl->m_Timer->stop();
             }
-            else if (!impl->m_timer->isActive())
-            {
-                impl->m_direction = isInTopZone ? DragDropScrollerPrivate::ScrollDirection::up : DragDropScrollerPrivate::ScrollDirection::down;
-                impl->m_timer->start();
+            else if (!impl->m_Timer->isActive()) {
+                impl->m_Direction = isInTopZone ? DragDropScrollerPrivate::ScrollDirection::up
+                                                : DragDropScrollerPrivate::ScrollDirection::down;
+                impl->m_Timer->start();
             }
         }
     }
-    else if (event->type() == QEvent::DragEnter)
-    {
-        auto w = static_cast<QWidget*>(obj);
+    else if (event->type() == QEvent::DragEnter) {
+        auto w = static_cast<QWidget *>(obj);
 
-        for (auto scrollArea : impl-> m_scrollAreas)
-        {
-            if (impl->m_currentScrollArea != scrollArea && scrollArea->isAncestorOf(w))
-            {
-                auto enterEvent = static_cast<QDragEnterEvent*>(event);
+        for (auto scrollArea : impl->m_ScrollAreas) {
+            if (impl->m_CurrentScrollArea != scrollArea && scrollArea->isAncestorOf(w)) {
+                auto enterEvent = static_cast<QDragEnterEvent *>(event);
                 enterEvent->acceptProposedAction();
                 enterEvent->setDropAction(Qt::IgnoreAction);
-                impl->m_currentScrollArea = scrollArea;
+                impl->m_CurrentScrollArea = scrollArea;
                 break;
             }
         }
     }
-    else if (event->type() == QEvent::DragLeave)
-    {
-        auto w = static_cast<QWidget*>(obj);
-        if (impl->m_currentScrollArea)
-        {
-            if (!QRect(QPoint(), impl->m_currentScrollArea->size()).contains(impl->m_currentScrollArea->mapFromGlobal(QCursor::pos())))
-            {
-                impl->m_currentScrollArea = nullptr;
-                impl->m_direction = DragDropScrollerPrivate::ScrollDirection::unknown;
-                impl->m_timer->stop();
+    else if (event->type() == QEvent::DragLeave) {
+        auto w = static_cast<QWidget *>(obj);
+        if (impl->m_CurrentScrollArea) {
+            if (!QRect(QPoint(), impl->m_CurrentScrollArea->size())
+                     .contains(impl->m_CurrentScrollArea->mapFromGlobal(QCursor::pos()))) {
+                impl->m_CurrentScrollArea = nullptr;
+                impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
+                impl->m_Timer->stop();
             }
         }
     }
-    else if (event->type() == QEvent::Drop)
-    {
-        auto w = static_cast<QWidget*>(obj);
-        if (impl->m_currentScrollArea)
-        {
-            impl->m_currentScrollArea = nullptr;
-            impl->m_direction = DragDropScrollerPrivate::ScrollDirection::unknown;
-            impl->m_timer->stop();
+    else if (event->type() == QEvent::Drop) {
+        auto w = static_cast<QWidget *>(obj);
+        if (impl->m_CurrentScrollArea) {
+            impl->m_CurrentScrollArea = nullptr;
+            impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
+            impl->m_Timer->stop();
         }
     }
 
@@ -128,121 +117,114 @@ bool DragDropScroller::eventFilter(QObject *obj, QEvent *event)
 
 void DragDropScroller::onTimer()
 {
-    if (impl->m_currentScrollArea)
-    {
+    if (impl->m_CurrentScrollArea) {
         auto mvt = 0;
-        switch (impl->m_direction)
-        {
-        case DragDropScrollerPrivate::ScrollDirection::up:
-            mvt = SCROLL_SPEED;
-            break;
-        case DragDropScrollerPrivate::ScrollDirection::down:
-            mvt = -SCROLL_SPEED;
-            break;
-        default:
-            break;
+        switch (impl->m_Direction) {
+            case DragDropScrollerPrivate::ScrollDirection::up:
+                mvt = SCROLL_SPEED;
+                break;
+            case DragDropScrollerPrivate::ScrollDirection::down:
+                mvt = -SCROLL_SPEED;
+                break;
+            default:
+                break;
         }
 
-        impl->m_currentScrollArea->verticalScrollBar()->setValue(impl->m_currentScrollArea->verticalScrollBar()->value() + mvt);
+        impl->m_CurrentScrollArea->verticalScrollBar()->setValue(
+            impl->m_CurrentScrollArea->verticalScrollBar()->value() + mvt);
     }
 }
 
 struct DragDropHelper::DragDropHelperPrivate {
 
-    VisualizationDragWidget* m_currentDragWidget = nullptr;
-    std::unique_ptr<QWidget> m_placeHolder = nullptr;
-    std::unique_ptr<DragDropScroller> m_dragDropScroller = nullptr;
-    QString m_imageTempUrl; //Temporary file for image url generated by the drag & drop. Not using QTemporaryFile to have a name which is not generated.
+    VisualizationDragWidget *m_CurrentDragWidget = nullptr;
+    std::unique_ptr<QWidget> m_PlaceHolder = nullptr;
+    std::unique_ptr<DragDropScroller> m_DragDropScroller = nullptr;
+    QString m_ImageTempUrl; // Temporary file for image url generated by the drag & drop. Not using
+                            // QTemporaryFile to have a name which is not generated.
 
     explicit DragDropHelperPrivate()
-        : m_placeHolder{std::make_unique<QWidget>()},
-          m_dragDropScroller{std::make_unique<DragDropScroller>()}
+            : m_PlaceHolder{std::make_unique<QWidget>()},
+              m_DragDropScroller{std::make_unique<DragDropScroller>()}
     {
-         m_placeHolder->setStyleSheet("background-color: #BBD5EE; border:2px solid #2A7FD4");
-         sqpApp->installEventFilter(m_dragDropScroller.get());
+        m_PlaceHolder->setStyleSheet("background-color: #BBD5EE; border:2px solid #2A7FD4");
+        sqpApp->installEventFilter(m_DragDropScroller.get());
 
 
-         m_imageTempUrl = QDir::temp().absoluteFilePath("Scqlop_graph.png");
+        m_ImageTempUrl = QDir::temp().absoluteFilePath("Scqlop_graph.png");
     }
 
     void preparePlaceHolder() const
     {
-        if (m_currentDragWidget)
-        {
-            m_placeHolder->setMinimumSize(m_currentDragWidget->size());
-            m_placeHolder->setSizePolicy(m_currentDragWidget->sizePolicy());
+        if (m_CurrentDragWidget) {
+            m_PlaceHolder->setMinimumSize(m_CurrentDragWidget->size());
+            m_PlaceHolder->setSizePolicy(m_CurrentDragWidget->sizePolicy());
         }
-        else
-        {
-            m_placeHolder->setMinimumSize(200, 200);
+        else {
+            m_PlaceHolder->setMinimumSize(200, 200);
         }
     }
 };
 
 
-DragDropHelper::DragDropHelper() :
-    impl{spimpl::make_unique_impl<DragDropHelperPrivate>()}
-{
-}
+DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()} {}
 
 DragDropHelper::~DragDropHelper()
 {
-    QFile::remove(impl->m_imageTempUrl);
+    QFile::remove(impl->m_ImageTempUrl);
 }
 
 void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
 {
-    impl->m_currentDragWidget = dragWidget;
+    impl->m_CurrentDragWidget = dragWidget;
 }
 
 VisualizationDragWidget *DragDropHelper::getCurrentDragWidget() const
 {
-    return impl->m_currentDragWidget;
+    return impl->m_CurrentDragWidget;
 }
 
 
-QWidget& DragDropHelper::placeHolder() const
+QWidget &DragDropHelper::placeHolder() const
 {
-    return *impl->m_placeHolder;
+    return *impl->m_PlaceHolder;
 }
 
 void DragDropHelper::insertPlaceHolder(QVBoxLayout *layout, int index)
 {
     removePlaceHolder();
     impl->preparePlaceHolder();
-    layout->insertWidget(index, impl->m_placeHolder.get());
-    impl->m_placeHolder->show();
+    layout->insertWidget(index, impl->m_PlaceHolder.get());
+    impl->m_PlaceHolder->show();
 }
 
 void DragDropHelper::removePlaceHolder()
 {
-    auto parentWidget = impl->m_placeHolder->parentWidget();
-    if (parentWidget)
-    {
-        parentWidget->layout()->removeWidget(impl->m_placeHolder.get());
-        impl->m_placeHolder->setParent(nullptr);
-        impl->m_placeHolder->hide();
+    auto parentWidget = impl->m_PlaceHolder->parentWidget();
+    if (parentWidget) {
+        parentWidget->layout()->removeWidget(impl->m_PlaceHolder.get());
+        impl->m_PlaceHolder->setParent(nullptr);
+        impl->m_PlaceHolder->hide();
     }
 }
 
 bool DragDropHelper::isPlaceHolderSet() const
 {
-    return impl->m_placeHolder->parentWidget();
+    return impl->m_PlaceHolder->parentWidget();
 }
 
 void DragDropHelper::addDragDropScrollArea(QScrollArea *scrollArea)
 {
-   impl->m_dragDropScroller->addScrollArea(scrollArea);
+    impl->m_DragDropScroller->addScrollArea(scrollArea);
 }
 
 void DragDropHelper::removeDragDropScrollArea(QScrollArea *scrollArea)
 {
-    impl->m_dragDropScroller->removeScrollArea(scrollArea);
+    impl->m_DragDropScroller->removeScrollArea(scrollArea);
 }
 
-QUrl DragDropHelper::imageTemporaryUrl(const QImage& image) const
+QUrl DragDropHelper::imageTemporaryUrl(const QImage &image) const
 {
-    image.save(impl->m_imageTempUrl);
-    return QUrl::fromLocalFile(impl->m_imageTempUrl);
+    image.save(impl->m_ImageTempUrl);
+    return QUrl::fromLocalFile(impl->m_ImageTempUrl);
 }
-
diff --git a/gui/src/SqpApplication.cpp b/gui/src/SqpApplication.cpp
index 1187cc9..7eaec69 100644
--- a/gui/src/SqpApplication.cpp
+++ b/gui/src/SqpApplication.cpp
@@ -2,13 +2,13 @@
 
 #include <Data/IDataProvider.h>
 #include <DataSource/DataSourceController.h>
+#include <DragDropHelper.h>
 #include <Network/NetworkController.h>
 #include <QThread>
 #include <Time/TimeController.h>
 #include <Variable/Variable.h>
 #include <Variable/VariableController.h>
 #include <Visualization/VisualizationController.h>
-#include <DragDropHelper.h>
 
 Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
 
@@ -120,13 +120,9 @@ SqpApplication::SqpApplication(int &argc, char **argv)
     impl->m_VisualizationControllerThread.start();
 }
 
-SqpApplication::~SqpApplication()
-{
-}
+SqpApplication::~SqpApplication() {}
 
-void SqpApplication::initialize()
-{
-}
+void SqpApplication::initialize() {}
 
 DataSourceController &SqpApplication::dataSourceController() noexcept
 {
diff --git a/gui/src/Visualization/VisualizationDragDropContainer.cpp b/gui/src/Visualization/VisualizationDragDropContainer.cpp
index 8d199b9..0775b94 100644
--- a/gui/src/Visualization/VisualizationDragDropContainer.cpp
+++ b/gui/src/Visualization/VisualizationDragDropContainer.cpp
@@ -1,43 +1,43 @@
 #include "Visualization/VisualizationDragDropContainer.h"
-#include "Visualization/VisualizationDragWidget.h"
-#include "SqpApplication.h"
 #include "DragDropHelper.h"
+#include "SqpApplication.h"
+#include "Visualization/VisualizationDragWidget.h"
 
 #include <QDrag>
-#include <QVBoxLayout>
 #include <QDragEnterEvent>
+#include <QVBoxLayout>
 
 #include <memory>
 
 struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
 
-    QVBoxLayout* m_layout;
-    QStringList m_acceptedMimeTypes;
-    QStringList m_mergeAllowedMimeTypes;
+    QVBoxLayout *m_Layout;
+    QStringList m_AcceptedMimeTypes;
+    QStringList m_MergeAllowedMimeTypes;
 
-    explicit VisualizationDragDropContainerPrivate(QWidget* widget)
+    explicit VisualizationDragDropContainerPrivate(QWidget *widget)
     {
-        m_layout  = new QVBoxLayout(widget);
-        m_layout->setContentsMargins(0,0,0,0);
+        m_Layout = new QVBoxLayout(widget);
+        m_Layout->setContentsMargins(0, 0, 0, 0);
     }
 
-    bool acceptMimeData(const QMimeData* data) const
+    bool acceptMimeData(const QMimeData *data) const
     {
-        for (const auto& type : m_acceptedMimeTypes)
-        {
-            if (data->hasFormat(type))
+        for (const auto &type : m_AcceptedMimeTypes) {
+            if (data->hasFormat(type)) {
                 return true;
+            }
         }
 
         return false;
     }
 
-    bool allowMergeMimeData(const QMimeData* data) const
+    bool allowMergeMimeData(const QMimeData *data) const
     {
-        for (const auto& type : m_mergeAllowedMimeTypes)
-        {
-            if (data->hasFormat(type))
+        for (const auto &type : m_MergeAllowedMimeTypes) {
+            if (data->hasFormat(type)) {
                 return true;
+            }
         }
 
         return false;
@@ -45,20 +45,17 @@ struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
 
     bool hasPlaceHolder() const
     {
-        return sqpApp->dragDropHelper().placeHolder().parentWidget() == m_layout->parentWidget();
+        return sqpApp->dragDropHelper().placeHolder().parentWidget() == m_Layout->parentWidget();
     }
 
-    VisualizationDragWidget* getChildDragWidgetAt(QWidget* parent, const QPoint &pos) const
+    VisualizationDragWidget *getChildDragWidgetAt(QWidget *parent, const QPoint &pos) const
     {
-        VisualizationDragWidget* dragWidget = nullptr;
-
-        for (auto child : parent->children())
-        {
-            auto widget = qobject_cast<VisualizationDragWidget*>(child);
-            if (widget && widget->isVisible())
-            {
-                if (widget->frameGeometry().contains(pos))
-                {
+        VisualizationDragWidget *dragWidget = nullptr;
+
+        for (auto child : parent->children()) {
+            auto widget = qobject_cast<VisualizationDragWidget *>(child);
+            if (widget && widget->isVisible()) {
+                if (widget->frameGeometry().contains(pos)) {
                     dragWidget = widget;
                     break;
                 }
@@ -68,54 +65,56 @@ struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
         return dragWidget;
     }
 
-    bool cursorIsInContainer(QWidget* container) const
+    bool cursorIsInContainer(QWidget *container) const
     {
-        auto adustNum = 18; //to be safe, in case of scrollbar on the side
-        auto containerRect = QRect(QPoint(), container->contentsRect().size()).adjusted(adustNum, adustNum, -adustNum, -adustNum);
+        auto adustNum = 18; // to be safe, in case of scrollbar on the side
+        auto containerRect = QRect(QPoint(), container->contentsRect().size())
+                                 .adjusted(adustNum, adustNum, -adustNum, -adustNum);
         qDebug() << containerRect << container->mapFromGlobal(QCursor::pos());
         return containerRect.contains(container->mapFromGlobal(QCursor::pos()));
     }
-
 };
 
 VisualizationDragDropContainer::VisualizationDragDropContainer(QWidget *parent)
-    : QWidget{parent}, impl{spimpl::make_unique_impl<VisualizationDragDropContainerPrivate>(this)}
+        : QWidget{parent},
+          impl{spimpl::make_unique_impl<VisualizationDragDropContainerPrivate>(this)}
 {
     setAcceptDrops(true);
 }
 
 void VisualizationDragDropContainer::addDragWidget(VisualizationDragWidget *dragWidget)
 {
-    impl->m_layout->addWidget(dragWidget);
+    impl->m_Layout->addWidget(dragWidget);
     disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
-    connect(dragWidget, &VisualizationDragWidget::dragDetected, this, &VisualizationDragDropContainer::startDrag);
+    connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
+            &VisualizationDragDropContainer::startDrag);
 }
 
-void VisualizationDragDropContainer::insertDragWidget(int index, VisualizationDragWidget *dragWidget)
+void VisualizationDragDropContainer::insertDragWidget(int index,
+                                                      VisualizationDragWidget *dragWidget)
 {
-    impl->m_layout->insertWidget(index, dragWidget);
+    impl->m_Layout->insertWidget(index, dragWidget);
     disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
-    connect(dragWidget, &VisualizationDragWidget::dragDetected, this, &VisualizationDragDropContainer::startDrag);
+    connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
+            &VisualizationDragDropContainer::startDrag);
 }
 
 void VisualizationDragDropContainer::setAcceptedMimeTypes(const QStringList &mimeTypes)
 {
-    impl->m_acceptedMimeTypes = mimeTypes;
+    impl->m_AcceptedMimeTypes = mimeTypes;
 }
 
 void VisualizationDragDropContainer::setMergeAllowedMimeTypes(const QStringList &mimeTypes)
 {
-    impl->m_mergeAllowedMimeTypes = mimeTypes;
+    impl->m_MergeAllowedMimeTypes = mimeTypes;
 }
 
 int VisualizationDragDropContainer::countDragWidget() const
 {
     auto nbGraph = 0;
-    for (auto child : children())
-    {
-        auto widget = qobject_cast<VisualizationDragWidget*>(child);
-        if (widget)
-        {
+    for (auto child : children()) {
+        auto widget = qobject_cast<VisualizationDragWidget *>(child);
+        if (widget) {
             nbGraph += 1;
         }
     }
@@ -123,11 +122,12 @@ int VisualizationDragDropContainer::countDragWidget() const
     return nbGraph;
 }
 
-void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidget, const QPoint &dragPosition)
+void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidget,
+                                               const QPoint &dragPosition)
 {
-    auto& helper = sqpApp->dragDropHelper();
+    auto &helper = sqpApp->dragDropHelper();
 
-    //Note: The management of the drag object is done by Qt
+    // Note: The management of the drag object is done by Qt
     auto *drag = new QDrag{dragWidget};
     drag->setHotSpot(dragPosition);
 
@@ -142,53 +142,49 @@ void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidg
     mimeData->setImageData(image);
     mimeData->setUrls({helper.imageTemporaryUrl(image)});
 
-    if (impl->m_layout->indexOf(dragWidget) >= 0)
-    {
+    if (impl->m_Layout->indexOf(dragWidget) >= 0) {
         helper.setCurrentDragWidget(dragWidget);
 
-        if (impl->cursorIsInContainer(this))
-        {
-            auto dragWidgetIndex = impl->m_layout->indexOf(dragWidget);
-            helper.insertPlaceHolder(impl->m_layout, dragWidgetIndex);
+        if (impl->cursorIsInContainer(this)) {
+            auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
+            helper.insertPlaceHolder(impl->m_Layout, dragWidgetIndex);
             dragWidget->setVisible(false);
         }
     }
 
-    //Note: The exec() is blocking on windows but not on linux and macOS
+    // Note: The exec() is blocking on windows but not on linux and macOS
     drag->exec(Qt::MoveAction | Qt::CopyAction);
 }
 
 void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
 {
-    if (impl->acceptMimeData(event->mimeData()))
-    {
+    if (impl->acceptMimeData(event->mimeData())) {
         event->acceptProposedAction();
 
-        auto& helper = sqpApp->dragDropHelper();
+        auto &helper = sqpApp->dragDropHelper();
 
-        if (!impl->hasPlaceHolder())
-        {      
+        if (!impl->hasPlaceHolder()) {
             auto dragWidget = helper.getCurrentDragWidget();
-            auto parentWidget = qobject_cast<VisualizationDragDropContainer*>(dragWidget->parentWidget());
-            if (parentWidget)
-            {
+            auto parentWidget
+                = qobject_cast<VisualizationDragDropContainer *>(dragWidget->parentWidget());
+            if (parentWidget) {
                 dragWidget->setVisible(false);
             }
 
             auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
 
-            if (dragWidgetHovered)
-            {
-                auto hoveredWidgetIndex = impl->m_layout->indexOf(dragWidgetHovered);
-                auto dragWidgetIndex = impl->m_layout->indexOf(helper.getCurrentDragWidget());
-                if (dragWidgetIndex >= 0 && dragWidgetIndex <= hoveredWidgetIndex)
-                    hoveredWidgetIndex += 1; //Correction of the index if the drop occurs in the same container
+            if (dragWidgetHovered) {
+                auto hoveredWidgetIndex = impl->m_Layout->indexOf(dragWidgetHovered);
+                auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
+                if (dragWidgetIndex >= 0 && dragWidgetIndex <= hoveredWidgetIndex) {
+                    hoveredWidgetIndex
+                        += 1; // Correction of the index if the drop occurs in the same container
+                }
 
-                helper.insertPlaceHolder(impl->m_layout, hoveredWidgetIndex);
+                helper.insertPlaceHolder(impl->m_Layout, hoveredWidgetIndex);
             }
-            else
-            {
-                helper.insertPlaceHolder(impl->m_layout, 0);
+            else {
+                helper.insertPlaceHolder(impl->m_Layout, 0);
             }
         }
     }
@@ -202,23 +198,20 @@ void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
 {
     Q_UNUSED(event);
 
-    auto& helper = sqpApp->dragDropHelper();
+    auto &helper = sqpApp->dragDropHelper();
 
-    if (!impl->cursorIsInContainer(this))
-    {
+    if (!impl->cursorIsInContainer(this)) {
         helper.removePlaceHolder();
 
         bool isInternal = true;
-        if (isInternal)
-        {
-            //Only if the drag is strated from the visualization
-            //Show the drag widget at its original place
-            //So the drag widget doesn't stay hidden if the drop occurs outside the visualization drop zone
-            //(It is not possible to catch a drop event outside of the application)
+        if (isInternal) {
+            // Only if the drag is strated from the visualization
+            // Show the drag widget at its original place
+            // So the drag widget doesn't stay hidden if the drop occurs outside the visualization
+            // drop zone (It is not possible to catch a drop event outside of the application)
 
             auto dragWidget = sqpApp->dragDropHelper().getCurrentDragWidget();
-            if (dragWidget)
-            {
+            if (dragWidget) {
                 dragWidget->setVisible(true);
             }
         }
@@ -229,16 +222,13 @@ void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
 
 void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
 {
-    if (impl->acceptMimeData(event->mimeData()))
-    {
+    if (impl->acceptMimeData(event->mimeData())) {
         auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
-        if (dragWidgetHovered)
-        {
+        if (dragWidgetHovered) {
             auto canMerge = impl->allowMergeMimeData(event->mimeData());
 
             auto nbDragWidget = countDragWidget();
-            if (nbDragWidget > 0)
-            {
+            if (nbDragWidget > 0) {
                 auto graphHeight = size().height() / nbDragWidget;
                 auto dropIndex = floor(event->pos().y() / graphHeight);
                 auto zoneSize = qMin(graphHeight / 3.0, 150.0);
@@ -246,28 +236,27 @@ void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
                 auto isOnTop = event->pos().y() < dropIndex * graphHeight + zoneSize;
                 auto isOnBottom = event->pos().y() > (dropIndex + 1) * graphHeight - zoneSize;
 
-                auto& helper = sqpApp->dragDropHelper();
-                auto placeHolderIndex = impl->m_layout->indexOf(&(helper.placeHolder()));
+                auto &helper = sqpApp->dragDropHelper();
+                auto placeHolderIndex = impl->m_Layout->indexOf(&(helper.placeHolder()));
 
-                if (isOnTop || isOnBottom)
-                {
-                    if (isOnBottom)
+                if (isOnTop || isOnBottom) {
+                    if (isOnBottom) {
                         dropIndex += 1;
+                    }
 
-                    auto dragWidgetIndex = impl->m_layout->indexOf(helper.getCurrentDragWidget());
-                    if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex)
-                        dropIndex += 1; //Correction of the index if the drop occurs in the same container
+                    auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
+                    if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
+                        dropIndex += 1; // Correction of the index if the drop occurs in the same
+                                        // container
+                    }
 
-                    if (dropIndex != placeHolderIndex)
-                    {
-                        helper.insertPlaceHolder(impl->m_layout, dropIndex);
+                    if (dropIndex != placeHolderIndex) {
+                        helper.insertPlaceHolder(impl->m_Layout, dropIndex);
                     }
                 }
-                else if (canMerge)
-                {
-                    //drop on the middle -> merge
-                    if (impl->hasPlaceHolder())
-                    {
+                else if (canMerge) {
+                    // drop on the middle -> merge
+                    if (impl->hasPlaceHolder()) {
                         helper.removePlaceHolder();
                     }
                 }
@@ -282,18 +271,18 @@ void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
 
 void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
 {
-    if (impl->acceptMimeData(event->mimeData()))
-    {
+    if (impl->acceptMimeData(event->mimeData())) {
         auto dragWidget = sqpApp->dragDropHelper().getCurrentDragWidget();
-        if (impl->hasPlaceHolder() && dragWidget)
-        {
-            auto& helper = sqpApp->dragDropHelper();
+        if (impl->hasPlaceHolder() && dragWidget) {
+            auto &helper = sqpApp->dragDropHelper();
 
-            auto droppedIndex = impl->m_layout->indexOf(&helper.placeHolder());
+            auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
 
-            auto dragWidgetIndex = impl->m_layout->indexOf(dragWidget);
-            if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex)
-                droppedIndex -= 1; //Correction of the index if the drop occurs in the same container
+            auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
+            if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
+                droppedIndex
+                    -= 1; // Correction of the index if the drop occurs in the same container
+            }
 
             dragWidget->setVisible(true);
             dragWidget->setStyleSheet("");
diff --git a/gui/src/Visualization/VisualizationDragWidget.cpp b/gui/src/Visualization/VisualizationDragWidget.cpp
index 0784704..57f7074 100644
--- a/gui/src/Visualization/VisualizationDragWidget.cpp
+++ b/gui/src/Visualization/VisualizationDragWidget.cpp
@@ -1,50 +1,53 @@
 #include "Visualization/VisualizationDragWidget.h"
 #include "Visualization/VisualizationDragDropContainer.h"
 
-#include <QMouseEvent>
 #include <QApplication>
+#include <QMouseEvent>
 
 struct VisualizationDragWidget::VisualizationDragWidgetPrivate {
 
-    QPoint m_dragStartPosition;
-    bool m_dragStartPositionValid = false;
+    QPoint m_DragStartPosition;
+    bool m_DragStartPositionValid = false;
 
-    explicit VisualizationDragWidgetPrivate()
-    {
-    }
+    explicit VisualizationDragWidgetPrivate() {}
 };
 
-VisualizationDragWidget::VisualizationDragWidget(QWidget* parent)
-    : QWidget{parent}, impl{spimpl::make_unique_impl<VisualizationDragWidgetPrivate>()}
+VisualizationDragWidget::VisualizationDragWidget(QWidget *parent)
+        : QWidget{parent}, impl{spimpl::make_unique_impl<VisualizationDragWidgetPrivate>()}
 {
-
 }
 
 void VisualizationDragWidget::mousePressEvent(QMouseEvent *event)
 {
-    if (event->button() == Qt::LeftButton)
-        impl->m_dragStartPosition = event->pos();
+    if (event->button() == Qt::LeftButton) {
+        impl->m_DragStartPosition = event->pos();
+    }
 
-    impl->m_dragStartPositionValid = isDragAllowed();
+    impl->m_DragStartPositionValid = isDragAllowed();
 
     QWidget::mousePressEvent(event);
 }
 
 void VisualizationDragWidget::mouseMoveEvent(QMouseEvent *event)
 {
-    if (!impl->m_dragStartPositionValid || !isDragAllowed())
+    if (!impl->m_DragStartPositionValid || !isDragAllowed()) {
         return;
+    }
 
-    if (!(event->buttons() & Qt::LeftButton))
+    if (!(event->buttons() & Qt::LeftButton)) {
         return;
+    }
 
-    if (!event->modifiers().testFlag(Qt::AltModifier))
+    if (!event->modifiers().testFlag(Qt::AltModifier)) {
         return;
+    }
 
-    if ((event->pos() - impl->m_dragStartPosition).manhattanLength() < QApplication::startDragDistance())
+    if ((event->pos() - impl->m_DragStartPosition).manhattanLength()
+        < QApplication::startDragDistance()) {
         return;
+    }
 
-    emit dragDetected(this, impl->m_dragStartPosition);
+    emit dragDetected(this, impl->m_DragStartPosition);
 
     QWidget::mouseMoveEvent(event);
 }
diff --git a/gui/src/Visualization/VisualizationGraphWidget.cpp b/gui/src/Visualization/VisualizationGraphWidget.cpp
index a0f598e..107c70e 100644
--- a/gui/src/Visualization/VisualizationGraphWidget.cpp
+++ b/gui/src/Visualization/VisualizationGraphWidget.cpp
@@ -8,9 +8,9 @@
 
 #include <Data/ArrayData.h>
 #include <Data/IDataSeries.h>
+#include <DragDropHelper.h>
 #include <Settings/SqpSettingsDefs.h>
 #include <SqpApplication.h>
-#include <DragDropHelper.h>
 #include <Variable/Variable.h>
 #include <Variable/VariableController.h>
 
@@ -72,9 +72,10 @@ VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget 
             &VisualizationGraphWidget::onMouseRelease);
     connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
     connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
-    connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
-                                   &QCPAxis::rangeChanged),
-            this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
+    connect(
+        ui->widget->xAxis,
+        static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(&QCPAxis::rangeChanged),
+        this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
 
     // Activates menu when right clicking on the graph
     ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
@@ -97,12 +98,11 @@ VisualizationGraphWidget::~VisualizationGraphWidget()
 VisualizationZoneWidget *VisualizationGraphWidget::parentZoneWidget() const noexcept
 {
     auto parent = parentWidget();
-    do
-    {
+    do {
         parent = parent->parentWidget();
-    } while (parent != nullptr && !qobject_cast<VisualizationZoneWidget*>(parent));
+    } while (parent != nullptr && !qobject_cast<VisualizationZoneWidget *>(parent));
 
-    return qobject_cast<VisualizationZoneWidget*>(parent);
+    return qobject_cast<VisualizationZoneWidget *>(parent);
 }
 
 void VisualizationGraphWidget::enableAcquisition(bool enable)
@@ -165,11 +165,11 @@ void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable
     ui->widget->replot();
 }
 
-QList<std::shared_ptr<Variable>> VisualizationGraphWidget::variables() const
+QList<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
 {
-    auto variables = QList<std::shared_ptr<Variable>>{};
-    for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap); it != std::cend(impl->m_VariableToPlotMultiMap); ++it)
-    {
+    auto variables = QList<std::shared_ptr<Variable> >{};
+    for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap);
+         it != std::cend(impl->m_VariableToPlotMultiMap); ++it) {
         variables << it->first;
     }
 
@@ -232,10 +232,10 @@ QString VisualizationGraphWidget::name() const
 
 QMimeData *VisualizationGraphWidget::mimeData() const
 {
-     auto *mimeData = new QMimeData;
-     mimeData->setData(DragDropHelper::MIME_TYPE_GRAPH, QByteArray());
+    auto *mimeData = new QMimeData;
+    mimeData->setData(DragDropHelper::MIME_TYPE_GRAPH, QByteArray());
 
-     return mimeData;
+    return mimeData;
 }
 
 bool VisualizationGraphWidget::isDragAllowed() const
@@ -290,9 +290,9 @@ void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
 
 void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
 {
-    qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
-                                            << QThread::currentThread()->objectName() << "DoAcqui"
-                                            << impl->m_DoAcquisition;
+    qCDebug(LOG_VisualizationGraphWidget())
+        << tr("TORM: VisualizationGraphWidget::onRangeChanged")
+        << QThread::currentThread()->objectName() << "DoAcqui" << impl->m_DoAcquisition;
 
     auto graphRange = SqpRange{t1.lower, t1.upper};
     auto oldGraphRange = SqpRange{t2.lower, t2.upper};
diff --git a/gui/src/Visualization/VisualizationTabWidget.cpp b/gui/src/Visualization/VisualizationTabWidget.cpp
index 148fbcb..15f61b2 100644
--- a/gui/src/Visualization/VisualizationTabWidget.cpp
+++ b/gui/src/Visualization/VisualizationTabWidget.cpp
@@ -2,13 +2,13 @@
 #include "Visualization/IVisualizationWidgetVisitor.h"
 #include "ui_VisualizationTabWidget.h"
 
-#include "Visualization/VisualizationZoneWidget.h"
 #include "Visualization/VisualizationGraphWidget.h"
+#include "Visualization/VisualizationZoneWidget.h"
 
 #include "Variable/VariableController.h"
 
-#include "SqpApplication.h"
 #include "DragDropHelper.h"
+#include "SqpApplication.h"
 
 Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
 
@@ -61,8 +61,10 @@ VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *par
 {
     ui->setupUi(this);
 
-    ui->dragDropContainer->setAcceptedMimeTypes({DragDropHelper::MIME_TYPE_GRAPH, DragDropHelper::MIME_TYPE_ZONE});
-    connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this, &VisualizationTabWidget::dropMimeData);
+    ui->dragDropContainer->setAcceptedMimeTypes(
+        {DragDropHelper::MIME_TYPE_GRAPH, DragDropHelper::MIME_TYPE_ZONE});
+    connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this,
+            &VisualizationTabWidget::dropMimeData);
     sqpApp->dragDropHelper().addDragDropScrollArea(ui->scrollArea);
 
     // Widget is deleted when closed
@@ -82,7 +84,7 @@ void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
 
 void VisualizationTabWidget::insertZone(int index, VisualizationZoneWidget *zoneWidget)
 {
-     ui->dragDropContainer->insertDragWidget(index, zoneWidget);
+    ui->dragDropContainer->insertDragWidget(index, zoneWidget);
 }
 
 VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
@@ -90,7 +92,8 @@ VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Vari
     return createZone({variable}, -1);
 }
 
-VisualizationZoneWidget *VisualizationTabWidget::createZone(const QList<std::shared_ptr<Variable> > &variables, int index)
+VisualizationZoneWidget *
+VisualizationTabWidget::createZone(const QList<std::shared_ptr<Variable> > &variables, int index)
 {
     auto zoneWidget = createEmptyZone(index);
 
@@ -102,7 +105,8 @@ VisualizationZoneWidget *VisualizationTabWidget::createZone(const QList<std::sha
 
 VisualizationZoneWidget *VisualizationTabWidget::createEmptyZone(int index)
 {
-    auto zoneWidget = new VisualizationZoneWidget{defaultZoneName(*ui->dragDropContainer->layout()), this};
+    auto zoneWidget
+        = new VisualizationZoneWidget{defaultZoneName(*ui->dragDropContainer->layout()), this};
     this->insertZone(index, zoneWidget);
 
     return zoneWidget;
@@ -158,42 +162,38 @@ QLayout &VisualizationTabWidget::tabLayout() const noexcept
 
 void VisualizationTabWidget::dropMimeData(int index, const QMimeData *mimeData)
 {
-    auto& helper = sqpApp->dragDropHelper();
-    if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_GRAPH))
-    {
-        auto graphWidget = static_cast<VisualizationGraphWidget*>(helper.getCurrentDragWidget());
-        auto parentDragDropContainer = qobject_cast<VisualizationDragDropContainer*>(graphWidget->parentWidget());
+    auto &helper = sqpApp->dragDropHelper();
+    if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_GRAPH)) {
+        auto graphWidget = static_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
+        auto parentDragDropContainer
+            = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
         Q_ASSERT(parentDragDropContainer);
 
         auto nbGraph = parentDragDropContainer->countDragWidget();
 
-        const auto& variables = graphWidget->variables();
+        const auto &variables = graphWidget->variables();
 
-        if (!variables.isEmpty())
-        {
-            //Abort the requests for the variables (if any)
-            //Commented, because it's not sure if it's needed or not
-            //for (const auto& var : variables)
+        if (!variables.isEmpty()) {
+            // Abort the requests for the variables (if any)
+            // Commented, because it's not sure if it's needed or not
+            // for (const auto& var : variables)
             //{
             //    sqpApp->variableController().onAbortProgressRequested(var);
             //}
 
-            if (nbGraph == 1)
-            {
-                //This is the only graph in the previous zone, close the zone
+            if (nbGraph == 1) {
+                // This is the only graph in the previous zone, close the zone
                 graphWidget->parentZoneWidget()->close();
             }
-            else
-            {
-                //Close the graph
+            else {
+                // Close the graph
                 graphWidget->close();
             }
 
             createZone(variables, index);
         }
-        else
-        {
-            //The graph is empty, create an empty zone and move the graph inside
+        else {
+            // The graph is empty, create an empty zone and move the graph inside
 
             auto parentZoneWidget = graphWidget->parentZoneWidget();
 
@@ -202,15 +202,15 @@ void VisualizationTabWidget::dropMimeData(int index, const QMimeData *mimeData)
             auto zoneWidget = createEmptyZone(index);
             zoneWidget->addGraph(graphWidget);
 
-            //Close the old zone if it was the only graph inside
-            if (nbGraph == 1)
+            // Close the old zone if it was the only graph inside
+            if (nbGraph == 1) {
                 parentZoneWidget->close();
+            }
         }
     }
-    else if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_ZONE))
-    {
-        //Simple move of the zone, no variable operation associated
-        auto zoneWidget = static_cast<VisualizationZoneWidget*>(helper.getCurrentDragWidget());
+    else if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_ZONE)) {
+        // Simple move of the zone, no variable operation associated
+        auto zoneWidget = static_cast<VisualizationZoneWidget *>(helper.getCurrentDragWidget());
         auto parentDragDropContainer = zoneWidget->parentWidget();
         parentDragDropContainer->layout()->removeWidget(zoneWidget);
 
diff --git a/gui/src/Visualization/VisualizationZoneWidget.cpp b/gui/src/Visualization/VisualizationZoneWidget.cpp
index 3cb3499..dc96673 100644
--- a/gui/src/Visualization/VisualizationZoneWidget.cpp
+++ b/gui/src/Visualization/VisualizationZoneWidget.cpp
@@ -9,9 +9,9 @@
 #include <Variable/Variable.h>
 #include <Variable/VariableController.h>
 
+#include <DragDropHelper.h>
 #include <QUuid>
 #include <SqpApplication.h>
-#include <DragDropHelper.h>
 #include <cmath>
 
 #include <QLayout>
@@ -78,7 +78,8 @@ VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *p
     ui->zoneNameLabel->setText(name);
 
     ui->dragDropContainer->setAcceptedMimeTypes({DragDropHelper::MIME_TYPE_GRAPH});
-    connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this, &VisualizationZoneWidget::dropMimeData);
+    connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this,
+            &VisualizationZoneWidget::dropMimeData);
 
     // 'Close' options : widget is deleted when closed
     setAttribute(Qt::WA_DeleteOnClose);
@@ -116,10 +117,11 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
     return createGraph(variable, -1);
 }
 
-VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable, int index)
+VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable,
+                                                               int index)
 {
-    auto graphWidget = new VisualizationGraphWidget{
-        defaultGraphName(*ui->dragDropContainer->layout()), this};
+    auto graphWidget
+        = new VisualizationGraphWidget{defaultGraphName(*ui->dragDropContainer->layout()), this};
 
 
     // Set graph properties
@@ -146,10 +148,10 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
                         graphChildRange.m_TStart += deltaLeft;
                         graphChildRange.m_TEnd -= deltaRight;
                         qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
-                                                               << deltaLeft;
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
-                                                               << deltaRight;
+                        qCDebug(LOG_VisualizationZoneWidget())
+                            << tr("TORM: deltaLeft") << deltaLeft;
+                        qCDebug(LOG_VisualizationZoneWidget())
+                            << tr("TORM: deltaRight") << deltaRight;
                         qCDebug(LOG_VisualizationZoneWidget())
                             << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
 
@@ -160,10 +162,10 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
                         qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
-                                                               << deltaLeft;
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
-                                                               << deltaRight;
+                        qCDebug(LOG_VisualizationZoneWidget())
+                            << tr("TORM: deltaLeft") << deltaLeft;
+                        qCDebug(LOG_VisualizationZoneWidget())
+                            << tr("TORM: deltaRight") << deltaRight;
                         qCDebug(LOG_VisualizationZoneWidget())
                             << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                         graphChildRange.m_TStart -= deltaLeft;
@@ -200,10 +202,10 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
                         break;
                 }
                 graphChild->enableAcquisition(false);
-                qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
-                                                       << graphChild->graphRange();
-                qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
-                                                       << graphChildRange;
+                qCDebug(LOG_VisualizationZoneWidget())
+                    << tr("TORM: Range before: ") << graphChild->graphRange();
+                qCDebug(LOG_VisualizationZoneWidget())
+                    << tr("TORM: Range after : ") << graphChildRange;
                 qCDebug(LOG_VisualizationZoneWidget())
                     << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                 graphChild->setGraphRange(graphChildRange);
@@ -226,7 +228,7 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
     if (layout->count() > 0) {
         // Case of a new graph in a existant zone
         if (auto visualizationGraphWidget
-                = dynamic_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
+            = dynamic_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
             range = visualizationGraphWidget->graphRange();
         }
     }
@@ -243,7 +245,7 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
     if (auto dataSeries = variable->dataSeries()) {
         dataSeries->lockRead();
         auto valuesBounds
-                = dataSeries->valuesBounds(variable->range().m_TStart, variable->range().m_TEnd);
+            = dataSeries->valuesBounds(variable->range().m_TStart, variable->range().m_TEnd);
         auto end = dataSeries->cend();
         if (valuesBounds.first != end && valuesBounds.second != end) {
             auto rangeValue = [](const auto &value) { return std::isnan(value) ? 0. : value; };
@@ -259,14 +261,15 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
     return graphWidget;
 }
 
-VisualizationGraphWidget *VisualizationZoneWidget::createGraph(const QList<std::shared_ptr<Variable> > variables, int index)
+VisualizationGraphWidget *
+VisualizationZoneWidget::createGraph(const QList<std::shared_ptr<Variable> > variables, int index)
 {
-    if (variables.isEmpty())
+    if (variables.isEmpty()) {
         return nullptr;
+    }
 
     auto graphWidget = createGraph(variables.first(), index);
-    for (auto variableIt = variables.cbegin() + 1; variableIt != variables.cend(); ++variableIt)
-    {
+    for (auto variableIt = variables.cbegin() + 1; variableIt != variables.cend(); ++variableIt) {
         graphWidget->addVariable(*variableIt, graphWidget->graphRange());
     }
 
@@ -351,57 +354,51 @@ void VisualizationZoneWidget::onVariableAboutToBeRemoved(std::shared_ptr<Variabl
 
 void VisualizationZoneWidget::dropMimeData(int index, const QMimeData *mimeData)
 {
-    auto& helper = sqpApp->dragDropHelper();
-    if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_GRAPH))
-    {
-        auto graphWidget = static_cast<VisualizationGraphWidget*>(helper.getCurrentDragWidget());
-        auto parentDragDropContainer = qobject_cast<VisualizationDragDropContainer*>(graphWidget->parentWidget());
+    auto &helper = sqpApp->dragDropHelper();
+    if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_GRAPH)) {
+        auto graphWidget = static_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
+        auto parentDragDropContainer
+            = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
         Q_ASSERT(parentDragDropContainer);
 
-        const auto& variables = graphWidget->variables();
+        const auto &variables = graphWidget->variables();
 
-        if (parentDragDropContainer != ui->dragDropContainer && !variables.isEmpty())
-        {
-            //The drop didn't occur in the same zone
+        if (parentDragDropContainer != ui->dragDropContainer && !variables.isEmpty()) {
+            // The drop didn't occur in the same zone
 
-            //Abort the requests for the variables (if any)
-            //Commented, because it's not sure if it's needed or not
-            //for (const auto& var : variables)
+            // Abort the requests for the variables (if any)
+            // Commented, because it's not sure if it's needed or not
+            // for (const auto& var : variables)
             //{
             //    sqpApp->variableController().onAbortProgressRequested(var);
             //}
 
             auto previousParentZoneWidget = graphWidget->parentZoneWidget();
             auto nbGraph = parentDragDropContainer->countDragWidget();
-            if (nbGraph == 1)
-            {
-                //This is the only graph in the previous zone, close the zone
+            if (nbGraph == 1) {
+                // This is the only graph in the previous zone, close the zone
                 previousParentZoneWidget->close();
             }
-            else
-            {
-                //Close the graph
+            else {
+                // Close the graph
                 graphWidget->close();
             }
 
-            //Creates the new graph in the zone
+            // Creates the new graph in the zone
             createGraph(variables, index);
         }
-        else
-        {
-            //The drop occurred in the same zone or the graph is empty
-            //Simple move of the graph, no variable operation associated
+        else {
+            // The drop occurred in the same zone or the graph is empty
+            // Simple move of the graph, no variable operation associated
             parentDragDropContainer->layout()->removeWidget(graphWidget);
 
-            if (variables.isEmpty() && parentDragDropContainer != ui->dragDropContainer)
-            {
+            if (variables.isEmpty() && parentDragDropContainer != ui->dragDropContainer) {
                 // The graph is empty and dropped in a different zone.
                 // Take the range of the first graph in the zone (if existing).
                 auto layout = ui->dragDropContainer->layout();
-                if (layout->count() > 0)
-                {
-                    if (auto visualizationGraphWidget = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget()))
-                    {
+                if (layout->count() > 0) {
+                    if (auto visualizationGraphWidget
+                        = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                         graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
                     }
                 }