HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r839:5f082699d3e8

Integrates the drag&drop classes into the existing visualization classes.

trabillard -

r839:5f082699d3e8

parent child

Context file:

r839:5f082699d3e8

gui/include/Visualization/VisualizationGraphWidget.h +11 -1

             #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
+            #include "Visualization/VisualizationDragWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
             class QCustomPlot;
             class SqpRange;
             class Variable;
+            class VisualizationZoneWidget;
             namespace Ui {
             class VisualizationGraphWidget;
             } // namespace Ui
-            class VisualizationGraphWidget : public QWidget, public IVisualizationWidget {
+            class VisualizationGraphWidget : public VisualizationDragWidget, public IVisualizationWidget {
                 Q_OBJECT
                 friend class QCustomPlotSynchronizer;
                 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationGraphWidget();
+                VisualizationZoneWidget* parentZoneWidget() const noexcept;
                 /// If acquisition isn't enable, requestDataLoading signal cannot be emit
                 void enableAcquisition(bool enable);
                 /// Removes a variable from the graph
                 void removeVariable(std::shared_ptr<Variable> variable) noexcept;
+                /// Returns the list of all variables used in the graph
+                QList<std::shared_ptr<Variable>> variables() const;
                 void setYRange(const SqpRange &range);
                 SqpRange graphRange() const noexcept;
                 void setGraphRange(const SqpRange &range);
                 bool contains(const Variable &variable) const override;
                 QString name() const override;
+                // VisualisationDragWidget
+                QMimeData* mimeData() const override;
+                bool isDragAllowed() const override;
             signals:
                 void synchronize(const SqpRange &range, const SqpRange &oldRange);

gui/include/Visualization/VisualizationTabWidget.h +16 -1

             #include <QLoggingCategory>
             #include <QWidget>
+            #include <QMimeData>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationTabWidget)
                 /// Add a zone widget
                 void addZone(VisualizationZoneWidget *zoneWidget);
+                void insertZone(int index, VisualizationZoneWidget *zoneWidget);
                 /**
                  * Creates a zone using a variable. The variable will be displayed in a new graph of the new
-                 * zone.
+                 * zone. The zone is added at the end.
                  * @param variable the variable for which to create the zone
                  * @return the pointer to the created zone
                  */
                 VisualizationZoneWidget *createZone(std::shared_ptr<Variable> variable);
+                /**
+                 * Creates a zone using a list of variables. The variables will be displayed in a new graph of the new
+                 * zone. The zone is inserted at the specified index.
+                 * @param variables the variables for which to create the zone
+                 * @param index The index where the zone should be inserted in the layout
+                 * @return the pointer to the created zone
+                 */
+                VisualizationZoneWidget *createZone(const QList<std::shared_ptr<Variable>>& variables, int index);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
                 class VisualizationTabWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationTabWidgetPrivate> impl;
+            private slots:
+                void dropMimeData(int index, const QMimeData *mimeData);
             };
             #endif // SCIQLOP_VISUALIZATIONTABWIDGET_H

gui/include/Visualization/VisualizationZoneWidget.h +31 -2

             #define SCIQLOP_VISUALIZATIONZONEWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
+            #include "Visualization/VisualizationDragWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
             class Variable;
             class VisualizationGraphWidget;
-            class VisualizationZoneWidget : public QWidget, public IVisualizationWidget {
+            class VisualizationZoneWidget : public VisualizationDragWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationZoneWidget();
-                /// Add a graph widget
+                /// Adds a graph widget
                 void addGraph(VisualizationGraphWidget *graphWidget);
+                 /// Inserts a graph widget
+                void insertGraph(int index, VisualizationGraphWidget *graphWidget);
                 /**
                  * Creates a graph using a variable. The variable will be displayed in the new graph.
+                 * The graph is added at the end.
                  * @param variable the variable for which to create the graph
                  * @return the pointer to the created graph
                  */
                 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable);
+                /**
+                 * Creates a graph using a variable. The variable will be displayed in the new graph.
+                 * The graph is inserted at the specified index.
+                 * @param variable the variable for which to create the graph
+                 * @param index The index where the graph should be inserted in the layout
+                 * @return the pointer to the created graph
+                 */
+                VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable, int index);
+                /**
+                 * Creates a graph using a list of variables. The variables will be displayed in the new graph.
+                 * The graph is inserted at the specified index.
+                 * @param variables List of variables to be added to the graph
+                 * @param index The index where the graph should be inserted in the layout
+                 * @return the pointer to the created graph
+                 */
+                VisualizationGraphWidget *createGraph(const QList<std::shared_ptr<Variable>> variables, int index);
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
                 bool contains(const Variable &variable) const override;
                 QString name() const override;
