GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r850:3715d1ed451c

Move Common MIME types constants in a Definition file in core module.

trabillard -

r850:3715d1ed451c

parent child

Context file:

r850:3715d1ed451c

core/include/Common/MimeTypesDef.h created 644 +18 0

@@ -0,0 +1,18
	1	#ifndef SCIQLOP_MIMETYPESDEF_H
	2	#define SCIQLOP_MIMETYPESDEF_H
	3
	4	#include "CoreGlobal.h"
	5
	6	#include <QString>
	7
	8	// ////////////////// //
	9	// SciQlop Mime Types //
	10	// ////////////////// //
	11
	12	extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_GRAPH;
	13	extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_ZONE;
	14	extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_VARIABLE_LIST;
	15	extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_TIME_RANGE;
	16
	17
	18	#endif // SCIQLOP_MIMETYPESDEF_H

core/src/Common/MimeTypesDef.cpp created 644 +6 0

@@ -0,0 +1,6
	1	#include "Common/MimeTypesDef.h"
	2
	3	const QString MIME_TYPE_GRAPH = QStringLiteral("scqlop/graph");
	4	const QString MIME_TYPE_ZONE = QStringLiteral("scqlop/zone");
	5	const QString MIME_TYPE_VARIABLE_LIST = QStringLiteral("scqlop/var-list");
	6	const QString MIME_TYPE_TIME_RANGE = QStringLiteral("scqlop/time-range");

gui/src/DragDropHelper.cpp 0 -3

             #include "DragDropHelper.h"
             #include "SqpApplication.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include <QDir>
             #include <QDragEnterEvent>
             #include <QDragMoveEvent>
             #include <QScrollArea>
             #include <QScrollBar>
             #include <QTimer>
             #include <QVBoxLayout>
