GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r892:28af007d2663

New event filter class to manage the tab switching of a tabBar during a drag&drop

trabillard -

r892:28af007d2663

parent child

Context file:

r892:28af007d2663

gui/include/DragAndDrop/DragDropTabSwitcher.h created 644 +29 0

@@ -0,0 +1,29
	1	#ifndef SCIQLOP_DRAGDROPTABSWITCHER_H
	2	#define SCIQLOP_DRAGDROPTABSWITCHER_H
	3
	4	#include <Common/spimpl.h>
	5
	6	#include <QLoggingCategory>
	7	#include <QTabBar>
	8
	9	Q_DECLARE_LOGGING_CATEGORY(LOG_DragDropTabSwitcher)
	10
	11	class DragDropTabSwitcher : public QObject {
	12	Q_OBJECT
	13
	14	public:
	15	DragDropTabSwitcher(QObject *parent = nullptr);
	16
	17	void addTabBar(QTabBar *tabBar);
	18	void removeTabBar(QTabBar *tabBar);
	19
	20	protected:
	21	bool eventFilter(QObject obj, QEvent event);
	22
	23	private:
	24	class DragDropTabSwitcherPrivate;
	25	spimpl::unique_impl_ptr<DragDropTabSwitcherPrivate> impl;
	26	};
	27
	28
	29	#endif // SCIQLOP_DRAGDROPTABSWITCHER_H

gui/src/DragAndDrop/DragDropTabSwitcher.cpp created 644 +180 0

