GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r853:1ba93038a6bd

Move the GRAPH_MINIMUM_HEIGHT constant in a place accessible everywhere and use it in the drag&drop

trabillard -

r853:1ba93038a6bd

parent child

Context file:

r853:1ba93038a6bd

gui/include/Common/VisualizationDef.h created 644 +7 0

@@ -0,0 +1,7
	1	#ifndef SCIQLOP_VISUALIZATIONDEF_H
	2	#define SCIQLOP_VISUALIZATIONDEF_H
	3
	4	/// Minimum height for graph added in zones (in pixels)
	5	extern const int GRAPH_MINIMUM_HEIGHT;
	6
	7	#endif // SCIQLOP_VISUALIZATIONDEF_H

gui/src/Common/VisualizationDef.cpp created 644 +3 0

@@ -0,0 +1,3
	1	#include "Common/VisualizationDef.h"
	2
	3	const int GRAPH_MINIMUM_HEIGHT = 300;

gui/src/DragDropHelper.cpp +1 -1

             #include "DragDropHelper.h"
             #include "SqpApplication.h"
             #include "Visualization/VisualizationDragDropContainer.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/operations/FindVariableOperation.h"
             #include "Variable/VariableController.h"
             #include "Common/MimeTypesDef.h"
             #include "Common/VisualizationDef.h"
             #include <QDir>
             #include <QDragEnterEvent>
             #include <QDragMoveEvent>
             #include <QScrollArea>
             #include <QScrollBar>
             #include <QTimer>
             #include <QVBoxLayout>
             const int SCROLL_SPEED = 5;
             const int SCROLL_ZONE_SIZE = 50;
             Q_LOGGING_CATEGORY(LOG_DragDropHelper, "DragDrophelper")
             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 {
                         // Configuration of the placeHolder when there is no dragWidget
                         // (for instance with a drag from a variable)
-                        m_PlaceHolder->setMinimumSize(400, 300);
+                        m_PlaceHolder->setMinimumSize(0, GRAPH_MINIMUM_HEIGHT);
                         m_PlaceHolder->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                     }
                 }
             };
             DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()}
             {
             }
             DragDropHelper::~DragDropHelper()
             {
                 QFile::remove(impl->m_ImageTempUrl);
             }
             void DragDropHelper::resetDragAndDrop()
             {
                 setCurrentDragWidget(nullptr);
             }
             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);
             }
             bool DragDropHelper::checkMimeDataForVisualization(const QMimeData *mimeData,
                                                                VisualizationDragDropContainer *dropContainer)
             {
                 auto result = true;
                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     if (variables.count() == 1) {
                         // Check that the viariable is not already in a graph
                         // Search for the top level VisualizationWidget
                         auto parent = dropContainer->parentWidget();
                         while (parent && qobject_cast<VisualizationWidget *>(parent) == nullptr) {
                             parent = parent->parentWidget();
                         }
                         if (parent) {
                             auto visualizationWidget = static_cast<VisualizationWidget *>(parent);
                             FindVariableOperation findVariableOperation{variables.first()};
                             visualizationWidget->accept(&findVariableOperation);
                             auto variableContainers = findVariableOperation.result();
                             if (!variableContainers.empty()) {
                                 result = false;
                             }
                         }
                         else {
                             qCWarning(LOG_DragDropHelper()) << QObject::tr(
                                 "DragDropHelper::checkMimeDataForVisualization, the parent "
                                 "VisualizationWidget cannot be found.");
                             result = false;
                         }
                     }
                     else {
                         result = false;
                     }
                 }
                 return result;
             }

gui/src/Visualization/VisualizationDragDropContainer.cpp +4 -1

             #include "Visualization/VisualizationDragDropContainer.h"
             #include "DragDropHelper.h"
             #include "SqpApplication.h"
             #include "Visualization/VisualizationDragWidget.h"
