GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1260:af39d3a05321

Refactoring of catalogue: use a custom item class

trabillard -

r1260:af39d3a05321

parent child

Context file:

r1260:af39d3a05321

gui/include/Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h created 644 +34 0

@@ -0,0 +1,34
	1	#ifndef SCIQLOP_CATALOGUEABSTRACTTREEITEM_H
	2	#define SCIQLOP_CATALOGUEABSTRACTTREEITEM_H
	3
	4	#include <Common/spimpl.h>
	5	#include <QVariant>
	6	#include <QVector>
	7
	8	class QMimeData;
	9
	10	class CatalogueAbstractTreeItem {
	11	public:
	12	constexpr static const int DEFAULT_TYPE = -1;
	13
	14	CatalogueAbstractTreeItem(int type = DEFAULT_TYPE);
	15	virtual ~CatalogueAbstractTreeItem();
	16
	17	void addChild(CatalogueAbstractTreeItem *child);
	18	QVector<CatalogueAbstractTreeItem *> children() const;
	19	CatalogueAbstractTreeItem *parent() const;
	20
	21	int type() const;
	22	QString text(int column = 0) const;
	23
	24	virtual QVariant data(int column, int role) const;
	25	virtual Qt::ItemFlags flags(int column) const;
	26	virtual bool setData(int column, int role, const QVariant &value);
	27	virtual bool canDropMimeData(const QMimeData *data, Qt::DropAction action);
	28
	29	private:
	30	class CatalogueAbstractTreeItemPrivate;
	31	spimpl::unique_impl_ptr<CatalogueAbstractTreeItemPrivate> impl;
	32	};
	33
	34	#endif // SCIQLOP_CATALOGUEABSTRACTTREEITEM_H

gui/include/Catalogue/CatalogueTreeItems/CatalogueTextTreeItem.h created 644 +23 0

@@ -0,0 +1,23
	1	#ifndef SCIQLOP_CATALOGUETEXTTREEITEM_H
	2	#define SCIQLOP_CATALOGUETEXTTREEITEM_H
	3
	4	#include <Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h>
	5	#include <Common/spimpl.h>
	6
	7	class CatalogueTextTreeItem : public CatalogueAbstractTreeItem {
	8	public:
	9	CatalogueTextTreeItem(const QIcon &icon, const QString &text, int type);
	10
	11	QVariant data(int column, int role) const override;
	12	Qt::ItemFlags flags(int column) const override;
	13
	14	QString text() const;
	15
	16	void setEnabled(bool value);
	17
	18	private:
	19	class CatalogueTextTreeItemPrivate;
	20	spimpl::unique_impl_ptr<CatalogueTextTreeItemPrivate> impl;
	21	};
	22
	23	#endif // SCIQLOP_CATALOGUETEXTTREEITEM_H

gui/include/Catalogue/CatalogueTreeItems/CatalogueTreeItem.h created 644 +27 0

@@ -0,0 +1,27
	1	#ifndef SCIQLOP_CATALOGUETREEITEM_H
	2	#define SCIQLOP_CATALOGUETREEITEM_H
	3
	4	#include <Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h>
	5	#include <Common/spimpl.h>
	6
	7	class DBCatalogue;
	8
	9
	10	class CatalogueTreeItem : public CatalogueAbstractTreeItem {
	11	public:
	12	CatalogueTreeItem(std::shared_ptr<DBCatalogue> catalogue, const QIcon &icon, int type);
	13
	14	QVariant data(int column, int role) const override;
	15	bool setData(int column, int role, const QVariant &value) override;
	16	Qt::ItemFlags flags(int column) const override;
	17	bool canDropMimeData(const QMimeData *data, Qt::DropAction action) override;
	18
	19	/// Returns the catalogue represented by the item
	20	std::shared_ptr<DBCatalogue> catalogue() const;
	21
	22	private:
	23	class CatalogueTreeItemPrivate;
	24	spimpl::unique_impl_ptr<CatalogueTreeItemPrivate> impl;
	25	};
	26
	27	#endif // SCIQLOP_CATALOGUETREEITEM_H

gui/src/Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.cpp created 644 +74 0