@@ -0,0 +1,180
	1	#include "DragAndDrop/DragDropTabSwitcher.h"
	2
	3	#include <QAbstractButton>
	4	#include <QDragEnterEvent>
	5	#include <QDragMoveEvent>
	6	#include <QTimer>
	7
	8	#include "SqpApplication.h"
	9
	10	Q_LOGGING_CATEGORY(LOG_DragDropTabSwitcher, "DragDropTabSwitcher")
	11
	12	const int CHANGE_TAB_INTERVAL = 400; // time necessary over a tab to accept the switch
	13	const int SCROLL_BUTTON_AUTO_CLICK_INTERVAL
	14	= 500; // time between 2 auto clicks on a scroll button of the tab bar
	15
	16	struct DragDropTabSwitcher::DragDropTabSwitcherPrivate {
	17
	18	QList<QTabBar *> m_TabBarList;
	19	QTabBar *m_CurrentTabBar = nullptr;
	20
	21	int m_HoveredTabIndex = -1;
	22	std::unique_ptr<QTimer> m_TabSwitchTimer = nullptr;
	23
	24	QAbstractButton *m_HoveredScrollButton = nullptr;
	25	std::unique_ptr<QTimer> m_ScrollButtonsTimer = nullptr;
	26
	27	explicit DragDropTabSwitcherPrivate()
	28	: m_TabSwitchTimer{std::make_unique<QTimer>()},
	29	m_ScrollButtonsTimer{std::make_unique<QTimer>()}
	30	{
	31	m_TabSwitchTimer->setSingleShot(true);
	32	m_TabSwitchTimer->setInterval(CHANGE_TAB_INTERVAL);
	33	QObject::connect(m_TabSwitchTimer.get(), &QTimer::timeout, [this]() {
	34	if (m_CurrentTabBar) {
	35	m_CurrentTabBar->setCurrentIndex(m_HoveredTabIndex);
	36	}
	37	else {
	38	qCWarning(LOG_DragDropTabSwitcher()) << "DragDropTabSwitcherPrivate::timeout: "
	39	"Cannot select a new tab: unknown current "
	40	"tab bar.";
	41	}
	42	});
	43
	44	m_ScrollButtonsTimer->setInterval(SCROLL_BUTTON_AUTO_CLICK_INTERVAL);
	45	QObject::connect(m_ScrollButtonsTimer.get(), &QTimer::timeout, [this]() {
	46	if (m_HoveredScrollButton) {
	47	m_HoveredScrollButton->animateClick();
	48	}
	49	else {
	50	qCWarning(LOG_DragDropTabSwitcher())
	51	<< "DragDropTabSwitcherPrivate::timeoutScroll: "
	52	"Unknown scroll button";
	53	}
	54	});
	55	}
	56
	57	bool isScrollTabButton(QAbstractButton button, QTabBar tabBar)
	58	{
	59	auto isNextOrPreviousTabButton = true;
	60
	61	if (tabBar->isAncestorOf(button)) {
	62	for (auto i = 0; i < tabBar->count(); ++i) {
	63	if (tabBar->tabButton(i, QTabBar::RightSide) == button
	64	\|\| tabBar->tabButton(i, QTabBar::LeftSide) == button) {
	65	isNextOrPreviousTabButton = false;
	66	break;
	67	}
	68	}
	69	}
	70	else {
	71	isNextOrPreviousTabButton = false;
	72	}
	73
	74	return isNextOrPreviousTabButton;
	75	}
	76
	77	QAbstractButton tabScrollButtonAt(const QPoint &pos, QTabBar tabBar)
	78	{
	79
	80	auto globalPos = tabBar->mapToGlobal(pos);
	81
	82	auto widgetUnderMouse = sqpApp->widgetAt(globalPos);
	83	if (auto btn = qobject_cast<QAbstractButton *>(widgetUnderMouse)) {
	84
	85	if (isScrollTabButton(btn, tabBar)) {
	86	return btn;
	87	}
	88	}
	89
	90	return nullptr;
	91	}
	92	};
	93
	94	DragDropTabSwitcher::DragDropTabSwitcher(QObject *parent)
	95	: QObject(parent), impl{spimpl::make_unique_impl<DragDropTabSwitcherPrivate>()}
	96	{
	97	}
	98
	99	void DragDropTabSwitcher::addTabBar(QTabBar *tabBar)
	100	{
	101	impl->m_TabBarList << tabBar;
	102	tabBar->setAcceptDrops(true);
	103	}
	104
	105	void DragDropTabSwitcher::removeTabBar(QTabBar *tabBar)
	106	{
	107	impl->m_TabBarList.removeAll(tabBar);
	108	tabBar->setAcceptDrops(false);
	109	}
	110
	111	bool DragDropTabSwitcher::eventFilter(QObject obj, QEvent event)
	112	{
	113	if (event->type() == QEvent::DragMove) {
	114
	115	if (impl->m_CurrentTabBar) {
	116
	117	QWidget w = static_cast<QWidget >(obj);
	118	if (!impl->m_CurrentTabBar->isAncestorOf(w)) {
	119	return false;
	120	}
	121
	122	auto moveEvent = static_cast<QDragMoveEvent *>(event);
	123
	124	auto scrollButton = impl->tabScrollButtonAt(moveEvent->pos(), impl->m_CurrentTabBar);
	125
	126	if (!scrollButton) {
	127
	128	auto tabIndex = impl->m_CurrentTabBar->tabAt(moveEvent->pos());
	129	if (tabIndex >= 0 && tabIndex != impl->m_CurrentTabBar->currentIndex()) {
	130	// The mouse is over an unselected tab
	131	if (!impl->m_TabSwitchTimer->isActive()
	132	\|\| tabIndex != impl->m_HoveredTabIndex) {
	133	impl->m_HoveredTabIndex = tabIndex;
	134	impl->m_TabSwitchTimer->start();
	135	}
	136	else {
	137	// do nothing, timer already running
	138	}
	139	}
	140	else {
	141	impl->m_TabSwitchTimer->stop();
	142	}
	143
	144	impl->m_ScrollButtonsTimer->stop();
	145	}
	146	else {
	147	// The mouse is over a scroll button
	148	// click it in a loop with a timer
	149	if (!impl->m_ScrollButtonsTimer->isActive()
	150	\|\| impl->m_HoveredScrollButton != scrollButton) {
	151	impl->m_HoveredScrollButton = scrollButton;
	152	impl->m_ScrollButtonsTimer->start();
	153	}
	154	}
	155	}
	156	}
	157	else if (event->type() == QEvent::DragEnter) {
	158	QWidget w = static_cast<QWidget >(obj);
	159
	160	for (auto tabBar : impl->m_TabBarList) {
	161	if (w == tabBar) {
	162	auto enterEvent = static_cast<QDragEnterEvent *>(event);
	163	enterEvent->acceptProposedAction();
	164	enterEvent->setDropAction(Qt::IgnoreAction);
	165	impl->m_CurrentTabBar = tabBar;
	166	break;
	167	}
	168	}
	169	}
	170	else if (event->type() == QEvent::DragLeave \|\| event->type() == QEvent::Drop) {
	171	if (impl->m_CurrentTabBar) {
	172	impl->m_HoveredTabIndex = -1;
	173	impl->m_TabSwitchTimer->stop();
	174	impl->m_CurrentTabBar = nullptr;
	175	impl->m_ScrollButtonsTimer->stop();
	176	}
	177	}
	178
	179	return false;
	180	}