+                // VisualisationDragWidget
+                QMimeData* mimeData() const override;
+                bool isDragAllowed() const override;
             protected:
                 void closeEvent(QCloseEvent *event) override;
                 void onVariableAdded(std::shared_ptr<Variable> variable);
                 /// Slot called when a variable is about to be removed from a graph contained in the zone
                 void onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable);
+                void dropMimeData(int index, const QMimeData* mimeData);
             };
             #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H

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

             #include "Visualization/VisualizationDefs.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/VisualizationGraphRenderingDelegate.h"
+            #include "Visualization/VisualizationZoneWidget.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
+            #include <DragDropHelper.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
-                    : QWidget{parent},
+                    : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name)}
             {
                 delete ui;
             }
+            VisualizationZoneWidget *VisualizationGraphWidget::parentZoneWidget() const noexcept
+            {
+                auto parent = parentWidget();
+                do
+                {
+                    parent = parent->parentWidget();
+                } while (parent != nullptr && !qobject_cast<VisualizationZoneWidget*>(parent));
+                return qobject_cast<VisualizationZoneWidget*>(parent);
+            }
             void VisualizationGraphWidget::enableAcquisition(bool enable)
             {
                 impl->m_DoAcquisition = enable;
                 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);
                 return impl->m_Name;
             }
