GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1259:e88efff11587

Refactoring of catalogue display using a QTreeView and a custom model based on QTreeWidgetItem

trabillard -

r1259:e88efff11587

parent child

Context file:

r1259:e88efff11587

gui/include/Catalogue/CatalogueTreeModel.h created 644 +47 0

@@ -0,0 +1,47
	1	#ifndef SCIQLOP_CATALOGUETREEMODEL_H
	2	#define SCIQLOP_CATALOGUETREEMODEL_H
	3
	4	#include <Common/spimpl.h>
	5	#include <QAbstractItemModel>
	6	#include <QTreeWidgetItem>
	7
	8	/**
	9	* @brief Model to display catalogue items based on QTreeWidgetItem
	10	* @warning Do not use the method QTreeWidgetItem::treeWidget for an item added to this model or the application will crash
	11	*/
	12	class CatalogueTreeModel : public QAbstractItemModel {
	13	Q_OBJECT
	14
	15	signals:
	16	void itemRenamed(const QModelIndex &index);
	17
	18	public:
	19	CatalogueTreeModel(QObject *parent = nullptr);
	20
	21	enum class Column { Name, Validation, Count };
	22
	23	QModelIndex addTopLevelItem(QTreeWidgetItem *item);
	24	int topLevelItemCount() const;
	25	QTreeWidgetItem *topLevelItem(int i) const;
	26
	27	void addChildItem(QTreeWidgetItem *child, const QModelIndex &parentIndex);
	28
	29	QTreeWidgetItem *item(const QModelIndex &index) const;
	30	QModelIndex indexOf(QTreeWidgetItem *item, int column = 0) const;
	31
	32	// model
	33	QModelIndex index(int row, int column,
	34	const QModelIndex &parent = QModelIndex()) const override;
	35	QModelIndex parent(const QModelIndex &index) const override;
	36	int rowCount(const QModelIndex &parent) const override;
	37	int columnCount(const QModelIndex &parent) const override;
	38	Qt::ItemFlags flags(const QModelIndex &index) const override;
	39	QVariant data(const QModelIndex &index, int role) const override;
	40	bool setData(const QModelIndex &index, const QVariant &value, int role) override;
	41
	42	private:
	43	class CatalogueTreeModelPrivate;
	44	spimpl::unique_impl_ptr<CatalogueTreeModelPrivate> impl;
	45	};
	46
	47	#endif // CATALOGUETREEMODEL_H

gui/src/Catalogue/CatalogueTreeModel.cpp created 644 +169 0