gui/include/DragAndDrop/DragDropHelper.h +4 0

             #ifndef SCIQLOP_DRAGDROPHELPER_H
             #define SCIQLOP_DRAGDROPHELPER_H
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             #include <QWidget>
             class QVBoxLayout;
             class QScrollArea;
+            class QTabBar;
             class VisualizationDragWidget;
             class VisualizationDragDropContainer;
             class QMimeData;
             Q_DECLARE_LOGGING_CATEGORY(LOG_DragDropHelper)
             /**
              * @brief Helper class for drag&drop operations.
              * @note The helper is accessible from the sqpApp singleton and  has the same life as the whole
              * application (like a controller). But contrary to a controller, it doesn't live in a thread and
              * can interect with the gui.
              * @see SqpApplication
              */
             class DragDropHelper {
             public:
                 static const QString MIME_TYPE_GRAPH;
                 static const QString MIME_TYPE_ZONE;
                 enum class PlaceHolderType { Default, Graph, Zone };
                 DragDropHelper();
                 virtual ~DragDropHelper();
                 /// Resets some internal variables. Must be called before any new drag&drop operation.
                 void resetDragAndDrop();
                 /// Sets the visualization widget currently being drag on the visualization.
                 void setCurrentDragWidget(VisualizationDragWidget *dragWidget);
                 /// Returns the visualization widget currently being drag on the visualization.
                 /// Can be null if a new visualization widget is intended to be created by the drag&drop
                 /// operation.
                 VisualizationDragWidget *getCurrentDragWidget() const;
                 QWidget &placeHolder() const;
                 void insertPlaceHolder(QVBoxLayout *layout, int index, PlaceHolderType type,
                                        const QString &topLabelText);
                 void removePlaceHolder();
                 bool isPlaceHolderSet() const;
                 /// Checks if the specified mime data is valid for a drop in the visualization
                 bool checkMimeDataForVisualization(const QMimeData *mimeData,
                                                    VisualizationDragDropContainer *dropContainer);
                 void addDragDropScrollArea(QScrollArea *scrollArea);
                 void removeDragDropScrollArea(QScrollArea *scrollArea);
+                void addDragDropTabBar(QTabBar *tabBar);
+                void removeDragDropTabBar(QTabBar *tabBar);
                 QUrl imageTemporaryUrl(const QImage &image) const;
                 void setHightlightedDragWidget(VisualizationDragWidget *dragWidget);
                 VisualizationDragWidget *getHightlightedDragWidget() const;
             private:
                 class DragDropHelperPrivate;
                 spimpl::unique_impl_ptr<DragDropHelperPrivate> impl;
             };
             #endif // SCIQLOP_DRAGDROPHELPER_H