+            QMimeData *VisualizationGraphWidget::mimeData() const
+            {
+                 auto *mimeData = new QMimeData;
+                 mimeData->setData(DragDropHelper::MIME_TYPE_GRAPH, QByteArray());
+                 return mimeData;
+            }
+            bool VisualizationGraphWidget::isDragAllowed() const
+            {
+                return true;
+            }
             void VisualizationGraphWidget::closeEvent(QCloseEvent *event)
             {
                 Q_UNUSED(event);
             {
                 // Handles plot rendering when mouse is moving
                 impl->m_RenderingDelegate->onMouseMove(event);
+                VisualizationDragWidget::mouseMoveEvent(event);
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             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

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

@@ -3,6 +3,10
3	#include "ui_VisualizationTabWidget.h"	3	#include "ui_VisualizationTabWidget.h"
4		4
5	#include "Visualization/VisualizationZoneWidget.h"	5	#include "Visualization/VisualizationZoneWidget.h"
		6	#include "Visualization/VisualizationGraphWidget.h"
		7
		8	#include "SqpApplication.h"
		9	#include "DragDropHelper.h"
6		10
7	Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")	11	Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
8		12
@@ -55,6 +59,9 VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *par
55	{	59	{
56	ui->setupUi(this);	60	ui->setupUi(this);
57		61
		62	ui->dragDropContainer->setAcceptedMimeTypes({DragDropHelper::MIME_TYPE_GRAPH, DragDropHelper::MIME_TYPE_ZONE});
		63	connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccured, this, &VisualizationTabWidget::dropMimeData);
		64
58	// Widget is deleted when closed	65	// Widget is deleted when closed
59	setAttribute(Qt::WA_DeleteOnClose);	66	setAttribute(Qt::WA_DeleteOnClose);
60	}	67	}
@@ -66,16 +73,26 VisualizationTabWidget::~VisualizationTabWidget()
66		73
67	void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)	74	void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
68	{	75	{
69	~~tabLayout().add~~Widget(zoneWidget);	76	ui->dragDropContainer->addDragWidget(zoneWidget);
		77	}
		78
		79	void VisualizationTabWidget::insertZone(int index, VisualizationZoneWidget *zoneWidget)
		80	{
		81	ui->dragDropContainer->insertDragWidget(index, zoneWidget);
70	}	82	}
71		83
72	VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)	84	VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
73	{	85	{
74	auto zoneWidget = new VisualizationZoneWidget{defaultZoneName(tabLayout()), this};	86	return createZone({variable}, -1);
75	this->addZone(zoneWidget);	87	}
		88
		89	VisualizationZoneWidget *VisualizationTabWidget::createZone(const QList<std::shared_ptr<Variable> > &variables, int index)
		90	{
		91	auto zoneWidget = new VisualizationZoneWidget{defaultZoneName(*ui->dragDropContainer->layout()), this};
		92	this->insertZone(index, zoneWidget);
76		93
77	// Creates a new graph into the zone	94	// Creates a new graph into the zone
78	zoneWidget->createGraph(variable);	95	zoneWidget->createGraph(variables, index);
79		96
80	return zoneWidget;	97	return zoneWidget;
81	}	98	}
@@ -125,5 +142,40 void VisualizationTabWidget::closeEvent(QCloseEvent *event)
125		142
126	QLayout &VisualizationTabWidget::tabLayout() const noexcept	143	QLayout &VisualizationTabWidget::tabLayout() const noexcept
127	{	144	{
128	return *ui->~~scrollAreaWidgetContents~~->layout();	145	return *ui->dragDropContainer->layout();
		146	}
		147
		148	void VisualizationTabWidget::dropMimeData(int index, const QMimeData *mimeData)
		149	{
		150	auto& helper = sqpApp->dragDropHelper();
		151	if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_GRAPH))
		152	{
		153	auto graphWidget = static_cast<VisualizationGraphWidget*>(helper.getCurrentDragWidget());
		154	auto parentDragDropContainer = qobject_cast<VisualizationDragDropContainer*>(graphWidget->parentWidget());
		155	Q_ASSERT(parentDragDropContainer);
		156
		157	auto nbGraph = parentDragDropContainer->countDragWidget();
		158	if (nbGraph == 1)
		159	{
		160	//This is the only graph in the previous zone, close the zone
		161	graphWidget->parentZoneWidget()->close();
		162	}
		163	else
		164	{
		165	//Close the graph
		166	graphWidget->close();
		167	}
		168
		169	const auto& variables = graphWidget->variables();
		170	createZone(variables, index);
		171	}
		172	else if (mimeData->hasFormat(DragDropHelper::MIME_TYPE_ZONE))
		173	{
		174	//Simple move of the zone, no variable operation associated
		175	auto zoneWidget = static_cast<VisualizationZoneWidget*>(helper.getCurrentDragWidget());
		176	auto parentDragDropContainer = zoneWidget->parentWidget();
		177	parentDragDropContainer->layout()->removeWidget(zoneWidget);
		178
		179	ui->dragDropContainer->insertDragWidget(index, zoneWidget);
		180	}
129	}	181	}

gui/src/Visualization/VisualizationZoneWidget.cpp +98 -8

             #include <QUuid>
             #include <SqpApplication.h>
+            #include <DragDropHelper.h>
             #include <cmath>
+            #include <QLayout>
             Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
             namespace {
             };
             VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