@@ -0,0 +1,169
	1	#include "Catalogue/CatalogueTreeModel.h"
	2
	3	#include <QTreeWidgetItem>
	4	#include <memory>
	5
	6	struct CatalogueTreeModel::CatalogueTreeModelPrivate {
	7	std::unique_ptr<QTreeWidgetItem> m_RootItem = nullptr;
	8
	9	CatalogueTreeModelPrivate() : m_RootItem{std::make_unique<QTreeWidgetItem>()} {}
	10	};
	11
	12	CatalogueTreeModel::CatalogueTreeModel(QObject *parent)
	13	: QAbstractItemModel(parent), impl{spimpl::make_unique_impl<CatalogueTreeModelPrivate>()}
	14	{
	15	}
	16
	17	QModelIndex CatalogueTreeModel::addTopLevelItem(QTreeWidgetItem *item)
	18	{
	19	beginInsertRows(QModelIndex(), impl->m_RootItem->childCount(), impl->m_RootItem->childCount());
	20	impl->m_RootItem->addChild(item);
	21	endInsertRows();
	22
	23	return index(impl->m_RootItem->childCount() - 1, 0);
	24	}
	25
	26	int CatalogueTreeModel::topLevelItemCount() const
	27	{
	28	return impl->m_RootItem->childCount();
	29	}
	30
	31	QTreeWidgetItem *CatalogueTreeModel::topLevelItem(int i) const
	32	{
	33	return impl->m_RootItem->child(i);
	34	}
	35
	36	void CatalogueTreeModel::addChildItem(QTreeWidgetItem *child, const QModelIndex &parentIndex)
	37	{
	38	auto parentItem = item(parentIndex);
	39	beginInsertRows(parentIndex, parentItem->childCount(), parentItem->childCount());
	40	parentItem->addChild(child);
	41	endInsertRows();
	42	}
	43
	44	QTreeWidgetItem *CatalogueTreeModel::item(const QModelIndex &index) const
	45	{
	46	return static_cast<QTreeWidgetItem *>(index.internalPointer());
	47	}
	48
	49	QModelIndex CatalogueTreeModel::indexOf(QTreeWidgetItem *item, int column) const
	50	{
	51	auto parentItem = item->parent();
	52	if (!parentItem) {
	53	return QModelIndex();
	54	}
	55
	56	auto row = parentItem->indexOfChild(item);
	57	return createIndex(row, column, item);
	58	}
	59
	60	QModelIndex CatalogueTreeModel::index(int row, int column, const QModelIndex &parent) const
	61	{
	62	if (!hasIndex(row, column, parent)) {
	63	return QModelIndex();
	64	}
	65
	66	QTreeWidgetItem *parentItem = nullptr;
	67
	68	if (!parent.isValid()) {
	69	parentItem = impl->m_RootItem.get();
	70	}
	71	else {
	72	parentItem = static_cast<QTreeWidgetItem *>(parent.internalPointer());
	73	}
	74
	75	QTreeWidgetItem *childItem = parentItem->child(row);
	76	if (childItem) {
	77	return createIndex(row, column, childItem);
	78	}
	79
	80	return QModelIndex();
	81	}
	82
	83
	84	QModelIndex CatalogueTreeModel::parent(const QModelIndex &index) const
	85	{
	86	if (!index.isValid()) {
	87	return QModelIndex();
	88	}
	89
	90	auto childItem = static_cast<QTreeWidgetItem *>(index.internalPointer());
	91	auto parentItem = childItem->parent();
	92
	93	if (parentItem == nullptr \|\| parentItem->parent() == nullptr) {
	94	return QModelIndex();
	95	}
	96
	97	auto row = parentItem->parent()->indexOfChild(parentItem);
	98	return createIndex(row, 0, parentItem);
	99	}
	100
	101	int CatalogueTreeModel::rowCount(const QModelIndex &parent) const
	102	{
	103	QTreeWidgetItem *parentItem = nullptr;
	104	if (parent.column() > 0) {
	105	return 0;
	106	}
	107
	108	if (!parent.isValid()) {
	109	parentItem = impl->m_RootItem.get();
	110	}
	111	else {
	112	parentItem = static_cast<QTreeWidgetItem *>(parent.internalPointer());
	113	}
	114
	115	return parentItem->childCount();
	116	}
	117
	118	int CatalogueTreeModel::columnCount(const QModelIndex &parent) const
	119	{
	120	return (int)Column::Count;
	121	}
	122
	123	Qt::ItemFlags CatalogueTreeModel::flags(const QModelIndex &index) const
	124	{
	125	if (index.column() == (int)Column::Validation) {
	126	return Qt::NoItemFlags;
	127	}
	128
	129	auto item = static_cast<QTreeWidgetItem *>(index.internalPointer());
	130	if (item) {
	131	return item->flags();
	132	}
	133
	134	return Qt::NoItemFlags;
	135	}
	136
	137	QVariant CatalogueTreeModel::data(const QModelIndex &index, int role) const
	138	{
	139	if (!index.isValid()) {
	140	return QModelIndex();
	141	}
	142
	143	auto item = static_cast<QTreeWidgetItem *>(index.internalPointer());
	144	if (item) {
	145	return item->data(index.column(), role);
	146	}
	147
	148	return QModelIndex();
	149	}
	150
	151	bool CatalogueTreeModel::setData(const QModelIndex &index, const QVariant &value, int role)
	152	{
	153	if (!index.isValid()) {
	154	return false;
	155	}
	156
	157	auto item = static_cast<QTreeWidgetItem *>(index.internalPointer());
	158	if (item) {
	159	item->setData(index.column(), role, value);
	160
	161	if (index.column() == (int)Column::Name) {
	162	emit itemRenamed(index);
	163	}
	164
	165	return true;
	166	}
	167
	168	return false;
	169	}