gui/meson.build +2 0

             gui_moc_headers = [
               'include/DataSource/DataSourceWidget.h',
               'include/DataSource/DataSourceTreeWidget.h',
               'include/Settings/SqpSettingsDialog.h',
               'include/Settings/SqpSettingsGeneralWidget.h',
               'include/SidePane/SqpSidePane.h',
               'include/SqpApplication.h',
               'include/DragAndDrop/DragDropHelper.h',
               'include/DragAndDrop/DragDropScroller.h',
+              'include/DragAndDrop/DragDropTabSwitcher.h',
               'include/TimeWidget/TimeWidget.h',
               'include/Variable/VariableInspectorWidget.h',
               'include/Variable/VariableInspectorTableView.h',
               'include/Variable/RenameVariableDialog.h',
               'include/Visualization/qcustomplot.h',
               'include/Visualization/VisualizationGraphWidget.h',
               'include/Visualization/VisualizationTabWidget.h',
               'include/Visualization/VisualizationWidget.h',
               'include/Visualization/VisualizationZoneWidget.h',
               'include/Visualization/VisualizationDragDropContainer.h',
               'include/Visualization/VisualizationDragWidget.h'
             ]
             gui_ui_files = [
               'ui/DataSource/DataSourceWidget.ui',
               'ui/Settings/SqpSettingsDialog.ui',
               'ui/Settings/SqpSettingsGeneralWidget.ui',
               'ui/SidePane/SqpSidePane.ui',
               'ui/TimeWidget/TimeWidget.ui',
               'ui/Variable/VariableInspectorWidget.ui',
               'ui/Variable/RenameVariableDialog.ui',
               'ui/Variable/VariableMenuHeaderWidget.ui',
               'ui/Visualization/VisualizationGraphWidget.ui',
               'ui/Visualization/VisualizationTabWidget.ui',
               'ui/Visualization/VisualizationWidget.ui',
               'ui/Visualization/VisualizationZoneWidget.ui'
             ]
             gui_qresources = ['resources/sqpguiresources.qrc']
             gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers,
                                            ui_files : gui_ui_files,
                                            qresources : gui_qresources)
             gui_sources = [
               'src/SqpApplication.cpp',
               'src/DragAndDrop/DragDropHelper.cpp',
               'src/DragAndDrop/DragDropScroller.cpp',
+              'src/DragAndDrop/DragDropTabSwitcher.cpp',
               'src/Common/ColorUtils.cpp',
               'src/Common/VisualizationDef.cpp',
               'src/DataSource/DataSourceTreeWidgetItem.cpp',
               'src/DataSource/DataSourceTreeWidgetHelper.cpp',
               'src/DataSource/DataSourceWidget.cpp',
               'src/DataSource/DataSourceTreeWidget.cpp',
               'src/Settings/SqpSettingsDialog.cpp',
               'src/Settings/SqpSettingsGeneralWidget.cpp',
               'src/SidePane/SqpSidePane.cpp',
               'src/TimeWidget/TimeWidget.cpp',
               'src/Variable/VariableInspectorWidget.cpp',
               'src/Variable/VariableInspectorTableView.cpp',
               'src/Variable/VariableMenuHeaderWidget.cpp',
               'src/Variable/RenameVariableDialog.cpp',
               'src/Visualization/VisualizationGraphHelper.cpp',
               'src/Visualization/VisualizationGraphRenderingDelegate.cpp',
               'src/Visualization/VisualizationGraphWidget.cpp',
               'src/Visualization/VisualizationTabWidget.cpp',
               'src/Visualization/VisualizationWidget.cpp',
               'src/Visualization/VisualizationZoneWidget.cpp',
               'src/Visualization/qcustomplot.cpp',
               'src/Visualization/QCustomPlotSynchronizer.cpp',
               'src/Visualization/operations/FindVariableOperation.cpp',
               'src/Visualization/operations/GenerateVariableMenuOperation.cpp',
               'src/Visualization/operations/MenuBuilder.cpp',
               'src/Visualization/operations/RemoveVariableOperation.cpp',
               'src/Visualization/operations/RescaleAxeOperation.cpp',
               'src/Visualization/VisualizationDragDropContainer.cpp',
               'src/Visualization/VisualizationDragWidget.cpp'
             ]
             gui_inc = include_directories(['include'])
             sciqlop_gui_lib = library('sciqlopgui',
                                    gui_sources,
                                    gui_moc_files,
                                    include_directories : [gui_inc],
                                    dependencies : [ qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core],
                                    install : true
                                    )
             sciqlop_gui = declare_dependency(link_with : sciqlop_gui_lib,
                                             include_directories : gui_inc,
                                             dependencies : [qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core])