-            const QString DragDropHelper::MIME_TYPE_GRAPH = "scqlop/graph";
-            const QString DragDropHelper::MIME_TYPE_ZONE = "scqlop/zone";
             const int SCROLL_SPEED = 5;
             const int SCROLL_ZONE_SIZE = 50;
             struct DragDropScroller::DragDropScrollerPrivate {
                 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;
                 explicit DragDropScrollerPrivate() : m_Timer{std::make_unique<QTimer>()}
                 {
                     m_Timer->setInterval(0);
                 }
             };
             DragDropScroller::DragDropScroller(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<DragDropScrollerPrivate>()}
             {
                 connect(impl->m_Timer.get(), &QTimer::timeout, this, &DragDropScroller::onTimer);
             }
             void DragDropScroller::addScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_ScrollAreas << scrollArea;
                 scrollArea->viewport()->setAcceptDrops(true);
             }
             void DragDropScroller::removeScrollArea(QScrollArea *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 (impl->m_CurrentScrollArea && impl->m_CurrentScrollArea->isAncestorOf(w)) {
                         auto moveEvent = static_cast<QDragMoveEvent *>(event);
                         auto pos = moveEvent->pos();
                         if (impl->m_CurrentScrollArea->viewport() != w) {
                             auto globalPos = w->mapToGlobal(moveEvent->pos());
                             pos = impl->m_CurrentScrollArea->viewport()->mapFromGlobal(globalPos);
                         }
                         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();
                         }
                         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);
                     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;
                             break;
                         }
                     }
                 }
                 else if (event->type() == QEvent::DragLeave) {
                     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) {
                     if (impl->m_CurrentScrollArea) {
                         impl->m_CurrentScrollArea = nullptr;
                         impl->m_Direction = DragDropScrollerPrivate::ScrollDirection::unknown;
                         impl->m_Timer->stop();
                     }
                 }
                 return false;
             }
             void DragDropScroller::onTimer()
             {
                 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;
                     }
                     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.
                 explicit DragDropHelperPrivate()
                         : 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_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());
                     }
                     else {
                         m_PlaceHolder->setMinimumSize(200, 200);
                     }
                 }
             };
             DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()}
             {
             }
             DragDropHelper::~DragDropHelper()
             {
                 QFile::remove(impl->m_ImageTempUrl);
             }
             void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
             {
                 impl->m_CurrentDragWidget = dragWidget;
             }
             VisualizationDragWidget *DragDropHelper::getCurrentDragWidget() const
             {
                 return impl->m_CurrentDragWidget;
             }
             QWidget &DragDropHelper::placeHolder() const
             {
                 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();
             }
             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();
                 }
             }
             bool DragDropHelper::isPlaceHolderSet() const
             {
                 return impl->m_PlaceHolder->parentWidget();
             }
             void DragDropHelper::addDragDropScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_DragDropScroller->addScrollArea(scrollArea);
             }
             void DragDropHelper::removeDragDropScrollArea(QScrollArea *scrollArea)
             {
                 impl->m_DragDropScroller->removeScrollArea(scrollArea);
             }
             QUrl DragDropHelper::imageTemporaryUrl(const QImage &image) const
             {
                 image.save(impl->m_ImageTempUrl);
                 return QUrl::fromLocalFile(impl->m_ImageTempUrl);
             }

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

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationDefs.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "ui_VisualizationGraphWidget.h"
+            #include <Common/MimeTypesDef.h>
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <DragDropHelper.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
             namespace {
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                 explicit VisualizationGraphWidgetPrivate(const QString &name)
                         : m_Name{name},
                           m_DoAcquisition{true},
                           m_IsCalibration{false},
                           m_RenderingDelegate{nullptr}
                 {
                 }
                 QString m_Name;
                 // 1 variable -> n qcpplot
                 std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
                 bool m_DoAcquisition;
                 bool m_IsCalibration;
                 QCPItemTracer *m_TextTracer;
                 /// Delegate used to attach rendering features to the plot
                 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 // Set qcpplot properties :
                 // - Drag (on x-axis) and zoom are enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectItems);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
                 // The delegate must be initialized after the ui as it uses the plot
                 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*this);
                 connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
                 connect(ui->widget, &QCustomPlot::mouseRelease, this,
                         &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);
                 // Activates menu when right clicking on the graph
                 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
                         &VisualizationGraphWidget::onGraphMenuRequested);
                 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
                         &VariableController::onRequestDataLoading);
                 connect(&sqpApp->variableController(), &VariableController::updateVarDisplaying, this,
                         &VisualizationGraphWidget::onUpdateVarDisplaying);
             }
             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);
             }
             void VisualizationGraphWidget::enableAcquisition(bool enable)
             {
                 impl->m_DoAcquisition = enable;
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
                 impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
                 // Set axes properties according to the units of the data series
                 /// @todo : for the moment, no control is performed on the axes: the units and the tickers
                 /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
                 auto xAxisUnit = Unit{};
                 auto valuesUnit = Unit{};
                 if (auto dataSeries = variable->dataSeries()) {
                     dataSeries->lockRead();
                     xAxisUnit = dataSeries->xAxisUnit();
                     valuesUnit = dataSeries->valuesUnit();
                     dataSeries->unlock();
                 }
                 impl->m_RenderingDelegate->setAxesProperties(xAxisUnit, valuesUnit);
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
                 this->enableAcquisition(false);
                 this->setGraphRange(range);
                 this->enableAcquisition(true);
                 emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable, range, false);
                 emit variableAdded(variable);
             }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 // Each component associated to the variable :
                 // - is removed from qcpplot (which deletes it)
                 // - is no longer referenced in the map
                 auto 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;) {
                         ui->widget->removePlottable(plottableIt->second);
                         plottableIt = plottablesMap.erase(plottableIt);
                     }
                     impl->m_VariableToPlotMultiMap.erase(variableIt);
                 }
                 // Updates graph
                 ui->widget->replot();
             }
             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) {
                     variables << it->first;
                 }
                 return variables;
             }
             void VisualizationGraphWidget::setYRange(const SqpRange &range)
             {
                 ui->widget->yAxis->setRange(range.m_TStart, range.m_TEnd);
             }
             SqpRange VisualizationGraphWidget::graphRange() const noexcept
             {
                 auto graphRange = ui->widget->xAxis->range();
                 return SqpRange{graphRange.lower, graphRange.upper};
             }
             void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
                 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                 ui->widget->replot();
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
             }
             void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visit(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationGraphWidget())
                         << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationGraphWidget::canDrop(const Variable &variable) const
             {
                 /// @todo : for the moment, a graph can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationGraphWidget::contains(const Variable &variable) const
             {
                 // Finds the variable among the keys of the map
                 auto variablePtr = &variable;
                 auto findVariable
                     = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
                 auto end = impl->m_VariableToPlotMultiMap.cend();
                 auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
                 return it != end;
             }
             QString VisualizationGraphWidget::name() const
             {
                 return impl->m_Name;
             }
             QMimeData *VisualizationGraphWidget::mimeData() const
             {
                 auto mimeData = new QMimeData;
-                mimeData->setData(DragDropHelper::MIME_TYPE_GRAPH, QByteArray());
+                mimeData->setData(MIME_TYPE_GRAPH, QByteArray());
                 return mimeData;
             }
             bool VisualizationGraphWidget::isDragAllowed() const
             {
                 return true;
             }
             void VisualizationGraphWidget::closeEvent(QCloseEvent *event)
             {
                 Q_UNUSED(event);
                 // 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);
             }
             QCustomPlot &VisualizationGraphWidget::plot() noexcept
             {
                 return *ui->widget;
             }
             void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
             {
                 QMenu graphMenu{};
                 // Iterates on variables (unique keys)
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
                           end = impl->m_VariableToPlotMultiMap.cend();
                      it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                     // 'Remove variable' action
                     graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
                                         [ this, var = it->first ]() { removeVariable(var); });
                 }
                 if (!graphMenu.isEmpty()) {
                     graphMenu.exec(QCursor::pos());
                 }
             }
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
             {
                 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};
                 if (impl->m_DoAcquisition) {
                     QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
                     for (auto it = impl->m_VariableToPlotMultiMap.begin(),
                               end = impl->m_VariableToPlotMultiMap.end();
                          it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                         variableUnderGraphVector.push_back(it->first);
                     }
                     emit requestDataLoading(std::move(variableUnderGraphVector), graphRange,
                                             !impl->m_IsCalibration);
                     if (!impl->m_IsCalibration) {
                         qCDebug(LOG_VisualizationGraphWidget())
                             << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
                             << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
                         emit synchronize(graphRange, oldGraphRange);
                     }
                 }
             }
             void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
             {
                 // Handles plot rendering when mouse is moving
                 impl->m_RenderingDelegate->onMouseMove(event);
                 VisualizationDragWidget::mouseMoveEvent(event);
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto zoomOrientations = QFlags<Qt::Orientation>{};
                 // Lambda that enables a zoom orientation if the key modifier related to this orientation
                 // has
                 // been pressed
                 auto enableOrientation
                     = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
                           auto orientationEnabled = event->modifiers().testFlag(modifier);
                           zoomOrientations.setFlag(orientation, orientationEnabled);
                       };
                 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
                 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
                 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
             }
             void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
             {
                 impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
                 plot().setInteraction(QCP::iRangeDrag, !event->modifiers().testFlag(Qt::AltModifier));
                 VisualizationDragWidget::mousePressEvent(event);
             }
             void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
             {
                 impl->m_IsCalibration = false;
             }
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
                 auto graphRange = ui->widget->xAxis->range();
                 auto dateTime = SqpRange{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())) {
                         VisualizationGraphHelper::updateData(variableEntry.second, variable->dataSeries(),
                                                              variable->range());
                     }
                 }
             }
             void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,
                                                                  const SqpRange &range)
             {
                 auto it = impl->m_VariableToPlotMultiMap.find(variable);
                 if (it != impl->m_VariableToPlotMultiMap.end()) {
                     VisualizationGraphHelper::updateData(it->second, variable->dataSeries(), range);
                 }
             }

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

             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "ui_VisualizationTabWidget.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "Variable/VariableController.h"