@@ -0,0 +1,74
	1	#include "Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h"
	2
	3	struct CatalogueAbstractTreeItem::CatalogueAbstractTreeItemPrivate {
	4	int m_Type;
	5	QVector<CatalogueAbstractTreeItem *> m_Children;
	6	CatalogueAbstractTreeItem *m_Parent = nullptr;
	7
	8	CatalogueAbstractTreeItemPrivate(int type) : m_Type(type) {}
	9	};
	10
	11	CatalogueAbstractTreeItem::CatalogueAbstractTreeItem(int type)
	12	: impl{spimpl::make_unique_impl<CatalogueAbstractTreeItemPrivate>(type)}
	13	{
	14	}
	15
	16	CatalogueAbstractTreeItem::~CatalogueAbstractTreeItem()
	17	{
	18	qDeleteAll(impl->m_Children);
	19	}
	20
	21	void CatalogueAbstractTreeItem::addChild(CatalogueAbstractTreeItem *child)
	22	{
	23	impl->m_Children << child;
	24	child->impl->m_Parent = this;
	25	}
	26
	27	QVector<CatalogueAbstractTreeItem *> CatalogueAbstractTreeItem::children() const
	28	{
	29	return impl->m_Children;
	30	}
	31
	32	CatalogueAbstractTreeItem *CatalogueAbstractTreeItem::parent() const
	33	{
	34	return impl->m_Parent;
	35	}
	36
	37	int CatalogueAbstractTreeItem::type() const
	38	{
	39	return impl->m_Type;
	40	}
	41
	42	QString CatalogueAbstractTreeItem::text(int column) const
	43	{
	44	return data(0, Qt::DisplayRole).toString();
	45	}
	46
	47	QVariant CatalogueAbstractTreeItem::data(int column, int role) const
	48	{
	49	Q_UNUSED(column);
	50	Q_UNUSED(role);
	51	return QVariant();
	52	}
	53
	54	Qt::ItemFlags CatalogueAbstractTreeItem::flags(int column) const
	55	{
	56	Q_UNUSED(column);
	57	return Qt::NoItemFlags;
	58	}
	59
	60	bool CatalogueAbstractTreeItem::setData(int column, int role, const QVariant &value)
	61	{
	62	Q_UNUSED(column);
	63	Q_UNUSED(role);
	64	Q_UNUSED(value);
	65
	66	return false;
	67	}
	68
	69	bool CatalogueAbstractTreeItem::canDropMimeData(const QMimeData *data, Qt::DropAction action)
	70	{
	71	Q_UNUSED(data);
	72	Q_UNUSED(action);
	73	return false;
	74	}

gui/src/Catalogue/CatalogueTreeItems/CatalogueTextTreeItem.cpp created 644 +59 0

@@ -0,0 +1,59
	1	#include "Catalogue/CatalogueTreeItems/CatalogueTextTreeItem.h"
	2
	3	#include <QIcon>
	4
	5	struct CatalogueTextTreeItem::CatalogueTextTreeItemPrivate {
	6
	7	QString m_Text;
	8	QIcon m_Icon;
	9	bool m_IsEnabled = true;
	10
	11	CatalogueTextTreeItemPrivate(const QIcon &icon, const QString &text)
	12	: m_Text(text), m_Icon(icon)
	13	{
	14	}
	15	};
	16
	17
	18	CatalogueTextTreeItem::CatalogueTextTreeItem(const QIcon &icon, const QString &text, int type)
	19	: CatalogueAbstractTreeItem(type),
	20	impl{spimpl::make_unique_impl<CatalogueTextTreeItemPrivate>(icon, text)}
	21	{
	22	}
	23
	24	QVariant CatalogueTextTreeItem::data(int column, int role) const
	25	{
	26	if (column > 0) {
	27	return QVariant();
	28	}
	29
	30	switch (role) {
	31	case Qt::DisplayRole:
	32	return impl->m_Text;
	33	case Qt::DecorationRole:
	34	return impl->m_Icon;
	35	}
	36
	37	return QVariant();
	38	}
	39
	40	Qt::ItemFlags CatalogueTextTreeItem::flags(int column) const
	41	{
	42	Q_UNUSED(column);
	43
	44	if (!impl->m_IsEnabled) {
	45	return Qt::NoItemFlags;
	46	}
	47
	48	return Qt::ItemIsEnabled \| Qt::ItemIsSelectable;
	49	}
	50
	51	QString CatalogueTextTreeItem::text() const
	52	{
	53	return impl->m_Text;
	54	}
	55
	56	void CatalogueTextTreeItem::setEnabled(bool value)
	57	{
	58	impl->m_IsEnabled = value;
	59	}