gui/src/DragAndDrop/DragDropHelper.cpp +16 -2

             #include "DragAndDrop/DragDropHelper.h"
             #include "DragAndDrop/DragDropScroller.h"
+            #include "DragAndDrop/DragDropTabSwitcher.h"
             #include "SqpApplication.h"
             #include "Visualization/VisualizationDragDropContainer.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/operations/FindVariableOperation.h"
             #include "Variable/Variable.h"
             #include "Variable/VariableController.h"
             #include "Common/MimeTypesDef.h"
             #include "Common/VisualizationDef.h"
             #include <QDir>
             #include <QLabel>
             #include <QUrl>
             #include <QVBoxLayout>
-            Q_LOGGING_CATEGORY(LOG_DragDropHelper, "DragDrophelper")
+            Q_LOGGING_CATEGORY(LOG_DragDropHelper, "DragDropHelper")
             struct DragDropHelper::DragDropHelperPrivate {
                 VisualizationDragWidget *m_CurrentDragWidget = nullptr;
                 std::unique_ptr<QWidget> m_PlaceHolder = nullptr;
                 QLabel *m_PlaceHolderLabel;
                 QWidget *m_PlaceBackground;
                 std::unique_ptr<DragDropScroller> m_DragDropScroller = nullptr;
+                std::unique_ptr<DragDropTabSwitcher> m_DragDropTabSwitcher = nullptr;
                 QString m_ImageTempUrl; // Temporary file for image url generated by the drag & drop. Not using
                                         // QTemporaryFile to have a name which is not generated.
                 VisualizationDragWidget *m_HighlightedDragWidget = nullptr;
                 QMetaObject::Connection m_DragWidgetDestroyedConnection;
                 QMetaObject::Connection m_HighlightedWidgetDestroyedConnection;
                 explicit DragDropHelperPrivate()
                         : m_PlaceHolder{std::make_unique<QWidget>()},
-                          m_DragDropScroller{std::make_unique<DragDropScroller>()}
+                          m_DragDropScroller{std::make_unique<DragDropScroller>()},
+                          m_DragDropTabSwitcher{std::make_unique<DragDropTabSwitcher>()}
                 {
                     auto layout = new QVBoxLayout{m_PlaceHolder.get()};
                     layout->setSpacing(0);
                     layout->setContentsMargins(0, 0, 0, 0);
                     m_PlaceHolderLabel = new QLabel{"", m_PlaceHolder.get()};
                     m_PlaceHolderLabel->setMinimumHeight(25);
                     layout->addWidget(m_PlaceHolderLabel);
                     m_PlaceBackground = new QWidget{m_PlaceHolder.get()};
                     m_PlaceBackground->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                     layout->addWidget(m_PlaceBackground);
                     sqpApp->installEventFilter(m_DragDropScroller.get());
+                    sqpApp->installEventFilter(m_DragDropTabSwitcher.get());
                     m_ImageTempUrl = QDir::temp().absoluteFilePath("Sciqlop_graph.png");
                 }
                 void preparePlaceHolder(DragDropHelper::PlaceHolderType type, const QString &topLabelText) 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(0, GRAPH_MINIMUM_HEIGHT);
                         m_PlaceHolder->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                     }
                     switch (type) {
                         case DragDropHelper::PlaceHolderType::Graph:
                             m_PlaceBackground->setStyleSheet(
                                 "background-color: #BBD5EE; border: 1px solid #2A7FD4");
                             break;
                         case DragDropHelper::PlaceHolderType::Zone:
                         case DragDropHelper::PlaceHolderType::Default:
                             m_PlaceBackground->setStyleSheet(
                                 "background-color: #BBD5EE; border: 2px solid #2A7FD4");
                             m_PlaceHolderLabel->setStyleSheet("color: #2A7FD4");
                             break;
                     }
                     m_PlaceHolderLabel->setText(topLabelText);
                     m_PlaceHolderLabel->setVisible(!topLabelText.isEmpty());
                 }
             };
             DragDropHelper::DragDropHelper() : impl{spimpl::make_unique_impl<DragDropHelperPrivate>()} {}
             DragDropHelper::~DragDropHelper()
             {
                 QFile::remove(impl->m_ImageTempUrl);
             }
             void DragDropHelper::resetDragAndDrop()
             {
                 setCurrentDragWidget(nullptr);
                 impl->m_HighlightedDragWidget = nullptr;
             }
             void DragDropHelper::setCurrentDragWidget(VisualizationDragWidget *dragWidget)
             {
                 if (impl->m_CurrentDragWidget) {
                     QObject::disconnect(impl->m_DragWidgetDestroyedConnection);
                 }
                 if (dragWidget) {
                     // ensures the impl->m_CurrentDragWidget is reset when the widget is destroyed
                     impl->m_DragWidgetDestroyedConnection
                         = QObject::connect(dragWidget, &VisualizationDragWidget::destroyed,
                                            [this]() { impl->m_CurrentDragWidget = nullptr; });
                 }
                 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, PlaceHolderType type,
                                                    const QString &topLabelText)
             {
                 removePlaceHolder();
                 impl->preparePlaceHolder(type, topLabelText);
                 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);
             }