+            #include "Common/MimeTypesDef.h"
             #include "DragDropHelper.h"
             #include "SqpApplication.h"
             Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
             namespace {
             /// Generates a default name for a new zone, according to the number of zones already displayed in
             /// the tab
             QString defaultZoneName(const QLayout &layout)
             {
                 auto count = 0;
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (dynamic_cast<VisualizationZoneWidget *>(layout.itemAt(i)->widget())) {
                         count++;
                     }
                 }
                 return QObject::tr("Zone %1").arg(count + 1);
             }
             /**
              * Applies a function to all zones of the tab represented by its layout
              * @param layout the layout that contains zones
              * @param fun the function to apply to each zone
              */
             template <typename Fun>
             void processZones(QLayout &layout, Fun fun)
             {
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (auto item = layout.itemAt(i)) {
                         if (auto visualizationZoneWidget
                             = dynamic_cast<VisualizationZoneWidget *>(item->widget())) {
                             fun(*visualizationZoneWidget);
                         }
                     }
                 }
             }
             } // namespace
             struct VisualizationTabWidget::VisualizationTabWidgetPrivate {
                 explicit VisualizationTabWidgetPrivate(const QString &name) : m_Name{name} {}
                 QString m_Name;
             };
             VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationTabWidget},
                       impl{spimpl::make_unique_impl<VisualizationTabWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
-                ui->dragDropContainer->setAcceptedMimeTypes(
+                ui->dragDropContainer->setAcceptedMimeTypes({MIME_TYPE_GRAPH, MIME_TYPE_ZONE});
-                    {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
                 setAttribute(Qt::WA_DeleteOnClose);
             }
             VisualizationTabWidget::~VisualizationTabWidget()
             {
                 sqpApp->dragDropHelper().removeDragDropScrollArea(ui->scrollArea);
                 delete ui;
             }
             void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
             {
                 ui->dragDropContainer->addDragWidget(zoneWidget);
             }
             void VisualizationTabWidget::insertZone(int index, VisualizationZoneWidget *zoneWidget)
             {
                 ui->dragDropContainer->insertDragWidget(index, zoneWidget);
             }
             VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
             {
                 return createZone({variable}, -1);
             }
             VisualizationZoneWidget *
             VisualizationTabWidget::createZone(const QList<std::shared_ptr<Variable> > &variables, int index)
             {
                 auto zoneWidget = createEmptyZone(index);
                 // Creates a new graph into the zone
                 zoneWidget->createGraph(variables, index);
                 return zoneWidget;
             }
             VisualizationZoneWidget *VisualizationTabWidget::createEmptyZone(int index)
             {
                 auto zoneWidget
                     = new VisualizationZoneWidget{defaultZoneName(*ui->dragDropContainer->layout()), this};
                 this->insertZone(index, zoneWidget);
                 return zoneWidget;
             }
             void VisualizationTabWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to zone children: widgets different from zones are not visited (no action)
                     processZones(tabLayout(), [visitor](VisualizationZoneWidget &zoneWidget) {
                         zoneWidget.accept(visitor);
                     });
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationTabWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationTabWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationTabWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationTabWidget::name() const
             {
                 return impl->m_Name;
             }
             void VisualizationTabWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes zones in the tab
                 processZones(tabLayout(), [](VisualizationZoneWidget &zoneWidget) { zoneWidget.close(); });
                 QWidget::closeEvent(event);
             }
             QLayout &VisualizationTabWidget::tabLayout() const noexcept
             {
                 return *ui->dragDropContainer->layout();
             }
             void VisualizationTabWidget::dropMimeData(int index, const QMimeData *mimeData)
             {
                 auto &helper = sqpApp->dragDropHelper();
-                if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_GRAPH)) {
+                if (mimeData->hasFormat(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();
                     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
                             graphWidget->parentZoneWidget()->close();
                         }
                         else {
                             // Close the graph
                             graphWidget->close();
                         }
                         createZone(variables, index);
                     }
                     else {
                         // The graph is empty, create an empty zone and move the graph inside
                         auto parentZoneWidget = graphWidget->parentZoneWidget();
                         parentDragDropContainer->layout()->removeWidget(graphWidget);
                         auto zoneWidget = createEmptyZone(index);
                         zoneWidget->addGraph(graphWidget);
                         // Close the old zone if it was the only graph inside
                         if (nbGraph == 1) {
                             parentZoneWidget->close();
                         }
                     }
                 }