+            #include "Common/VisualizationDef.h"
             #include <QDrag>
             #include <QDragEnterEvent>
             #include <QVBoxLayout>
             #include <cmath>
             #include <memory>
             Q_LOGGING_CATEGORY(LOG_VisualizationDragDropContainer, "VisualizationDragDropContainer")
             struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
                 QVBoxLayout *m_Layout;
                 QStringList m_AcceptedMimeTypes;
                 QStringList m_MergeAllowedMimeTypes;
                 VisualizationDragDropContainer::AcceptMimeDataFunction m_AcceptMimeDataFun
                     = [](auto mimeData) { return true; };
                 explicit VisualizationDragDropContainerPrivate(QWidget *widget)
                 {
                     m_Layout = new QVBoxLayout(widget);
                     m_Layout->setContentsMargins(0, 0, 0, 0);
                 }
                 bool acceptMimeData(const QMimeData *data) const
                 {
                     for (const auto &type : m_AcceptedMimeTypes) {
                         if (data->hasFormat(type) && m_AcceptMimeDataFun(data)) {
                             return true;
                         }
                     }
                     return false;
                 }
                 bool allowMergeMimeData(const QMimeData *data) const
                 {
                     for (const auto &type : m_MergeAllowedMimeTypes) {
                         if (data->hasFormat(type)) {
                             return true;
                         }
                     }
                     return false;
                 }
                 bool hasPlaceHolder() const
                 {
                     return sqpApp->dragDropHelper().placeHolder().parentWidget() == m_Layout->parentWidget();
                 }
                 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)) {
                                 dragWidget = widget;
                                 break;
                             }
                         }
                     }
                     return dragWidget;
                 }
                 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);
                     return containerRect.contains(container->mapFromGlobal(QCursor::pos()));
                 }
             };
             VisualizationDragDropContainer::VisualizationDragDropContainer(QWidget *parent)
                     : QWidget{parent},
                       impl{spimpl::make_unique_impl<VisualizationDragDropContainerPrivate>(this)}
             {
                 setAcceptDrops(true);
             }
             void VisualizationDragDropContainer::addDragWidget(VisualizationDragWidget *dragWidget)
             {
                 impl->m_Layout->addWidget(dragWidget);
                 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
                 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
                         &VisualizationDragDropContainer::startDrag);
             }
             void VisualizationDragDropContainer::insertDragWidget(int index,
                                                                   VisualizationDragWidget *dragWidget)
             {
                 impl->m_Layout->insertWidget(index, dragWidget);
                 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
                 connect(dragWidget, &VisualizationDragWidget::dragDetected, this,
                         &VisualizationDragDropContainer::startDrag);
             }
             void VisualizationDragDropContainer::setAcceptedMimeTypes(const QStringList &mimeTypes)
             {
                 impl->m_AcceptedMimeTypes = mimeTypes;
             }
             void VisualizationDragDropContainer::setMergeAllowedMimeTypes(const QStringList &mimeTypes)
             {
                 impl->m_MergeAllowedMimeTypes = mimeTypes;
             }
             int VisualizationDragDropContainer::countDragWidget() const
             {
                 auto nbGraph = 0;
                 for (auto child : children()) {
                     if (qobject_cast<VisualizationDragWidget *>(child)) {
                         nbGraph += 1;
                     }
                 }
                 return nbGraph;
             }
             void VisualizationDragDropContainer::setAcceptMimeDataFunction(
                 VisualizationDragDropContainer::AcceptMimeDataFunction fun)
             {
                 impl->m_AcceptMimeDataFun = fun;
             }
             void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidget,
                                                            const QPoint &dragPosition)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 helper.resetDragAndDrop();
                 // Note: The management of the drag object is done by Qt
                 auto drag = new QDrag{dragWidget};
                 drag->setHotSpot(dragPosition);
                 auto mimeData = dragWidget->mimeData();
                 drag->setMimeData(mimeData);
                 auto pixmap = QPixmap(dragWidget->size());
                 dragWidget->render(&pixmap);
                 drag->setPixmap(pixmap);
                 auto image = pixmap.toImage();
                 mimeData->setImageData(image);
                 mimeData->setUrls({helper.imageTemporaryUrl(image)});
                 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);
                         dragWidget->setVisible(false);
                     }
                     // Note: The exec() is blocking on windows but not on linux and macOS
                     drag->exec(Qt::MoveAction | Qt::CopyAction);
                 }
                 else {
                     qCWarning(LOG_VisualizationDragDropContainer())
                         << tr("VisualizationDragDropContainer::startDrag, drag aborted, the specified "
                               "VisualizationDragWidget is not found in this container.");
                 }
             }
             void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent *event)
             {
                 if (impl->acceptMimeData(event->mimeData())) {
                     event->acceptProposedAction();
                     auto &helper = sqpApp->dragDropHelper();
                     if (!impl->hasPlaceHolder()) {
                         auto dragWidget = helper.getCurrentDragWidget();
                         if (dragWidget) {
                             // If the drag&drop is internal to the visualization, entering the container hide
                             // the dragWidget which was hidden by the dragLeaveEvent
                             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);
                             if (dragWidget) {
                                 auto dragWidgetIndex = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
                                 if (dragWidgetIndex >= 0 && dragWidgetIndex <= hoveredWidgetIndex) {
                                     // Correction of the index if the drop occurs in the same container
                                     // and if the drag is started from the visualization (in that case, the
                                     // dragWidget is hidden)
                                     hoveredWidgetIndex += 1;
                                 }
                             }
                             helper.insertPlaceHolder(impl->m_Layout, hoveredWidgetIndex);
                         }
                         else {
                             helper.insertPlaceHolder(impl->m_Layout, 0);
                         }
                     }
                     else {
                         // do nothing
                     }
                 }
                 else {
                     event->ignore();
                 }
                 QWidget::dragEnterEvent(event);
             }
             void VisualizationDragDropContainer::dragLeaveEvent(QDragLeaveEvent *event)
             {
                 Q_UNUSED(event);
                 auto &helper = sqpApp->dragDropHelper();
                 if (!impl->cursorIsInContainer(this)) {
                     helper.removePlaceHolder();
                     auto dragWidget = helper.getCurrentDragWidget();
                     if (dragWidget) {
                         // dragWidget has a value only if the drag is started from the visualization
                         // In that case, shows 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 (dragWidget) {
                             dragWidget->setVisible(true);
                         }
                     }
                 }
                 else {
                     // Leave event probably received for a child widget.
                     // Do nothing.
                     // Note: The DragLeave event, doesn't have any mean to determine who sent it.
                 }
                 QWidget::dragLeaveEvent(event);
             }
             void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent *event)
             {
                 if (impl->acceptMimeData(event->mimeData())) {
                     auto dragWidgetHovered = impl->getChildDragWidgetAt(this, event->pos());
                     if (dragWidgetHovered) {
                         auto canMerge = impl->allowMergeMimeData(event->mimeData());
                         auto nbDragWidget = countDragWidget();
                         if (nbDragWidget > 0) {
-                            auto graphHeight = size().height() / nbDragWidget;
+                            auto graphHeight = qMax(size().height() / nbDragWidget, GRAPH_MINIMUM_HEIGHT);
                             auto dropIndex = floor(event->pos().y() / graphHeight);
                             auto zoneSize = qMin(graphHeight / 3.0, 150.0);
                             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()));
                             if (isOnTop || isOnBottom) {
                                 if (isOnBottom) {
                                     dropIndex += 1;
                                 }
                                 if (helper.getCurrentDragWidget()) {
                                     auto dragWidgetIndex
                                         = impl->m_Layout->indexOf(helper.getCurrentDragWidget());
                                     if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
                                         // Correction of the index if the drop occurs in the same container
                                         // and if the drag is started from the visualization (in that case, the
                                         // dragWidget is hidden)
                                         dropIndex += 1;
                                     }
                                 }
                                 if (dropIndex != placeHolderIndex) {
                                     helper.insertPlaceHolder(impl->m_Layout, dropIndex);
                                 }
                             }
                             else if (canMerge) {
                                 // drop on the middle -> merge
                                 if (impl->hasPlaceHolder()) {
                                     helper.removePlaceHolder();
                                 }
                             }
                         }
                         else {
                             qCWarning(LOG_VisualizationDragDropContainer())
                                 << tr("VisualizationDragDropContainer::dragMoveEvent, no widget found in the "
                                       "container");
                         }
                     }
                     else {
                         // No hovered drag widget, the mouse is probably hover the placeHolder
                         // Do nothing
                     }
                 }
                 else {
                     event->ignore();
                 }
                 QWidget::dragMoveEvent(event);
             }
             void VisualizationDragDropContainer::dropEvent(QDropEvent *event)
             {
                 if (impl->acceptMimeData(event->mimeData())) {
                     auto dragWidget = sqpApp->dragDropHelper().getCurrentDragWidget();
                     if (impl->hasPlaceHolder()) {
                         auto &helper = sqpApp->dragDropHelper();
                         auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
                         if (dragWidget) {
                             auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
                             if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
                                 // Correction of the index if the drop occurs in the same container
                                 // and if the drag is started from the visualization (in that case, the
                                 // dragWidget is hidden)
                                 droppedIndex -= 1;
                             }
                             dragWidget->setVisible(true);
                         }
                         event->acceptProposedAction();
                         helper.removePlaceHolder();
                         emit dropOccured(droppedIndex, event->mimeData());
                     }
                     else {
                         qCWarning(LOG_VisualizationDragDropContainer())
                             << tr("VisualizationDragDropContainer::dropEvent, couldn't drop because the "
                                   "placeHolder is not found.");
                         Q_ASSERT(false);
                     }
                 }
                 else {
                     event->ignore();
                 }
                 QWidget::dropEvent(event);
             }

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

             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/QCustomPlotSynchronizer.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationWidget.h"
             #include "ui_VisualizationZoneWidget.h"
             #include "Common/MimeTypesDef.h"