+            void DragDropHelper::addDragDropTabBar(QTabBar *tabBar)
+            {
+                impl->m_DragDropTabSwitcher->addTabBar(tabBar);
+            }
+            void DragDropHelper::removeDragDropTabBar(QTabBar *tabBar)
+            {
+                impl->m_DragDropTabSwitcher->removeTabBar(tabBar);
+            }
             QUrl DragDropHelper::imageTemporaryUrl(const QImage &image) const
             {
                 image.save(impl->m_ImageTempUrl);
                 return QUrl::fromLocalFile(impl->m_ImageTempUrl);
             }
             void DragDropHelper::setHightlightedDragWidget(VisualizationDragWidget *dragWidget)
             {
                 if (impl->m_HighlightedDragWidget) {
                     impl->m_HighlightedDragWidget->highlightForMerge(false);
                     QObject::disconnect(impl->m_HighlightedWidgetDestroyedConnection);
                 }
                 if (dragWidget) {
                     dragWidget->highlightForMerge(true);
                     // ensures the impl->m_HighlightedDragWidget is reset when the widget is destroyed
                     impl->m_DragWidgetDestroyedConnection
                         = QObject::connect(dragWidget, &VisualizationDragWidget::destroyed,
                                            [this]() { impl->m_HighlightedDragWidget = nullptr; });
                 }
                 impl->m_HighlightedDragWidget = dragWidget;
             }
             VisualizationDragWidget *DragDropHelper::getHightlightedDragWidget() const
             {
                 return impl->m_HighlightedDragWidget;
             }
             bool DragDropHelper::checkMimeDataForVisualization(const QMimeData *mimeData,
                                                                VisualizationDragDropContainer *dropContainer)
             {
                 if (!mimeData || !dropContainer) {
                     qCWarning(LOG_DragDropHelper()) << QObject::tr(
                         "DragDropHelper::checkMimeDataForVisualization, invalid input parameters.");
                     Q_ASSERT(false);
                     return false;
                 }
                 auto result = false;
                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     if (variables.count() == 1) {
                         auto variable = variables.first();
                         if (variable->dataSeries() != nullptr) {
                             // Check that the variable is not already in a graph
                             auto parent = dropContainer->parentWidget();
                             while (parent && qobject_cast<VisualizationWidget *>(parent) == nullptr) {
                                 parent = parent->parentWidget(); // Search for the top level VisualizationWidget
                             }
                             if (parent) {
                                 auto visualizationWidget = static_cast<VisualizationWidget *>(parent);
                                 FindVariableOperation findVariableOperation{variable};
                                 visualizationWidget->accept(&findVariableOperation);
                                 auto variableContainers = findVariableOperation.result();
                                 if (variableContainers.empty()) {
                                     result = true;
                                 }
                                 else {
                                     // result = false: the variable already exist in the visualisation
                                 }
                             }
                             else {
                                 qCWarning(LOG_DragDropHelper()) << QObject::tr(
                                     "DragDropHelper::checkMimeDataForVisualization, the parent "
                                     "VisualizationWidget cannot be found. Cannot check if the variable is "
                                     "already used or not.");
                             }
                         }
                         else {
                             // result = false: the variable is not fully loaded
                         }
                     }
                     else {
                         // result = false: cannot drop multiple variables in the visualisation
                     }
                 }
                 else {
                     // Other MIME data
                     // no special rules, accepted by default
                     result = true;
                 }
                 return result;
             }