-                else if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_ZONE)) {
+                else if (mimeData->hasFormat(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);
                     ui->dragDropContainer->insertDragWidget(index, zoneWidget);
                 }
             }

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

             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/QCustomPlotSynchronizer.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "ui_VisualizationZoneWidget.h"
+            #include "Common/MimeTypesDef.h"
             #include <Data/SqpRange.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <DragDropHelper.h>
             #include <QUuid>
             #include <SqpApplication.h>
             #include <cmath>
             #include <QLayout>
             Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
             namespace {
             /// Minimum height for graph added in zones (in pixels)
             const auto GRAPH_MINIMUM_HEIGHT = 300;
             /// Generates a default name for a new graph, according to the number of graphs already displayed in
             /// the zone
             QString defaultGraphName(const QLayout &layout)
             {
                 auto count = 0;
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
                         count++;
                     }
                 }
                 return QObject::tr("Graph %1").arg(count + 1);
             }
             /**
              * Applies a function to all graphs of the zone represented by its layout
              * @param layout the layout that contains graphs
              * @param fun the function to apply to each graph
              */
             template <typename Fun>
             void processGraphs(QLayout &layout, Fun fun)
             {
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (auto item = layout.itemAt(i)) {
                         if (auto visualizationGraphWidget
                             = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
                             fun(*visualizationGraphWidget);
                         }
                     }
                 }
             }
             } // namespace
             struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
                 explicit VisualizationZoneWidgetPrivate()
                         : m_SynchronisationGroupId{QUuid::createUuid()},
                           m_Synchronizer{std::make_unique<QCustomPlotSynchronizer>()}
                 {
                 }
                 QUuid m_SynchronisationGroupId;
                 std::unique_ptr<IGraphSynchronizer> m_Synchronizer;
             };
             VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
                     : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationZoneWidget},
                       impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 ui->zoneNameLabel->setText(name);