gui/include/Catalogue/CatalogueTreeModel.h +16 -8

             #ifndef SCIQLOP_CATALOGUETREEMODEL_H
             #define SCIQLOP_CATALOGUETREEMODEL_H
             #include <Common/spimpl.h>
             #include <QAbstractItemModel>
-            #include <QTreeWidgetItem>
+            class CatalogueAbstractTreeItem;
             /**
              * @brief Model to display catalogue items based on QTreeWidgetItem
-             * @warning Do not use the method QTreeWidgetItem::treeWidget for an item added to this model or the application will crash
+             * @warning Do not use the method QTreeWidgetItem::treeWidget for an item added to this model or the
+             * application will crash
              */
             class CatalogueTreeModel : public QAbstractItemModel {
                 Q_OBJECT
             signals:
                 void itemRenamed(const QModelIndex &index);
             public:
                 CatalogueTreeModel(QObject *parent = nullptr);
                 enum class Column { Name, Validation, Count };
-                QModelIndex addTopLevelItem(QTreeWidgetItem *item);
+                QModelIndex addTopLevelItem(CatalogueAbstractTreeItem *item);
-                int topLevelItemCount() const;
+                QVector<CatalogueAbstractTreeItem *> topLevelItems() const;
-                QTreeWidgetItem *topLevelItem(int i) const;
-                void addChildItem(QTreeWidgetItem *child, const QModelIndex &parentIndex);
+                void addChildItem(CatalogueAbstractTreeItem *child, const QModelIndex &parentIndex);
-                QTreeWidgetItem *item(const QModelIndex &index) const;
+                CatalogueAbstractTreeItem *item(const QModelIndex &index) const;
-                QModelIndex indexOf(QTreeWidgetItem *item, int column = 0) const;
+                QModelIndex indexOf(CatalogueAbstractTreeItem *item, int column = 0) const;
                 // model
                 QModelIndex index(int row, int column,
                                   const QModelIndex &parent = QModelIndex()) const override;
                 QModelIndex parent(const QModelIndex &index) const override;
                 int rowCount(const QModelIndex &parent) const override;
                 int columnCount(const QModelIndex &parent) const override;
                 Qt::ItemFlags flags(const QModelIndex &index) const override;
                 QVariant data(const QModelIndex &index, int role) const override;
                 bool setData(const QModelIndex &index, const QVariant &value, int role) override;
+                bool canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
+                                     const QModelIndex &parent) const override;
+                bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
+                                  const QModelIndex &parent) override;
+                Qt::DropActions supportedDropActions() const;
+                QStringList mimeTypes() const;
             private:
                 class CatalogueTreeModelPrivate;
                 spimpl::unique_impl_ptr<CatalogueTreeModelPrivate> impl;
             };
             #endif // CATALOGUETREEMODEL_H

gui/meson.build +3 -1

             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/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/CatalogueTreeItems/CatalogueAbstractTreeItem.cpp',
+              'src/Catalogue/CatalogueTreeItems/CatalogueTreeItem.cpp',
+              'src/Catalogue/CatalogueTreeItems/CatalogueTextTreeItem.cpp',
               'src/Catalogue/CatalogueEventsModel.cpp',
               'src/Catalogue/CatalogueExplorerHelper.cpp',
               'src/Catalogue/CatalogueActionManager.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 +30 -33

             #include "Catalogue/CatalogueSideBarWidget.h"
             #include "ui_CatalogueSideBarWidget.h"
             #include <SqpApplication.h>
             #include <Catalogue/CatalogueController.h>
             #include <Catalogue/CatalogueExplorerHelper.h>