gui/src/Visualization/VisualizationWidget.cpp +6 0

             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/operations/FindVariableOperation.h"
             #include "Visualization/operations/GenerateVariableMenuOperation.h"
             #include "Visualization/operations/RemoveVariableOperation.h"
             #include "Visualization/operations/RescaleAxeOperation.h"
             #include "Visualization/qcustomplot.h"
             #include "ui_VisualizationWidget.h"
+            #include "DragAndDrop/DragDropHelper.h"
+            #include "SqpApplication.h"
             #include <QToolButton>
             Q_LOGGING_CATEGORY(LOG_VisualizationWidget, "VisualizationWidget")
             VisualizationWidget::VisualizationWidget(QWidget *parent)
                     : QWidget{parent}, ui{new Ui::VisualizationWidget}
             {
                 ui->setupUi(this);
                 auto addTabViewButton = new QToolButton{ui->tabWidget};
                 addTabViewButton->setText(tr("Add View"));
                 addTabViewButton->setCursor(Qt::ArrowCursor);
                 ui->tabWidget->setCornerWidget(addTabViewButton, Qt::TopRightCorner);
                 auto enableMinimumCornerWidgetSize = [this](bool enable) {
                     auto tabViewCornerWidget = ui->tabWidget->cornerWidget();
                     auto width = enable ? tabViewCornerWidget->width() : 0;
                     auto height = enable ? tabViewCornerWidget->height() : 0;
                     tabViewCornerWidget->setMinimumHeight(height);
                     tabViewCornerWidget->setMinimumWidth(width);
                     ui->tabWidget->setMinimumHeight(height);
                     ui->tabWidget->setMinimumWidth(width);
                 };
                 auto addTabView = [this, enableMinimumCornerWidgetSize]() {
                     auto widget = new VisualizationTabWidget{QString{"View %1"}.arg(ui->tabWidget->count() + 1),
                                                              ui->tabWidget};
                     auto index = ui->tabWidget->addTab(widget, widget->name());
                     if (ui->tabWidget->count() > 0) {
                         enableMinimumCornerWidgetSize(false);
                     }
                     qCInfo(LOG_VisualizationWidget()) << tr("add the tab of index %1").arg(index);
                 };
                 auto removeTabView = [this, enableMinimumCornerWidgetSize](int index) {
                     if (ui->tabWidget->count() == 1) {
                         enableMinimumCornerWidgetSize(true);
                     }
                     // Removes widget from tab and closes it
                     auto widget = ui->tabWidget->widget(index);
                     ui->tabWidget->removeTab(index);
                     if (widget) {
                         widget->close();
                     }
                     qCInfo(LOG_VisualizationWidget()) << tr("remove the tab of index %1").arg(index);
                 };
                 ui->tabWidget->setTabsClosable(true);
                 connect(addTabViewButton, &QToolButton::clicked, addTabView);
                 connect(ui->tabWidget, &QTabWidget::tabCloseRequested, removeTabView);
+                sqpApp->dragDropHelper().addDragDropTabBar(ui->tabWidget->tabBar());
                 // Adds default tab
                 addTabView();
             }
             VisualizationWidget::~VisualizationWidget()
             {
+                sqpApp->dragDropHelper().removeDragDropTabBar(ui->tabWidget->tabBar());
                 delete ui;
             }
             void VisualizationWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor for tab children
                     for (auto i = 0; i < ui->tabWidget->count(); ++i) {
                         // Widgets different from tabs are not visited (no action)
                         if (auto visualizationTabWidget
                             = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->widget(i))) {
                             visualizationTabWidget->accept(visitor);
                         }
                     }
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationWidget::canDrop(const Variable &variable) const
             {
                 // The main widget can never accomodate a variable
                 Q_UNUSED(variable);
                 return false;
             }
             bool VisualizationWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationWidget::name() const
             {
                 return QStringLiteral("MainView");
             }
             void VisualizationWidget::attachVariableMenu(
                 QMenu *menu, const QVector<std::shared_ptr<Variable> > &variables) noexcept
             {
                 // Menu is generated only if there is a single variable
                 if (variables.size() == 1) {
                     if (auto variable = variables.first()) {
                         // Gets the containers of the variable
                         FindVariableOperation findVariableOperation{variable};
                         accept(&findVariableOperation);
                         auto variableContainers = findVariableOperation.result();
                         // Generates the actions that make it possible to visualize the variable
                         GenerateVariableMenuOperation generateVariableMenuOperation{
                             menu, variable, std::move(variableContainers)};
                         accept(&generateVariableMenuOperation);
                     }
                     else {
                         qCCritical(LOG_VisualizationWidget()) << tr(
                             "Can't generate the menu relative to the visualization: the variable is null");
                     }
                 }
                 else {
                     qCDebug(LOG_VisualizationWidget())
                         << tr("No generation of the menu related to the visualization: several variables are "
                               "selected");
                 }
             }
             void VisualizationWidget::onVariableAboutToBeDeleted(std::shared_ptr<Variable> variable) noexcept
             {
                 // Calls the operation of removing all references to the variable in the visualization
                 auto removeVariableOperation = RemoveVariableOperation{variable};
                 accept(&removeVariableOperation);
             }
             void VisualizationWidget::onRangeChanged(std::shared_ptr<Variable> variable,
                                                      const SqpRange &range) noexcept
             {
                 // Calls the operation of rescaling all graph that contrains variable in the visualization
                 auto rescaleVariableOperation = RescaleAxeOperation{variable, range};
                 accept(&rescaleVariableOperation);
             }
             void VisualizationWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes tabs in the widget
                 for (auto i = 0; i < ui->tabWidget->count(); ++i) {
                     if (auto visualizationTabWidget
                         = dynamic_cast<VisualizationTabWidget *>(ui->tabWidget->widget(i))) {
                         visualizationTabWidget->close();
                     }
                 }
                 QWidget::closeEvent(event);
             }

General Comments 3

trabillard

|

Pull request updated. Auto status change to "Under Review"

Changed commits:
  * 1 added
  * 0 removed

Changed files:
  * A core/tests/meson.build

Write
Preview

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

	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