-                ui->dragDropContainer->setAcceptedMimeTypes({DragDropHelper::MIME_TYPE_GRAPH});
+                ui->dragDropContainer->setAcceptedMimeTypes({MIME_TYPE_GRAPH});
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this,
                         &VisualizationZoneWidget::dropMimeData);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                 // Synchronisation id
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             VisualizationZoneWidget::~VisualizationZoneWidget()
             {
                 delete ui;
             }
             void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
             {
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->addDragWidget(graphWidget);
             }
             void VisualizationZoneWidget::insertGraph(int index, VisualizationGraphWidget *graphWidget)
             {
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->insertDragWidget(index, graphWidget);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
             {
                 return createGraph(variable, -1);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable,
                                                                            int index)
             {
                 auto graphWidget
                     = new VisualizationGraphWidget{defaultGraphName(*ui->dragDropContainer->layout()), this};
                 // Set graph properties
                 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
                 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
                 // Lambda to synchronize zone widget
                 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &graphRange,
                                                                  const SqpRange &oldGraphRange) {
                     auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
                     auto frameLayout = ui->dragDropContainer->layout();
                     for (auto i = 0; i < frameLayout->count(); ++i) {
                         auto graphChild
                             = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
                         if (graphChild && (graphChild != graphWidget)) {
                             auto graphChildRange = graphChild->graphRange();
                             switch (zoomType) {
                                 case AcquisitionZoomType::ZoomIn: {
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     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: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::ZoomOut: {
                                     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: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanRight: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanLeft: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     break;
                                 }
                                 case AcquisitionZoomType::Unknown: {
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type unknown");
                                     break;
                                 }
                                 default:
                                     qCCritical(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type not take into account");
                                     // No action
                                     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: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                             graphChild->setGraphRange(graphChildRange);
                             graphChild->enableAcquisition(true);
                         }
                     }
                 };
                 // connection for synchronization
                 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
                 connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
                         &VisualizationZoneWidget::onVariableAdded);
                 connect(graphWidget, &VisualizationGraphWidget::variableAboutToBeRemoved, this,
                         &VisualizationZoneWidget::onVariableAboutToBeRemoved);
                 auto range = SqpRange{};
                 // Apply visitor to graph children
                 auto layout = ui->dragDropContainer->layout();
                 if (layout->count() > 0) {
                     // Case of a new graph in a existant zone
                     if (auto visualizationGraphWidget
                         = dynamic_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                         range = visualizationGraphWidget->graphRange();
                     }
                 }
                 else {
                     // Case of a new graph as the first of the zone
                     range = variable->range();
                 }
                 this->insertGraph(index, graphWidget);
                 graphWidget->addVariable(variable, range);
                 // get y using variable range
                 if (auto dataSeries = variable->dataSeries()) {
                     dataSeries->lockRead();
                     auto valuesBounds
                         = 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; };
                         auto minValue = rangeValue(valuesBounds.first->minValue());
                         auto maxValue = rangeValue(valuesBounds.second->maxValue());
                         graphWidget->setYRange(SqpRange{minValue, maxValue});
                     }
                     dataSeries->unlock();
                 }
                 return graphWidget;
             }
             VisualizationGraphWidget *
             VisualizationZoneWidget::createGraph(const QList<std::shared_ptr<Variable> > variables, int index)
             {
                 if (variables.isEmpty()) {
                     return nullptr;
                 }
                 auto graphWidget = createGraph(variables.first(), index);
                 for (auto variableIt = variables.cbegin() + 1; variableIt != variables.cend(); ++variableIt) {
                     graphWidget->addVariable(*variableIt, graphWidget->graphRange());
                 }
                 return graphWidget;
             }
             void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to graph children: widgets different from graphs are not visited (no
                     // action)
                     processGraphs(
                         *ui->dragDropContainer->layout(),
                         [visitor](VisualizationGraphWidget &graphWidget) { graphWidget.accept(visitor); });
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationZoneWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationZoneWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationZoneWidget::name() const
             {
                 return ui->zoneNameLabel->text();
             }
             QMimeData *VisualizationZoneWidget::mimeData() const
             {
                 auto mimeData = new QMimeData;
-                mimeData->setData(DragDropHelper::MIME_TYPE_ZONE, QByteArray());
+                mimeData->setData(MIME_TYPE_ZONE, QByteArray());
                 return mimeData;
             }
             bool VisualizationZoneWidget::isDragAllowed() const
             {
                 return true;
             }
             void VisualizationZoneWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes graphs in the zone
                 processGraphs(*ui->dragDropContainer->layout(),
                               [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
                 // Delete synchronization group from variable controller
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onRemoveSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
                 QWidget::closeEvent(event);
             }
             void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
                                           Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "desynchronize", Qt::QueuedConnection,
                                           Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::dropMimeData(int index, const QMimeData *mimeData)
             {
                 auto &helper = sqpApp->dragDropHelper();
-                if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_GRAPH)) {
+                if (mimeData->hasFormat(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();
                     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)
                         //{
                         //    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
                             previousParentZoneWidget->close();
                         }
                         else {
                             // Close the graph
                             graphWidget->close();
                         }
                         // 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
                         parentDragDropContainer->layout()->removeWidget(graphWidget);
                         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())) {
                                     graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
                                 }
                             }
                         }
                         ui->dragDropContainer->insertDragWidget(index, graphWidget);
                     }
                 }
             }

General Comments 1

trabillard

|

Auto status change to "Under Review"

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