gui/include/Catalogue/CatalogueTreeWidgetItem.h 0 -2

             #ifndef SCIQLOP_CATALOGUETREEWIDGETITEM_H
             #define SCIQLOP_CATALOGUETREEWIDGETITEM_H
             #include <Common/spimpl.h>
             #include <QTreeWidgetItem>
             class DBCatalogue;
             class CatalogueTreeWidgetItem : public QTreeWidgetItem {
             public:
                 CatalogueTreeWidgetItem(std::shared_ptr<DBCatalogue> catalogue,
                                         int type = QTreeWidgetItem::Type);
                 QVariant data(int column, int role) const override;
                 void setData(int column, int role, const QVariant &value) override;
                 /// Returns the catalogue represented by the item
                 std::shared_ptr<DBCatalogue> catalogue() const;
-                /// Displays or hides the save and cancel buttons indicating that the catalogue has unsaved
-                /// changes
                 void setHasChanges(bool value);
                 /// Returns true if the widget indicating the event has unsaved changes is displayed
                 bool hasChanges();
                 /// Refreshes the data displayed by the item from the catalogue
                 void refresh();
             private:
                 class CatalogueTreeWidgetItemPrivate;
                 spimpl::unique_impl_ptr<CatalogueTreeWidgetItemPrivate> impl;
             };
             #endif // SCIQLOP_CATALOGUETREEWIDGETITEM_H

gui/meson.build +4 -2

             qxorm_dep = dependency('QxOrm', required : true, fallback:['QxOrm','qxorm_dep'])
             catalogueapi_dep = dependency('CatalogueAPI', required : true, fallback:['CatalogueAPI','CatalogueAPI_dep'])
             gui_moc_headers = [
               'include/DataSource/DataSourceWidget.h',
               'include/Settings/SqpSettingsDialog.h',
               'include/Settings/SqpSettingsGeneralWidget.h',
               'include/SidePane/SqpSidePane.h',
               'include/SqpApplication.h',
               'include/DragAndDrop/DragDropScroller.h',
               'include/DragAndDrop/DragDropTabSwitcher.h',
               'include/TimeWidget/TimeWidget.h',
               'include/Variable/VariableInspectorWidget.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',
               'include/Visualization/ColorScaleEditor.h',
               'include/Actions/SelectionZoneAction.h',
               'include/Visualization/VisualizationMultiZoneSelectionDialog.h',
               'include/Catalogue/CatalogueExplorer.h',
               'include/Catalogue/CatalogueEventsWidget.h',
               'include/Catalogue/CatalogueSideBarWidget.h',
               'include/Catalogue/CatalogueInspectorWidget.h',
               'include/Catalogue/CatalogueEventsModel.h',
-              'include/Catalogue/CreateEventDialog.h'
+              'include/Catalogue/CreateEventDialog.h',
+              'include/Catalogue/CatalogueTreeModel.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',
               'ui/Visualization/ColorScaleEditor.ui',
               'ui/Visualization/VisualizationMultiZoneSelectionDialog.ui',
               'ui/Catalogue/CatalogueExplorer.ui',
               'ui/Catalogue/CatalogueEventsWidget.ui',
               'ui/Catalogue/CatalogueSideBarWidget.ui',
               'ui/Catalogue/CatalogueInspectorWidget.ui',
               'ui/Catalogue/CreateEventDialog.ui'
             ]
             gui_qresources = ['resources/sqpguiresources.qrc']
             rcc_gen = generator(rcc,
                             output  : 'qrc_@BASENAME@.cpp',
                             arguments : [
                              '--output',
                              '@OUTPUT@',
                              '@INPUT@',
                              '@EXTRA_ARGS@'])
             rcc_files = rcc_gen.process(gui_qresources, extra_args : ['-name', 'sqpguiresources'])
             gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers,
                                            ui_files : gui_ui_files)
             gui_sources = [
               'src/SqpApplication.cpp',
               'src/DragAndDrop/DragDropGuiController.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',
               'src/Visualization/AxisRenderingUtils.cpp',
               'src/Visualization/PlottablesRenderingUtils.cpp',
               'src/Visualization/MacScrollBarStyle.cpp',
               'src/Visualization/VisualizationCursorItem.cpp',
               'src/Visualization/ColorScaleEditor.cpp',
               'src/Visualization/SqpColorScale.cpp',
               'src/Visualization/QCPColorMapIterator.cpp',
               'src/Visualization/VisualizationSelectionZoneItem.cpp',
               'src/Visualization/VisualizationSelectionZoneManager.cpp',
               'src/Actions/SelectionZoneAction.cpp',
               'src/Actions/ActionsGuiController.cpp',
               'src/Visualization/VisualizationActionManager.cpp',
               'src/Visualization/VisualizationMultiZoneSelectionDialog.cpp',
               'src/Catalogue/CatalogueExplorer.cpp',
               'src/Catalogue/CatalogueEventsWidget.cpp',
               'src/Catalogue/CatalogueSideBarWidget.cpp',
               'src/Catalogue/CatalogueInspectorWidget.cpp',
               'src/Catalogue/CatalogueTreeWidgetItem.cpp',
               'src/Catalogue/CatalogueEventsModel.cpp',
               'src/Catalogue/CatalogueExplorerHelper.cpp',
               'src/Catalogue/CatalogueActionManager.cpp',
-              'src/Catalogue/CreateEventDialog.cpp'
+              'src/Catalogue/CreateEventDialog.cpp',
+              'src/Catalogue/CatalogueTreeModel.cpp'
             ]
             gui_inc = include_directories(['include'])
             sciqlop_gui_lib = library('sciqlopgui',
                                    gui_sources,
                                    gui_moc_files,
                                    rcc_files,
                                    include_directories : [gui_inc],
                                    dependencies : [ qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core, catalogueapi_dep],
                                    install : true
                                    )
             sciqlop_gui = declare_dependency(link_with : sciqlop_gui_lib,
                                             include_directories : gui_inc,
                                             dependencies : [qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core, catalogueapi_dep])