-                    : QWidget{parent},
+                    : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationZoneWidget},
                       impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
             {
                 ui->zoneNameLabel->setText(name);
+                ui->dragDropContainer->setAcceptedMimeTypes({DragDropHelper::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);
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
-                ui->visualizationZoneFrame->layout()->addWidget(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->visualizationZoneFrame->layout()), this};
+                    defaultGraphName(*ui->dragDropContainer->layout()), this};
                 // Set graph properties
                                                                  const SqpRange &oldGraphRange) {
                     auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
-                    auto frameLayout = ui->visualizationZoneFrame->layout();
+                    auto frameLayout = ui->dragDropContainer->layout();
                     for (auto i = 0; i < frameLayout->count(); ++i) {
                         auto graphChild
                             = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
                 auto range = SqpRange{};
                 // Apply visitor to graph children
-                auto layout = ui->visualizationZoneFrame->layout();
+                auto layout = ui->dragDropContainer->layout();
                 if (layout->count() > 0) {
                     // Case of a new graph in a existant zone
                     if (auto visualizationGraphWidget
                     range = variable->range();
                 }
-                this->addGraph(graphWidget);
+                this->insertGraph(index, graphWidget);
                 graphWidget->addVariable(variable, range);
                 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) {
                     // Apply visitor to graph children: widgets different from graphs are not visited (no
                     // action)
                     processGraphs(
-                        *ui->visualizationZoneFrame->layout(),
+                        *ui->dragDropContainer->layout(),
                         [visitor](VisualizationGraphWidget &graphWidget) { graphWidget.accept(visitor); });
                     visitor->visitLeave(this);
                 return ui->zoneNameLabel->text();
             }
+            QMimeData *VisualizationZoneWidget::mimeData() const
+            {
+                auto *mimeData = new QMimeData;
+                mimeData->setData(DragDropHelper::MIME_TYPE_ZONE, QByteArray());
+                return mimeData;
+            }
+            bool VisualizationZoneWidget::isDragAllowed() const
+            {
+                return true;
+            }
             void VisualizationZoneWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes graphs in the zone
-                processGraphs(*ui->visualizationZoneFrame->layout(),
+                processGraphs(*ui->dragDropContainer->layout(),
                               [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
                 // Delete synchronization group from variable controller
                                           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))
+                {
+                    auto graphWidget = static_cast<VisualizationGraphWidget*>(helper.getCurrentDragWidget());
+                    auto parentDragDropContainer = qobject_cast<VisualizationDragDropContainer*>(graphWidget->parentWidget());
+                    Q_ASSERT(parentDragDropContainer);
+                    const auto& variables = graphWidget->variables();
+                    if (!variables.empty())
+                    {
+                        if (parentDragDropContainer != ui->dragDropContainer)
+                        {
+                            //The drop didn't occur in the same zone
+                            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
+                            //Simple move of the graph, no variable operation associated
+                            parentDragDropContainer->layout()->removeWidget(graphWidget);
+                            ui->dragDropContainer->insertDragWidget(index, graphWidget);
+                        }
+                    }
+                }
+            }

gui/ui/Visualization/VisualizationTabWidget.ui +11 0

                    <property name="bottomMargin">
                     <number>0</number>
                    </property>
+                   <item>
+                    <widget class="VisualizationDragDropContainer" name="dragDropContainer" native="true"/>
+                   </item>
                   </layout>
                  </widget>
                 </widget>
                </item>
               </layout>
              </widget>
+             <customwidgets>
+              <customwidget>
+               <class>VisualizationDragDropContainer</class>
+               <extends>QWidget</extends>
+               <header>Visualization/VisualizationDragDropContainer.h</header>
+               <container>1</container>
+              </customwidget>
+             </customwidgets>
              <resources/>
              <connections/>
             </ui>

gui/ui/Visualization/VisualizationZoneWidget.ui +11 0

                   <property name="bottomMargin">
                    <number>0</number>
                   </property>
+                  <item>
+                   <widget class="VisualizationDragDropContainer" name="dragDropContainer" native="true"/>
+                  </item>
                  </layout>
                 </widget>
                </item>
               </layout>
              </widget>
+             <customwidgets>
+              <customwidget>
+               <class>VisualizationDragDropContainer</class>
+               <extends>QWidget</extends>
+               <header>Visualization/VisualizationDragDropContainer.h</header>
+               <container>1</container>
+              </customwidget>
+             </customwidgets>
              <resources/>
              <connections/>
             </ui>

General Comments 0

Write
Preview

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

No TODOs yet

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

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