+            #include "Common/VisualizationDef.h"
             #include <Data/SqpRange.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/operations/FindVariableOperation.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;
                 void dropGraph(int index, VisualizationZoneWidget *zoneWidget);
                 void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
                                    VisualizationZoneWidget *zoneWidget);
             };
             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({MIME_TYPE_GRAPH, MIME_TYPE_VARIABLE_LIST});
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
                                                                                   ui->dragDropContainer);
                 });
                 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(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)
             {
                 if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
                     impl->dropGraph(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     impl->dropVariables(variables, index, this);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeData, unknown MIME data received.");
                 }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropGraph(
                 int index, VisualizationZoneWidget *zoneWidget)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the dropped graph is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the parent container of "
                               "the dropped graph is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 const auto &variables = graphWidget->variables();
                 if (parentDragDropContainer != zoneWidget->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
                     zoneWidget->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 != zoneWidget->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 = zoneWidget->ui->dragDropContainer->layout();
                         if (layout->count() > 0) {
                             if (auto visualizationGraphWidget
                                 = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                                 graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
                             }
                         }
                     }
                     zoneWidget->ui->dragDropContainer->insertDragWidget(index, graphWidget);
                 }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropVariables(
                 const QList<std::shared_ptr<Variable> > &variables, int index,
                 VisualizationZoneWidget *zoneWidget)
             {
                 // Search for the top level VisualizationWidget
                 auto parent = zoneWidget->parentWidget();
                 while (parent && qobject_cast<VisualizationWidget *>(parent) == nullptr) {
                     parent = parent->parentWidget();
                 }
                 if (!parent) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropVariables, drop aborted, the parent "
                               "VisualizationWidget cannot be found.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto visualizationWidget = static_cast<VisualizationWidget *>(parent);
                 // Search for the first variable which can be dropped
                 for (auto variable : variables) {
                     FindVariableOperation findVariableOperation{variable};
                     visualizationWidget->accept(&findVariableOperation);
                     auto variableContainers = findVariableOperation.result();
                     if (variableContainers.empty()) {
                         zoneWidget->createGraph(variable, index);
                         break;
                     }
                 }
             }

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