gui/src/Catalogue/CatalogueSideBarWidget.cpp +106 -58

             #include "Catalogue/CatalogueSideBarWidget.h"
             #include "ui_CatalogueSideBarWidget.h"
             #include <SqpApplication.h>
             #include <Catalogue/CatalogueController.h>
+            #include <Catalogue/CatalogueExplorerHelper.h>
+            #include <Catalogue/CatalogueTreeModel.h>
             #include <Catalogue/CatalogueTreeWidgetItem.h>
             #include <CatalogueDao.h>
             #include <ComparaisonPredicate.h>
             #include <DBCatalogue.h>
             #include <QMenu>
             Q_LOGGING_CATEGORY(LOG_CatalogueSideBarWidget, "CatalogueSideBarWidget")
             constexpr auto ALL_EVENT_ITEM_TYPE = QTreeWidgetItem::UserType;
             constexpr auto TRASH_ITEM_TYPE = QTreeWidgetItem::UserType + 1;
             constexpr auto CATALOGUE_ITEM_TYPE = QTreeWidgetItem::UserType + 2;
             constexpr auto DATABASE_ITEM_TYPE = QTreeWidgetItem::UserType + 3;
             struct CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate {
-                void configureTreeWidget(QTreeWidget *treeWidget);
+                CatalogueTreeModel *m_TreeModel = nullptr;
-                QTreeWidgetItem *addDatabaseItem(const QString &name, QTreeWidget *treeWidget);
-                QTreeWidgetItem *getDatabaseItem(const QString &name, QTreeWidget *treeWidget);
+                void configureTreeWidget(QTreeView *treeView);
+                QModelIndex addDatabaseItem(const QString &name);
+                QTreeWidgetItem *getDatabaseItem(const QString &name);
                 void addCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue,
-                                      QTreeWidgetItem *parentDatabaseItem);
+                                      const QModelIndex &databaseIndex);
-                CatalogueTreeWidgetItem *getCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue,
+                CatalogueTreeWidgetItem *getCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue) const;
-                                                          QTreeWidget *treeWidget) const;
+                void setHasChanges(bool value, const QModelIndex &index, QTreeView *treeView);
+                bool hasChanges(const QModelIndex &index, QTreeView *treeView);
             };
             CatalogueSideBarWidget::CatalogueSideBarWidget(QWidget *parent)
                     : QWidget(parent),
                       ui(new Ui::CatalogueSideBarWidget),
                       impl{spimpl::make_unique_impl<CatalogueSideBarWidgetPrivate>()}
             {
                 ui->setupUi(this);
-                impl->configureTreeWidget(ui->treeWidget);
-                ui->treeWidget->setColumnCount(2);
+                impl->m_TreeModel = new CatalogueTreeModel(this);
-                ui->treeWidget->header()->setStretchLastSection(false);
+                ui->treeView->setModel(impl->m_TreeModel);
-                ui->treeWidget->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
-                ui->treeWidget->header()->setSectionResizeMode(0, QHeaderView::Stretch);
+                impl->configureTreeWidget(ui->treeView);
+                ui->treeView->header()->setStretchLastSection(false);
+                ui->treeView->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
+                ui->treeView->header()->setSectionResizeMode(0, QHeaderView::Stretch);
                 auto emitSelection = [this]() {
-                    auto selectedItems = ui->treeWidget->selectedItems();
+                    auto selectedItems = ui->treeView->selectionModel()->selectedRows();
                     if (selectedItems.isEmpty()) {
                         emit this->selectionCleared();
                     }
                     else {
                         QVector<std::shared_ptr<DBCatalogue> > catalogues;
                         QStringList databases;
-                        int selectionType = selectedItems.first()->type();
+                        auto firstIndex = selectedItems.first();
+                        auto firstItem = impl->m_TreeModel->item(firstIndex);
+                        if (!firstItem) {
+                            Q_ASSERT(false);
+                            return;
+                        }
+                        auto selectionType = firstItem->type();
-                        for (auto item : ui->treeWidget->selectedItems()) {
+                        for (auto itemIndex : selectedItems) {
-                            if (item->type() == selectionType) {
+                            auto item = impl->m_TreeModel->item(itemIndex);
+                            if (item && item->type() == selectionType) {
                                 switch (selectionType) {
                                     case CATALOGUE_ITEM_TYPE:
                                         catalogues.append(
                                             static_cast<CatalogueTreeWidgetItem *>(item)->catalogue());
                                         break;
                                     case DATABASE_ITEM_TYPE:
                                         selectionType = DATABASE_ITEM_TYPE;
                                         databases.append(item->text(0));
                                     case ALL_EVENT_ITEM_TYPE: // fallthrough
                                     case TRASH_ITEM_TYPE:     // fallthrough
                                     default:
                                         break;
                                 }
                             }
                             else {
                                 // Incoherent multi selection
                                 selectionType = -1;
                                 break;
                             }
                         }
                         switch (selectionType) {
                             case CATALOGUE_ITEM_TYPE:
                                 emit this->catalogueSelected(catalogues);
                                 break;
                             case DATABASE_ITEM_TYPE:
                                 emit this->databaseSelected(databases);
                                 break;
                             case ALL_EVENT_ITEM_TYPE:
                                 emit this->allEventsSelected();
                                 break;
                             case TRASH_ITEM_TYPE:
                                 emit this->trashSelected();
                                 break;
                             default:
                                 emit this->selectionCleared();
                                 break;
                         }
                     }
                 };
-                connect(ui->treeWidget, &QTreeWidget::itemClicked, emitSelection);
+                connect(ui->treeView, &QTreeView::clicked, emitSelection);
-                connect(ui->treeWidget, &QTreeWidget::currentItemChanged, emitSelection);
+                connect(ui->treeView->selectionModel(), &QItemSelectionModel::currentChanged, emitSelection);
-                connect(ui->treeWidget, &QTreeWidget::itemChanged,
+                connect(impl->m_TreeModel, &CatalogueTreeModel::itemRenamed, [emitSelection, this](auto index) {
-                        [emitSelection, this](auto item, auto column) {
+                    auto selectedIndexes = ui->treeView->selectionModel()->selectedRows();
-                            auto selectedItems = ui->treeWidget->selectedItems();
+                    if (selectedIndexes.contains(index)) {
-                            qDebug() << "ITEM CHANGED" << column;
+                        emitSelection();
-                            if (selectedItems.contains(item) && column == 0) {
-                                emitSelection();
+                    auto item = impl->m_TreeModel->item(index);
-                        });
+                    impl->setHasChanges(true, index, ui->treeView);
+                });
-                ui->treeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
+                ui->treeView->setContextMenuPolicy(Qt::CustomContextMenu);
-                connect(ui->treeWidget, &QTreeWidget::customContextMenuRequested, this,
+                connect(ui->treeView, &QTreeWidget::customContextMenuRequested, this,
                         &CatalogueSideBarWidget::onContextMenuRequested);
             }
             CatalogueSideBarWidget::~CatalogueSideBarWidget()
             {
                 delete ui;
             }
             void CatalogueSideBarWidget::setCatalogueChanges(const std::shared_ptr<DBCatalogue> &catalogue,
                                                              bool hasChanges)
             {
-                if (auto catalogueItem = impl->getCatalogueItem(catalogue, ui->treeWidget)) {
+                if (auto catalogueItem = impl->getCatalogueItem(catalogue)) {
-                    catalogueItem->setHasChanges(hasChanges);
+                    auto index = impl->m_TreeModel->indexOf(catalogueItem);
+                    impl->setHasChanges(hasChanges, index, ui->treeView);
                     catalogueItem->refresh();
                 }
             }
             void CatalogueSideBarWidget::onContextMenuRequested(const QPoint &pos)
             {
                 QMenu menu{this};
-                auto currentItem = ui->treeWidget->currentItem();
+                auto currentIndex = ui->treeView->currentIndex();
+                auto currentItem = impl->m_TreeModel->item(currentIndex);
+                if (!currentItem) {
+                    return;
+                }
                 switch (currentItem->type()) {
                     case CATALOGUE_ITEM_TYPE:
-                        menu.addAction("Rename",
+                        menu.addAction("Rename", [this, currentIndex]() { ui->treeView->edit(currentIndex); });
-                                       [this, currentItem]() { ui->treeWidget->editItem(currentItem); });
                         break;
                     case DATABASE_ITEM_TYPE:
                         break;
                     case ALL_EVENT_ITEM_TYPE:
                         break;
                     case TRASH_ITEM_TYPE:
                         menu.addAction("Empty Trash", []() {
                             // TODO
                         });
                         break;
                     default:
                         break;
                 }
                 if (!menu.isEmpty()) {
-                    menu.exec(ui->treeWidget->mapToGlobal(pos));
+                    menu.exec(ui->treeView->mapToGlobal(pos));
                 }
             }
-            void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::configureTreeWidget(
+            void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::configureTreeWidget(QTreeView *treeView)
-                QTreeWidget *treeWidget)
             {
                 auto allEventsItem = new QTreeWidgetItem{{"All Events"}, ALL_EVENT_ITEM_TYPE};
                 allEventsItem->setIcon(0, QIcon(":/icones/allEvents.png"));
-                treeWidget->addTopLevelItem(allEventsItem);
+                m_TreeModel->addTopLevelItem(allEventsItem);
                 auto trashItem = new QTreeWidgetItem{{"Trash"}, TRASH_ITEM_TYPE};
                 trashItem->setIcon(0, QIcon(":/icones/trash.png"));
-                treeWidget->addTopLevelItem(trashItem);
+                m_TreeModel->addTopLevelItem(trashItem);
-                auto separator = new QFrame{treeWidget};
+                auto separator = new QFrame{treeView};
                 separator->setFrameShape(QFrame::HLine);
                 auto separatorItem = new QTreeWidgetItem{};
                 separatorItem->setFlags(Qt::NoItemFlags);
-                treeWidget->addTopLevelItem(separatorItem);
+                auto separatorIndex = m_TreeModel->addTopLevelItem(separatorItem);
-                treeWidget->setItemWidget(separatorItem, 0, separator);
+                treeView->setIndexWidget(separatorIndex, separator);
                 auto repositories = sqpApp->catalogueController().getRepositories();
                 for (auto dbname : repositories) {
-                    auto db = addDatabaseItem(dbname, treeWidget);
+                    auto dbIndex = addDatabaseItem(dbname);
                     auto catalogues = sqpApp->catalogueController().retrieveCatalogues(dbname);
                     for (auto catalogue : catalogues) {
-                        addCatalogueItem(catalogue, db);
+                        addCatalogueItem(catalogue, dbIndex);
                     }
                 }
-                treeWidget->expandAll();
+                treeView->expandAll();
             }
-            QTreeWidgetItem *
+            QModelIndex
-            CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addDatabaseItem(const QString &name,
+            CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addDatabaseItem(const QString &name)
-                                                                                   QTreeWidget *treeWidget)
             {
                 auto databaseItem = new QTreeWidgetItem{{name}, DATABASE_ITEM_TYPE};
                 databaseItem->setIcon(0, QIcon{":/icones/database.png"});
-                treeWidget->addTopLevelItem(databaseItem);
+                auto databaseIndex = m_TreeModel->addTopLevelItem(databaseItem);
-                return databaseItem;
+                return databaseIndex;
             }
             QTreeWidgetItem *
-            CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getDatabaseItem(const QString &name,
+            CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getDatabaseItem(const QString &name)
-                                                                                   QTreeWidget *treeWidget)
             {
-                for (auto i = 0; i < treeWidget->topLevelItemCount(); ++i) {
+                for (auto i = 0; i < m_TreeModel->topLevelItemCount(); ++i) {
-                    auto item = treeWidget->topLevelItem(i);
+                    auto item = m_TreeModel->topLevelItem(i);
                     if (item->type() == DATABASE_ITEM_TYPE && item->text(0) == name) {
                         return item;
                     }
                 }
                 return nullptr;
             }
             void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addCatalogueItem(
-                const std::shared_ptr<DBCatalogue> &catalogue, QTreeWidgetItem *parentDatabaseItem)
+                const std::shared_ptr<DBCatalogue> &catalogue, const QModelIndex &databaseIndex)
             {
                 auto catalogueItem = new CatalogueTreeWidgetItem{catalogue, CATALOGUE_ITEM_TYPE};
                 catalogueItem->setIcon(0, QIcon{":/icones/catalogue.png"});
-                parentDatabaseItem->addChild(catalogueItem);
+                m_TreeModel->addChildItem(catalogueItem, databaseIndex);
             }
             CatalogueTreeWidgetItem *CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getCatalogueItem(
-                const std::shared_ptr<DBCatalogue> &catalogue, QTreeWidget *treeWidget) const
+                const std::shared_ptr<DBCatalogue> &catalogue) const
             {
-                for (auto i = 0; i < treeWidget->topLevelItemCount(); ++i) {
+                for (auto i = 0; i < m_TreeModel->topLevelItemCount(); ++i) {
-                    auto item = treeWidget->topLevelItem(i);
+                    auto item = m_TreeModel->topLevelItem(i);
                     if (item->type() == DATABASE_ITEM_TYPE) {
                         for (auto j = 0; j < item->childCount(); ++j) {
                             auto childItem = item->child(j);
                             if (childItem->type() == CATALOGUE_ITEM_TYPE) {
                                 auto catalogueItem = static_cast<CatalogueTreeWidgetItem *>(childItem);
                                 if (catalogueItem->catalogue() == catalogue) {
                                     return catalogueItem;
                                 }
                             }
                             else {
                                 qCWarning(LOG_CatalogueSideBarWidget()) << "getCatalogueItem: Invalid tree "
                                                                            "structure. A database item should "
                                                                            "only contain catalogues.";
                                 Q_ASSERT(false);
                             }
                         }
                     }
                 }
                 return nullptr;
             }
+            void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::setHasChanges(bool value,
+                                                                                      const QModelIndex &index,
+                                                                                      QTreeView *treeView)
+            {
+                auto validationIndex = index.sibling(index.row(), (int)CatalogueTreeModel::Column::Validation);
+                if (value) {
+                    if (!hasChanges(validationIndex, treeView)) {
+                        auto widget = CatalogueExplorerHelper::buildValidationWidget(
+                            treeView,
+                            [this, validationIndex, treeView]() {
+                                setHasChanges(false, validationIndex, treeView);
+                            },
+                            [this, validationIndex, treeView]() {
+                                setHasChanges(false, validationIndex, treeView);
+                            });
+                        treeView->setIndexWidget(validationIndex, widget);
+                    }
+                }
+                else {
+                    // Note: the widget is destroyed
+                    treeView->setIndexWidget(validationIndex, nullptr);
+                }
+            }
+            bool CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::hasChanges(const QModelIndex &index,
+                                                                                   QTreeView *treeView)
+            {
+                auto validationIndex = index.sibling(index.row(), (int)CatalogueTreeModel::Column::Validation);
+                return treeView->indexWidget(validationIndex) != nullptr;
+            }

gui/src/Catalogue/CatalogueTreeWidgetItem.cpp +1 -23

             #include "Catalogue/CatalogueTreeWidgetItem.h"
             #include <Catalogue/CatalogueExplorerHelper.h>
             #include <Catalogue/CatalogueController.h>
             #include <SqpApplication.h>
             #include <memory>
             #include <DBCatalogue.h>
             /// Column in the tree widget where the apply and cancel buttons must appear
             const auto APPLY_CANCEL_BUTTONS_COLUMN = 1;
             struct CatalogueTreeWidgetItem::CatalogueTreeWidgetItemPrivate {
                 std::shared_ptr<DBCatalogue> m_Catalogue;
                 CatalogueTreeWidgetItemPrivate(std::shared_ptr<DBCatalogue> catalogue) : m_Catalogue(catalogue)
                 {
                 }
             };
             CatalogueTreeWidgetItem::CatalogueTreeWidgetItem(std::shared_ptr<DBCatalogue> catalogue, int type)
                     : QTreeWidgetItem(type),
                       impl{spimpl::make_unique_impl<CatalogueTreeWidgetItemPrivate>(catalogue)}
             {
-                setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable);
+                setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsDropEnabled);
             }
             QVariant CatalogueTreeWidgetItem::data(int column, int role) const
             {
                 if (column == 0) {
                     switch (role) {
                         case Qt::EditRole: // fallthrough
                         case Qt::DisplayRole:
                             return impl->m_Catalogue->getName();
                         default:
                             break;
                     }
                 }
                 return QTreeWidgetItem::data(column, role);
             }
             void CatalogueTreeWidgetItem::setData(int column, int role, const QVariant &value)
             {
                 if (role == Qt::EditRole && column == 0) {
                     auto newName = value.toString();
                     if (newName != impl->m_Catalogue->getName()) {
                         setText(0, newName);
                         impl->m_Catalogue->setName(newName);
                         sqpApp->catalogueController().updateCatalogue(impl->m_Catalogue);
-                        setHasChanges(true);
                     }
                 }
                 else {
                     QTreeWidgetItem::setData(column, role, value);
                 }
             }
             std::shared_ptr<DBCatalogue> CatalogueTreeWidgetItem::catalogue() const
             {
                 return impl->m_Catalogue;
             }
-            void CatalogueTreeWidgetItem::setHasChanges(bool value)
-                if (value) {
-                    if (!hasChanges()) {
-                        auto widget = CatalogueExplorerHelper::buildValidationWidget(
-                            treeWidget(), [this]() { setHasChanges(false); },
-                            [this]() { setHasChanges(false); });
-                        treeWidget()->setItemWidget(this, APPLY_CANCEL_BUTTONS_COLUMN, widget);
-                else {
-                    // Note: the widget is destroyed
-                    treeWidget()->setItemWidget(this, APPLY_CANCEL_BUTTONS_COLUMN, nullptr);
-            bool CatalogueTreeWidgetItem::hasChanges()
-                return treeWidget()->itemWidget(this, APPLY_CANCEL_BUTTONS_COLUMN) != nullptr;
             void CatalogueTreeWidgetItem::refresh()
             {
                 emitDataChanged();
             }

gui/ui/Catalogue/CatalogueSideBarWidget.ui +15 -8

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>CatalogueSideBarWidget</class>
              <widget class="QWidget" name="CatalogueSideBarWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>330</width>
                 <height>523</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QVBoxLayout" name="verticalLayout">
                <property name="leftMargin">
                 <number>0</number>
                </property>
                <property name="topMargin">
                 <number>0</number>
                </property>
                <property name="rightMargin">
                 <number>0</number>
                </property>
                <property name="bottomMargin">
                 <number>0</number>
                </property>
                <item>
                 <layout class="QHBoxLayout" name="horizontalLayout">
                  <item>
                   <widget class="QToolButton" name="btnAdd">
                    <property name="text">
                     <string>+</string>
                    </property>
                    <property name="icon">
                     <iconset resource="../../resources/sqpguiresources.qrc">
                      <normaloff>:/icones/add.png</normaloff>:/icones/add.png</iconset>
                    </property>
                    <property name="autoRaise">
                     <bool>true</bool>
                    </property>
                   </widget>
                  </item>
                  <item>
                   <widget class="QToolButton" name="btnRemove">
                    <property name="text">
                     <string> - </string>
                    </property>
                    <property name="icon">
                     <iconset resource="../../resources/sqpguiresources.qrc">
                      <normaloff>:/icones/remove.png</normaloff>:/icones/remove.png</iconset>
                    </property>
                    <property name="autoRaise">
                     <bool>true</bool>
                    </property>
                   </widget>
                  </item>
                  <item>
                   <spacer name="horizontalSpacer">
                    <property name="orientation">
                     <enum>Qt::Horizontal</enum>
                    </property>
                    <property name="sizeHint" stdset="0">
                     <size>
                      <width>40</width>
                      <height>20</height>
                     </size>
                    </property>
                   </spacer>
                  </item>
                 </layout>
                </item>
                <item>
-                <widget class="QTreeWidget" name="treeWidget">
+                <widget class="QTreeView" name="treeView">
+                 <property name="acceptDrops">
+                  <bool>true</bool>
+                 </property>
+                 <property name="dragDropMode">
+                  <enum>QAbstractItemView::DropOnly</enum>
+                 </property>
+                 <property name="defaultDropAction">
+                  <enum>Qt::CopyAction</enum>
+                 </property>
                  <property name="selectionMode">
                   <enum>QAbstractItemView::ExtendedSelection</enum>
                  </property>
-                 <attribute name="headerVisible">
+                 <property name="headerHidden">
-                  <bool>false</bool>
+                  <bool>true</bool>
+                 </property>
+                 <attribute name="headerDefaultSectionSize">
+                  <number>0</number>
                  </attribute>
-                 <column>
-                  <property name="text">
-                   <string notr="true">1</string>
-                  </property>
-                 </column>
                 </widget>
                </item>
               </layout>
              </widget>
              <resources>
               <include location="../../resources/sqpguiresources.qrc"/>
               <include location="../../resources/sqpguiresources.qrc"/>
              </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