+            #include <Catalogue/CatalogueTreeItems/CatalogueTextTreeItem.h>
+            #include <Catalogue/CatalogueTreeItems/CatalogueTreeItem.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 ALL_EVENT_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 1;
-            constexpr auto TRASH_ITEM_TYPE = QTreeWidgetItem::UserType + 1;
+            constexpr auto TRASH_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 2;
-            constexpr auto CATALOGUE_ITEM_TYPE = QTreeWidgetItem::UserType + 2;
+            constexpr auto CATALOGUE_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 3;
-            constexpr auto DATABASE_ITEM_TYPE = QTreeWidgetItem::UserType + 3;
+            constexpr auto DATABASE_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 4;
             struct CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate {
                 CatalogueTreeModel *m_TreeModel = nullptr;
                 void configureTreeWidget(QTreeView *treeView);
                 QModelIndex addDatabaseItem(const QString &name);
-                QTreeWidgetItem *getDatabaseItem(const QString &name);
+                CatalogueAbstractTreeItem *getDatabaseItem(const QString &name);
                 void addCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue,
                                       const QModelIndex &databaseIndex);
-                CatalogueTreeWidgetItem *getCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue) const;
+                CatalogueTreeItem *getCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue) 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->m_TreeModel = new CatalogueTreeModel(this);
                 ui->treeView->setModel(impl->m_TreeModel);
                 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->treeView->selectionModel()->selectedRows();
                     if (selectedItems.isEmpty()) {
                         emit this->selectionCleared();
                     }
                     else {
                         QVector<std::shared_ptr<DBCatalogue> > catalogues;
                         QStringList databases;
                         auto firstIndex = selectedItems.first();
                         auto firstItem = impl->m_TreeModel->item(firstIndex);
                         if (!firstItem) {
                             Q_ASSERT(false);
                             return;
                         }
                         auto selectionType = firstItem->type();
                         for (auto itemIndex : selectedItems) {
                             auto item = impl->m_TreeModel->item(itemIndex);
                             if (item && item->type() == selectionType) {
                                 switch (selectionType) {
                                     case CATALOGUE_ITEM_TYPE:
-                                        catalogues.append(
+                                        catalogues.append(static_cast<CatalogueTreeItem *>(item)->catalogue());
-                                            static_cast<CatalogueTreeWidgetItem *>(item)->catalogue());
                                         break;
                                     case DATABASE_ITEM_TYPE:
-                                        selectionType = DATABASE_ITEM_TYPE;
+                                        databases.append(item->text());
-                                        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->treeView, &QTreeView::clicked, emitSelection);
                 connect(ui->treeView->selectionModel(), &QItemSelectionModel::currentChanged, emitSelection);
                 connect(impl->m_TreeModel, &CatalogueTreeModel::itemRenamed, [emitSelection, this](auto index) {
                     auto selectedIndexes = ui->treeView->selectionModel()->selectedRows();
                     if (selectedIndexes.contains(index)) {
                         emitSelection();
                     }
                     auto item = impl->m_TreeModel->item(index);
                     impl->setHasChanges(true, index, ui->treeView);
                 });
                 ui->treeView->setContextMenuPolicy(Qt::CustomContextMenu);
-                connect(ui->treeView, &QTreeWidget::customContextMenuRequested, this,
+                connect(ui->treeView, &QTreeView::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)) {
                     auto index = impl->m_TreeModel->indexOf(catalogueItem);
                     impl->setHasChanges(hasChanges, index, ui->treeView);
-                    catalogueItem->refresh();
+                    // catalogueItem->refresh();
                 }
             }
             void CatalogueSideBarWidget::onContextMenuRequested(const QPoint &pos)
             {
                 QMenu menu{this};
                 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", [this, currentIndex]() { ui->treeView->edit(currentIndex); });
                         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->treeView->mapToGlobal(pos));
                 }
             }
             void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::configureTreeWidget(QTreeView *treeView)
             {
-                auto allEventsItem = new QTreeWidgetItem{{"All Events"}, ALL_EVENT_ITEM_TYPE};
+                auto allEventsItem = new CatalogueTextTreeItem{QIcon{":/icones/allEvents.png"}, "All Events",
-                allEventsItem->setIcon(0, QIcon(":/icones/allEvents.png"));
+                                                               ALL_EVENT_ITEM_TYPE};
                 m_TreeModel->addTopLevelItem(allEventsItem);
-                auto trashItem = new QTreeWidgetItem{{"Trash"}, TRASH_ITEM_TYPE};
+                auto trashItem
-                trashItem->setIcon(0, QIcon(":/icones/trash.png"));
+                    = new CatalogueTextTreeItem{QIcon{":/icones/trash.png"}, "Trash", TRASH_ITEM_TYPE};
                 m_TreeModel->addTopLevelItem(trashItem);
                 auto separator = new QFrame{treeView};
                 separator->setFrameShape(QFrame::HLine);
-                auto separatorItem = new QTreeWidgetItem{};
+                auto separatorItem
-                separatorItem->setFlags(Qt::NoItemFlags);
+                    = new CatalogueTextTreeItem{QIcon{}, QString{}, CatalogueAbstractTreeItem::DEFAULT_TYPE};
+                separatorItem->setEnabled(false);
                 auto separatorIndex = m_TreeModel->addTopLevelItem(separatorItem);
                 treeView->setIndexWidget(separatorIndex, separator);
                 auto repositories = sqpApp->catalogueController().getRepositories();
                 for (auto dbname : repositories) {
                     auto dbIndex = addDatabaseItem(dbname);
                     auto catalogues = sqpApp->catalogueController().retrieveCatalogues(dbname);
                     for (auto catalogue : catalogues) {
                         addCatalogueItem(catalogue, dbIndex);
                     }
                 }
                 treeView->expandAll();
             }
             QModelIndex
             CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addDatabaseItem(const QString &name)
             {
-                auto databaseItem = new QTreeWidgetItem{{name}, DATABASE_ITEM_TYPE};
+                auto databaseItem
-                databaseItem->setIcon(0, QIcon{":/icones/database.png"});
+                    = new CatalogueTextTreeItem{QIcon{":/icones/database.png"}, {name}, DATABASE_ITEM_TYPE};
                 auto databaseIndex = m_TreeModel->addTopLevelItem(databaseItem);
                 return databaseIndex;
             }
-            QTreeWidgetItem *
+            CatalogueAbstractTreeItem *
             CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getDatabaseItem(const QString &name)
             {
-                for (auto i = 0; i < m_TreeModel->topLevelItemCount(); ++i) {
+                for (auto item : m_TreeModel->topLevelItems()) {
-                    auto item = m_TreeModel->topLevelItem(i);
+                    if (item->type() == DATABASE_ITEM_TYPE && item->text() == name) {
-                    if (item->type() == DATABASE_ITEM_TYPE && item->text(0) == name) {
                         return item;
                     }
                 }
                 return nullptr;
             }
             void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addCatalogueItem(
                 const std::shared_ptr<DBCatalogue> &catalogue, const QModelIndex &databaseIndex)
             {
-                auto catalogueItem = new CatalogueTreeWidgetItem{catalogue, CATALOGUE_ITEM_TYPE};
+                auto catalogueItem
-                catalogueItem->setIcon(0, QIcon{":/icones/catalogue.png"});
+                    = new CatalogueTreeItem{catalogue, QIcon{":/icones/catalogue.png"}, CATALOGUE_ITEM_TYPE};
                 m_TreeModel->addChildItem(catalogueItem, databaseIndex);
             }
-            CatalogueTreeWidgetItem *CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getCatalogueItem(
+            CatalogueTreeItem *CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getCatalogueItem(
                 const std::shared_ptr<DBCatalogue> &catalogue) const
             {
-                for (auto i = 0; i < m_TreeModel->topLevelItemCount(); ++i) {
+                for (auto item : m_TreeModel->topLevelItems()) {
-                    auto item = m_TreeModel->topLevelItem(i);
                     if (item->type() == DATABASE_ITEM_TYPE) {
-                        for (auto j = 0; j < item->childCount(); ++j) {
+                        for (auto childItem : item->children()) {
-                            auto childItem = item->child(j);
                             if (childItem->type() == CATALOGUE_ITEM_TYPE) {
-                                auto catalogueItem = static_cast<CatalogueTreeWidgetItem *>(childItem);
+                                auto catalogueItem = static_cast<CatalogueTreeItem *>(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/CatalogueTreeItems/CatalogueTreeItem.cpp ~~gui/src/Catalogue/CatalogueTreeWidgetItem.cpp~~ renamed +35 -19

-            #include "Catalogue/CatalogueTreeWidgetItem.h"
+            #include "Catalogue/CatalogueTreeItems/CatalogueTreeItem.h"
             #include <Catalogue/CatalogueExplorerHelper.h>
             #include <Catalogue/CatalogueController.h>
+            #include <Common/MimeTypesDef.h>
+            #include <QIcon>
+            #include <QMimeData>
             #include <SqpApplication.h>
             #include <memory>
             #include <DBCatalogue.h>
-            /// Column in the tree widget where the apply and cancel buttons must appear
+            struct CatalogueTreeItem::CatalogueTreeItemPrivate {
-            const auto APPLY_CANCEL_BUTTONS_COLUMN = 1;
-            struct CatalogueTreeWidgetItem::CatalogueTreeWidgetItemPrivate {
                 std::shared_ptr<DBCatalogue> m_Catalogue;
+                QIcon m_Icon;
-                CatalogueTreeWidgetItemPrivate(std::shared_ptr<DBCatalogue> catalogue) : m_Catalogue(catalogue)
+                CatalogueTreeItemPrivate(std::shared_ptr<DBCatalogue> catalogue, const QIcon &icon)
+                        : m_Catalogue(catalogue), m_Icon(icon)
                 {
                 }
             };
-            CatalogueTreeWidgetItem::CatalogueTreeWidgetItem(std::shared_ptr<DBCatalogue> catalogue, int type)
+            CatalogueTreeItem::CatalogueTreeItem(std::shared_ptr<DBCatalogue> catalogue, const QIcon &icon,
-                    : QTreeWidgetItem(type),
+                                                 int type)
-                      impl{spimpl::make_unique_impl<CatalogueTreeWidgetItemPrivate>(catalogue)}
+                    : CatalogueAbstractTreeItem(type),
+                      impl{spimpl::make_unique_impl<CatalogueTreeItemPrivate>(catalogue, icon)}
             {
-                setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsDropEnabled);
             }
-            QVariant CatalogueTreeWidgetItem::data(int column, int role) const
+            QVariant CatalogueTreeItem::data(int column, int role) const
             {
                 if (column == 0) {
                     switch (role) {
                         case Qt::EditRole: // fallthrough
                         case Qt::DisplayRole:
                             return impl->m_Catalogue->getName();
+                        case Qt::DecorationRole:
+                            return impl->m_Icon;
                         default:
                             break;
                     }
                 }
-                return QTreeWidgetItem::data(column, role);
+                return QVariant();
             }
-            void CatalogueTreeWidgetItem::setData(int column, int role, const QVariant &value)
+            bool CatalogueTreeItem::setData(int column, int role, const QVariant &value)
             {
+                bool result = false;
                 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);
+                        result = true;
                     }
                 }
+                return result;
+            }
+            Qt::ItemFlags CatalogueTreeItem::flags(int column) const
+            {
+                if (column == 0) {
+                    return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable
+                           | Qt::ItemIsDropEnabled;
+                }
                 else {
-                    QTreeWidgetItem::setData(column, role, value);
+                    return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
                 }
             }
-            std::shared_ptr<DBCatalogue> CatalogueTreeWidgetItem::catalogue() const
+            bool CatalogueTreeItem::canDropMimeData(const QMimeData *data, Qt::DropAction action)
             {
-                return impl->m_Catalogue;
+                return data->hasFormat(MIME_TYPE_EVENT_LIST);
             }
-            void CatalogueTreeWidgetItem::refresh()
+            std::shared_ptr<DBCatalogue> CatalogueTreeItem::catalogue() const
             {
-                emitDataChanged();
+                return impl->m_Catalogue;
             }

gui/src/Catalogue/CatalogueTreeModel.cpp +73 -52

             #include "Catalogue/CatalogueTreeModel.h"
+            #include <Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h>
-            #include <QTreeWidgetItem>
+            #include <QMimeData>
             #include <memory>
+            #include <Common/MimeTypesDef.h>
             struct CatalogueTreeModel::CatalogueTreeModelPrivate {
-                std::unique_ptr<QTreeWidgetItem> m_RootItem = nullptr;
+                std::unique_ptr<CatalogueAbstractTreeItem> m_RootItem = nullptr;
-                CatalogueTreeModelPrivate() : m_RootItem{std::make_unique<QTreeWidgetItem>()} {}
+                CatalogueTreeModelPrivate() : m_RootItem{std::make_unique<CatalogueAbstractTreeItem>()} {}
             };
             CatalogueTreeModel::CatalogueTreeModel(QObject *parent)
                     : QAbstractItemModel(parent), impl{spimpl::make_unique_impl<CatalogueTreeModelPrivate>()}
             {
             }
-            QModelIndex CatalogueTreeModel::addTopLevelItem(QTreeWidgetItem *item)
+            QModelIndex CatalogueTreeModel::addTopLevelItem(CatalogueAbstractTreeItem *item)
             {
-                beginInsertRows(QModelIndex(), impl->m_RootItem->childCount(), impl->m_RootItem->childCount());
+                auto nbTopLevelItems = impl->m_RootItem->children().count();
+                beginInsertRows(QModelIndex(), nbTopLevelItems, nbTopLevelItems);
                 impl->m_RootItem->addChild(item);
                 endInsertRows();
-                return index(impl->m_RootItem->childCount() - 1, 0);
+                emit dataChanged(QModelIndex(), QModelIndex());
-            int CatalogueTreeModel::topLevelItemCount() const
+                return index(nbTopLevelItems, 0);
-                return impl->m_RootItem->childCount();
             }
-            QTreeWidgetItem *CatalogueTreeModel::topLevelItem(int i) const
+            QVector<CatalogueAbstractTreeItem *> CatalogueTreeModel::topLevelItems() const
             {
-                return impl->m_RootItem->child(i);
+                return impl->m_RootItem->children();
             }
-            void CatalogueTreeModel::addChildItem(QTreeWidgetItem *child, const QModelIndex &parentIndex)
+            void CatalogueTreeModel::addChildItem(CatalogueAbstractTreeItem *child,
+                                                  const QModelIndex &parentIndex)
             {
                 auto parentItem = item(parentIndex);
-                beginInsertRows(parentIndex, parentItem->childCount(), parentItem->childCount());
+                int c = parentItem->children().count();
+                beginInsertRows(parentIndex, c, c);
                 parentItem->addChild(child);
                 endInsertRows();
+                emit dataChanged(QModelIndex(), QModelIndex());
             }
-            QTreeWidgetItem *CatalogueTreeModel::item(const QModelIndex &index) const
+            CatalogueAbstractTreeItem *CatalogueTreeModel::item(const QModelIndex &index) const
             {
-                return static_cast<QTreeWidgetItem *>(index.internalPointer());
+                return static_cast<CatalogueAbstractTreeItem *>(index.internalPointer());
             }
-            QModelIndex CatalogueTreeModel::indexOf(QTreeWidgetItem *item, int column) const
+            QModelIndex CatalogueTreeModel::indexOf(CatalogueAbstractTreeItem *item, int column) const
             {
                 auto parentItem = item->parent();
                 if (!parentItem) {
                     return QModelIndex();
                 }
-                auto row = parentItem->indexOfChild(item);
+                auto row = parentItem->children().indexOf(item);
                 return createIndex(row, column, item);
             }
             QModelIndex CatalogueTreeModel::index(int row, int column, const QModelIndex &parent) const
             {
+                if (column > 0) {
+                    int a = 0;
+                }
                 if (!hasIndex(row, column, parent)) {
                     return QModelIndex();
                 }
-                QTreeWidgetItem *parentItem = nullptr;
+                CatalogueAbstractTreeItem *parentItem = nullptr;
                 if (!parent.isValid()) {
                     parentItem = impl->m_RootItem.get();
                 }
                 else {
-                    parentItem = static_cast<QTreeWidgetItem *>(parent.internalPointer());
+                    parentItem = item(parent);
                 }
-                QTreeWidgetItem *childItem = parentItem->child(row);
+                auto childItem = parentItem->children().value(row);
                 if (childItem) {
                     return createIndex(row, column, childItem);
                 }
                 return QModelIndex();
             }
             QModelIndex CatalogueTreeModel::parent(const QModelIndex &index) const
             {
                 if (!index.isValid()) {
                     return QModelIndex();
                 }
-                auto childItem = static_cast<QTreeWidgetItem *>(index.internalPointer());
+                auto childItem = item(index);
                 auto parentItem = childItem->parent();
                 if (parentItem == nullptr || parentItem->parent() == nullptr) {
                     return QModelIndex();
                 }
-                auto row = parentItem->parent()->indexOfChild(parentItem);
+                auto row = parentItem->parent()->children().indexOf(parentItem);
                 return createIndex(row, 0, parentItem);
             }
             int CatalogueTreeModel::rowCount(const QModelIndex &parent) const
             {
-                QTreeWidgetItem *parentItem = nullptr;
+                CatalogueAbstractTreeItem *parentItem = nullptr;
-                if (parent.column() > 0) {
-                    return 0;
                 if (!parent.isValid()) {
                     parentItem = impl->m_RootItem.get();
                 }
                 else {
-                    parentItem = static_cast<QTreeWidgetItem *>(parent.internalPointer());
+                    parentItem = item(parent);
                 }
-                return parentItem->childCount();
+                return parentItem->children().count();
             }
             int CatalogueTreeModel::columnCount(const QModelIndex &parent) const
             {
                 return (int)Column::Count;
             }
             Qt::ItemFlags CatalogueTreeModel::flags(const QModelIndex &index) const
             {
-                if (index.column() == (int)Column::Validation) {
+                auto treeItem = item(index);
-                    return Qt::NoItemFlags;
+                if (treeItem) {
+                    return treeItem->flags(index.column());
-                auto item = static_cast<QTreeWidgetItem *>(index.internalPointer());
-                if (item) {
-                    return item->flags();
                 }
                 return Qt::NoItemFlags;
             }
             QVariant CatalogueTreeModel::data(const QModelIndex &index, int role) const
             {
-                if (!index.isValid()) {
+                auto treeItem = item(index);
-                    return QModelIndex();
+                if (treeItem) {
+                    return treeItem->data(index.column(), role);
-                auto item = static_cast<QTreeWidgetItem *>(index.internalPointer());
-                if (item) {
-                    return item->data(index.column(), role);
                 }
                 return QModelIndex();
             }
             bool CatalogueTreeModel::setData(const QModelIndex &index, const QVariant &value, int role)
             {
-                if (!index.isValid()) {
+                auto treeItem = item(index);
-                    return false;
+                if (treeItem) {
+                    auto result = treeItem->setData(index.column(), role, value);
-                auto item = static_cast<QTreeWidgetItem *>(index.internalPointer());
-                if (item) {
-                    item->setData(index.column(), role, value);
-                    if (index.column() == (int)Column::Name) {
+                    if (result && index.column() == (int)Column::Name) {
                         emit itemRenamed(index);
                     }
-                    return true;
+                    return result;
                 }
                 return false;
             }
+            bool CatalogueTreeModel::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row,
+                                                     int column, const QModelIndex &parent) const
+            {
+                auto draggedIndex = parent;
+                auto draggedItem = item(draggedIndex);
+                if (draggedItem) {
+                    return draggedItem->canDropMimeData(data, action);
+                }
+                return false;
+            }
+            bool CatalogueTreeModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row,
+                                                  int column, const QModelIndex &parent)
+            {
+                return false;
+            }
+            Qt::DropActions CatalogueTreeModel::supportedDropActions() const
+            {
+                return Qt::CopyAction | Qt::MoveAction;
+            }
+            QStringList CatalogueTreeModel::mimeTypes() const
+            {
+                return {MIME_TYPE_EVENT_LIST};
+            }

gui/ui/Catalogue/CatalogueSideBarWidget.ui +6 -12

             <?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="QTreeView" name="treeView">
                  <property name="acceptDrops">
                   <bool>true</bool>
                  </property>
                  <property name="dragDropMode">
-                  <enum>QAbstractItemView::DropOnly</enum>
+                  <enum>QAbstractItemView::DragDrop</enum>
                  </property>
-                 <property name="defaultDropAction">
+                 <attribute name="headerVisible">
-                  <enum>Qt::CopyAction</enum>
+                  <bool>false</bool>
-                 </property>
+                 </attribute>
-                 <property name="selectionMode">
+                 <attribute name="headerStretchLastSection">
-                  <enum>QAbstractItemView::ExtendedSelection</enum>
+                  <bool>false</bool>
-                 </property>
-                 <property name="headerHidden">
-                  <bool>true</bool>
-                 </property>
-                 <attribute name="headerDefaultSectionSize">
-                  <number>0</number>
                  </attribute>
                 </widget>
                </item>
               </layout>
              </widget>
              <resources>
               <include location="../../resources/sqpguiresources.qrc"/>
               <include location="../../resources/sqpguiresources.qrc"/>
              </resources>
              <connections/>
             </ui>

gui/include/Catalogue/CatalogueTreeWidgetItem.h removed 0 -34

NO CONTENT: file was removed

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