GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1356:3771be3f513d

Add catalogue handling

perrinel -

r1356:3771be3f513d

parent child

Context file:

r1356:3771be3f513d

core/include/Catalogue/CatalogueController.h +1 0

                 void updateCatalogue(std::shared_ptr<DBCatalogue> catalogue);
                 void removeCatalogue(std::shared_ptr<DBCatalogue> catalogue);
                 void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue);
+                void discardCatalogue(std::shared_ptr<DBCatalogue> catalogue, bool &removed);
                 void saveAll();
                 bool hasChanges() const;

core/src/Catalogue/CatalogueController.cpp +54 -20

                 QStringList m_RepositoryList;
                 CatalogueController *m_Q;
-                QSet<QString> m_EventKeysWithChanges;
+                QSet<QString> m_KeysWithChanges;
                 QString eventUniqueKey(const std::shared_ptr<DBEvent> &event) const;
+                QString catalogueUniqueKey(const std::shared_ptr<DBCatalogue> &catalogue) const;
                 void copyDBtoDB(const QString &dbFrom, const QString &dbTo);
                 QString toWorkRepository(QString repository);
                 void saveEvent(std::shared_ptr<DBEvent> event, bool persist = true);
                 void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue, bool persist = true);
-                std::shared_ptr<IRequestPredicate> createFinder(const QUuid& uniqId, const QString & repository, DBType type);
+                std::shared_ptr<IRequestPredicate> createFinder(const QUuid &uniqId, const QString &repository,
+                                                                DBType type);
             };
             CatalogueController::CatalogueController(QObject *parent)
                 event->setRepository(impl->toWorkRepository(event->getRepository()));
                 auto uniqueId = impl->eventUniqueKey(event);
-                impl->m_EventKeysWithChanges.insert(uniqueId);
+                impl->m_KeysWithChanges.insert(uniqueId);
                 impl->m_CatalogueDao.updateEvent(*event);
             }
                 auto uniqueId = impl->eventUniqueKey(event);
-                impl->m_EventKeysWithChanges.insert(uniqueId);
+                impl->m_KeysWithChanges.insert(uniqueId);
             }
             void CatalogueController::saveEvent(std::shared_ptr<DBEvent> event)
             {
                 impl->saveEvent(event, true);
-                impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));
+                impl->m_KeysWithChanges.remove(impl->eventUniqueKey(event));
             }
             void CatalogueController::discardEvent(std::shared_ptr<DBEvent> event, bool &removed)
                     auto workEvent = impl->m_CatalogueDao.getEvent(workPred);
                     *event = workEvent;
-                    impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));
+                    impl->m_KeysWithChanges.remove(impl->eventUniqueKey(event));
                 }
                 else {
                     removed = true;
             bool CatalogueController::eventHasChanges(std::shared_ptr<DBEvent> event) const
             {
-                return impl->m_EventKeysWithChanges.contains(impl->eventUniqueKey(event));
+                return impl->m_KeysWithChanges.contains(impl->eventUniqueKey(event));
             }
             std::list<std::shared_ptr<DBCatalogue> >
                 auto catalogueTemp = *catalogue;
                 impl->m_CatalogueDao.addCatalogue(catalogueTemp);
-                auto workPred = impl->createFinder(catalogue->getUniqId(), catalogue->getRepository(), DBType::WORK);
+                auto workPred
+                    = impl->createFinder(catalogue->getUniqId(), catalogue->getRepository(), DBType::WORK);
                 auto workCatalogue = impl->m_CatalogueDao.getCatalogue(workPred);
                 *catalogue = workCatalogue;
-            //    auto uniqueId = impl->eventUniqueKey(catalogue);
+                auto uniqueId = impl->catalogueUniqueKey(catalogue);
-            //    impl->m_EventKeysWithChanges.insert(uniqueId);
+                impl->m_KeysWithChanges.insert(uniqueId);
             }
             void CatalogueController::updateCatalogue(std::shared_ptr<DBCatalogue> catalogue)
             {
                 catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
-            //    auto uniqueId = impl->eventUniqueKey(event);
+                auto uniqueId = impl->catalogueUniqueKey(catalogue);
-            //    impl->m_EventKeysWithChanges.insert(uniqueId);
+                impl->m_KeysWithChanges.insert(uniqueId);
                 impl->m_CatalogueDao.updateCatalogue(*catalogue);
             }
             void CatalogueController::saveCatalogue(std::shared_ptr<DBCatalogue> catalogue)
             {
                 impl->saveCatalogue(catalogue, true);
-            //    impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));
+                impl->m_KeysWithChanges.remove(impl->catalogueUniqueKey(catalogue));
+            }
+            void CatalogueController::discardCatalogue(std::shared_ptr<DBCatalogue> catalogue, bool &removed)
+            {
+                auto syncPred
+                    = impl->createFinder(catalogue->getUniqId(), catalogue->getRepository(), DBType::SYNC);
+                auto workPred
+                    = impl->createFinder(catalogue->getUniqId(), catalogue->getRepository(), DBType::WORK);
+                auto syncCatalogue = impl->m_CatalogueDao.getCatalogue(syncPred);
+                if (!syncCatalogue.getUniqId().isNull()) {
+                    removed = false;
+                    impl->m_CatalogueDao.copyCatalogue(
+                        syncCatalogue, impl->toWorkRepository(catalogue->getRepository()), true);
+                    auto workCatalogue = impl->m_CatalogueDao.getCatalogue(workPred);
+                    *catalogue = workCatalogue;
+                    impl->m_KeysWithChanges.remove(impl->catalogueUniqueKey(catalogue));
+                }
+                else {
+                    removed = true;
+                    // Since the element wasn't in sync repository. Discard it means remove it
+                    catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
+                    impl->m_CatalogueDao.removeCatalogue(*catalogue);
+                }
             }
             void CatalogueController::saveAll()
                 }
                 impl->savAllDB();
-                impl->m_EventKeysWithChanges.clear();
+                impl->m_KeysWithChanges.clear();
             }
             bool CatalogueController::hasChanges() const
             {
-                return !impl->m_EventKeysWithChanges.isEmpty(); // TODO: catalogues
+                return !impl->m_KeysWithChanges.isEmpty();
             }
             QByteArray
                 return event->getUniqId().toString().append(event->getRepository());
             }
+            QString CatalogueController::CatalogueControllerPrivate::catalogueUniqueKey(
+                const std::shared_ptr<DBCatalogue> &catalogue) const
+            {
+                return catalogue->getUniqId().toString().append(catalogue->getRepository());
+            }
             void CatalogueController::CatalogueControllerPrivate::copyDBtoDB(const QString &dbFrom,
                                                                              const QString &dbTo)
             {
                 }
             }
-            std::shared_ptr<IRequestPredicate> CatalogueController::CatalogueControllerPrivate::createFinder(const QUuid &uniqId, const QString &repository, DBType type)
+            std::shared_ptr<IRequestPredicate> CatalogueController::CatalogueControllerPrivate::createFinder(
+                const QUuid &uniqId, const QString &repository, DBType type)
             {
                 // update catalogue parameter
-                auto uniqIdPredicate = std::make_shared<ComparaisonPredicate>(
+                auto uniqIdPredicate = std::make_shared<ComparaisonPredicate>(QString{"uniqId"}, uniqId,
-                    QString{"uniqId"}, uniqId, ComparaisonOperation::EQUALEQUAL);
+                                                                              ComparaisonOperation::EQUALEQUAL);
                 auto repositoryType = repository;
                 switch (type) {
                 }
                 auto repositoryPredicate = std::make_shared<ComparaisonPredicate>(
-                    QString{"repository"}, repositoryType,
+                    QString{"repository"}, repositoryType, ComparaisonOperation::EQUALEQUAL);
-                    ComparaisonOperation::EQUALEQUAL);
                 auto finderPred = std::make_shared<CompoundPredicate>(CompoundOperation::AND);
                 finderPred->AddRequestPredicate(uniqIdPredicate);

gui/include/Catalogue/CatalogueSideBarWidget.h +3 0

                 QVector<std::shared_ptr<DBCatalogue> > getCatalogues(const QString &repository) const;
+            private slots:
+                void emitSelection();
             private:
                 Ui::CatalogueSideBarWidget *ui;

gui/include/Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h +1 0

                 virtual ~CatalogueAbstractTreeItem();
                 void addChild(CatalogueAbstractTreeItem *child);
+                void removeChild(CatalogueAbstractTreeItem *child);
                 QVector<CatalogueAbstractTreeItem *> children() const;
                 CatalogueAbstractTreeItem *parent() const;

gui/include/Catalogue/CatalogueTreeModel.h +3 0

                 QVector<CatalogueAbstractTreeItem *> topLevelItems() const;
                 void addChildItem(CatalogueAbstractTreeItem *child, const QModelIndex &parentIndex);
+                void removeChildItem(CatalogueAbstractTreeItem *child, const QModelIndex &parentIndex);
+                /// Refresh the data for the specified index
+                void refresh(const QModelIndex &index);
                 CatalogueAbstractTreeItem *item(const QModelIndex &index) const;
                 QModelIndex indexOf(CatalogueAbstractTreeItem *item, int column = 0) const;

gui/src/Catalogue/CatalogueActionManager.cpp +3 -3

                     if (catalogue) {
-                        // TODO
+                        catalogue->addEvent(event->getUniqId());
-                        // catalogue->addEvent(event);
+                        sqpApp->catalogueController().updateCatalogue(catalogue);
                         m_CatalogueExplorer->sideBarWidget().setCatalogueChanges(catalogue, true);
                         if (m_CatalogueExplorer->eventsWidget().displayedCatalogues().contains(catalogue)) {
                             m_CatalogueExplorer->eventsWidget().addEvent(event);
                             if (!selectedCatalogue) {
                                 selectedCatalogue = std::make_shared<DBCatalogue>();
                                 selectedCatalogue->setName(dialog.catalogueName());
-                                // sqpApp->catalogueController().addCatalogue(selectedCatalogue); TODO
+                                sqpApp->catalogueController().addCatalogue(selectedCatalogue);
                                 impl->m_CatalogueExplorer->sideBarWidget().addCatalogue(selectedCatalogue,
                                                                                         REPOSITORY_DEFAULT);
                             }

gui/src/Catalogue/CatalogueSideBarWidget.cpp +123 -38

@@ -12,6 +12,7
12	#include <DBCatalogue.h>	12	#include <DBCatalogue.h>
13		13
14	#include <QMenu>	14	#include <QMenu>
		15	#include <QMessageBox>
15		16
16	Q_LOGGING_CATEGORY(LOG_CatalogueSideBarWidget, "CatalogueSideBarWidget")	17	Q_LOGGING_CATEGORY(LOG_CatalogueSideBarWidget, "CatalogueSideBarWidget")
17		18
@@ -33,7 +34,7 struct CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate {
33	const QModelIndex &databaseIndex);	34	const QModelIndex &databaseIndex);
34		35
35	CatalogueTreeItem *getCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue) const;	36	CatalogueTreeItem *getCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue) const;
36	void setHasChanges(bool value, const QModelIndex &index, ~~QTreeView~~ *~~treeView~~);	37	void setHasChanges(bool value, const QModelIndex &index, CatalogueSideBarWidget *sideBarWidget);
37	bool hasChanges(const QModelIndex &index, QTreeView *treeView);	38	bool hasChanges(const QModelIndex &index, QTreeView *treeView);
38		39
39	int selectionType(QTreeView *treeView) const	40	int selectionType(QTreeView *treeView) const
@@ -109,39 +110,77 CatalogueSideBarWidget::CatalogueSideBarWidget(QWidget *parent)
109	ui->treeView->header()->setSectionResizeMode(QHeaderView::ResizeToContents);	110	ui->treeView->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
110	ui->treeView->header()->setSectionResizeMode(0, QHeaderView::Stretch);	111	ui->treeView->header()->setSectionResizeMode(0, QHeaderView::Stretch);
111		112
112	auto emitSelection = [this]() {	113	connect(ui->treeView, &QTreeView::clicked, this, &CatalogueSideBarWidget::emitSelection);
		114	connect(ui->treeView->selectionModel(), &QItemSelectionModel::currentChanged, this,
		115	&CatalogueSideBarWidget::emitSelection);
113		116
114	auto selectionType = impl->selectionType(ui->treeView);
115		117
116	switch (selectionType) {	118	// connect(ui->btnAdd, &QToolButton::clicked, [this]() {
117	case CATALOGUE_ITEM_TYPE:	119	// QVector<std::shared_ptr<DBCatalogue> > catalogues;
118	emit this->catalogueSelected(impl->selectedCatalogues(ui->treeView));	120	// impl->getSelectedItems(ui->treeView, events, eventProducts);
119	break;	121
120	case DATABASE_ITEM_TYPE:	122	// if (!events.isEmpty() && eventProducts.isEmpty()) {
121	emit this->databaseSelected(impl->selectedRepositories(ui->treeView));	123
122	break;	124	// if (QMessageBox::warning(this, tr("Remove Event(s)"),
123	case ALL_EVENT_ITEM_TYPE:	125	// tr("The selected event(s) will be completly removed "
124	emit this->allEventsSelected();	126	// "from the repository!\nAre you sure you want to
125	break;	127	// continue?"),
126	case TRASH_ITEM_TYPE:	128	// QMessageBox::Yes \| QMessageBox::No, QMessageBox::No)
127	emit this->trashSelected();	129	// == QMessageBox::Yes) {
128	break;	130
129	default:	131	// for (auto event : events) {
130	emit this->selectionCleared();	132	// sqpApp->catalogueController().removeEvent(event);
131	break;	133	// impl->removeEvent(event, ui->treeView);
		134	// }
		135	// }
		136	// }
		137	// });
		138
		139
		140	connect(impl->m_TreeModel, &CatalogueTreeModel::itemDropped, [this](auto index) {
		141	auto item = impl->m_TreeModel->item(index);
		142	if (item && item->type() == CATALOGUE_ITEM_TYPE) {
		143	auto catalogue = static_cast<CatalogueTreeItem *>(item)->catalogue();
		144	this->setCatalogueChanges(catalogue, true);
132	}	145	}
133	};	146	});
		147	connect(ui->btnRemove, &QToolButton::clicked, [this]() {
		148	QVector<QPair<std::shared_ptr<DBCatalogue>, CatalogueAbstractTreeItem *> >
		149	cataloguesToItems;
		150	auto selectedIndexes = ui->treeView->selectionModel()->selectedRows();
134		151
135	connect(ui->treeView, &QTreeView::clicked, emitSelection);	152	for (auto index : selectedIndexes) {
136	connect(ui->treeView->selectionModel(), &QItemSelectionModel::currentChanged, emitSelection);	153	auto item = impl->m_TreeModel->item(index);
137	connect(impl->m_TreeModel, &CatalogueTreeModel::itemRenamed, [emitSelection, this](auto index) {	154	if (item && item->type() == CATALOGUE_ITEM_TYPE) {
		155	auto catalogue = static_cast<CatalogueTreeItem *>(item)->catalogue();
		156	cataloguesToItems << qMakePair(catalogue, item);
		157	}
		158	}
		159
		160	if (!cataloguesToItems.isEmpty()) {
		161
		162	if (QMessageBox::warning(this, tr("Remove Catalogue(s)"),
		163	tr("The selected catalogues(s) will be completly removed "
		164	"from the repository!\nAre you sure you want to continue?"),
		165	QMessageBox::Yes \| QMessageBox::No, QMessageBox::No)
		166	== QMessageBox::Yes) {
		167
		168	for (auto catalogueToItem : cataloguesToItems) {
		169	sqpApp->catalogueController().removeCatalogue(catalogueToItem.first);
		170	impl->m_TreeModel->removeChildItem(
		171	catalogueToItem.second,
		172	impl->m_TreeModel->indexOf(catalogueToItem.second->parent()));
		173	}
		174	}
		175	}
		176	});
		177
		178	connect(impl->m_TreeModel, &CatalogueTreeModel::itemRenamed, [this](auto index) {
138	auto selectedIndexes = ui->treeView->selectionModel()->selectedRows();	179	auto selectedIndexes = ui->treeView->selectionModel()->selectedRows();
139	if (selectedIndexes.contains(index)) {	180	if (selectedIndexes.contains(index)) {
140	emitSelection();	181	this->emitSelection();
141	}	182	}
142		183	impl->setHasChanges(true, index, this);
143	auto item = impl->m_TreeModel->item(index);
144	impl->setHasChanges(true, index, ui->treeView);
145	});	184	});
146		185
147	ui->treeView->setContextMenuPolicy(Qt::CustomContextMenu);	186	ui->treeView->setContextMenuPolicy(Qt::CustomContextMenu);
@@ -166,7 +205,7 void CatalogueSideBarWidget::setCatalogueChanges(const std::shared_ptr<DBCatalog
166	{	205	{
167	if (auto catalogueItem = impl->getCatalogueItem(catalogue)) {	206	if (auto catalogueItem = impl->getCatalogueItem(catalogue)) {
168	auto index = impl->m_TreeModel->indexOf(catalogueItem);	207	auto index = impl->m_TreeModel->indexOf(catalogueItem);
169	impl->setHasChanges(hasChanges, index, ui->~~treeView~~);	208	impl->setHasChanges(hasChanges, index, this);
170	// catalogueItem->refresh();	209	// catalogueItem->refresh();
171	}	210	}
172	}	211	}
@@ -189,6 +228,29 CatalogueSideBarWidget::getCatalogues(const QString &repository) const
189	return result;	228	return result;
190	}	229	}
191		230
		231	void CatalogueSideBarWidget::emitSelection()
		232	{
		233	auto selectionType = impl->selectionType(ui->treeView);
		234
		235	switch (selectionType) {
		236	case CATALOGUE_ITEM_TYPE:
		237	emit this->catalogueSelected(impl->selectedCatalogues(ui->treeView));
		238	break;
		239	case DATABASE_ITEM_TYPE:
		240	emit this->databaseSelected(impl->selectedRepositories(ui->treeView));
		241	break;
		242	case ALL_EVENT_ITEM_TYPE:
		243	emit this->allEventsSelected();
		244	break;
		245	case TRASH_ITEM_TYPE:
		246	emit this->trashSelected();
		247	break;
		248	default:
		249	emit this->selectionCleared();
		250	break;
		251	}
		252	}
		253
192	void CatalogueSideBarWidget::onContextMenuRequested(const QPoint &pos)	254	void CatalogueSideBarWidget::onContextMenuRequested(const QPoint &pos)
193	{	255	{
194	QMenu menu{this};	256	QMenu menu{this};
@@ -307,25 +369,48 CatalogueTreeItem *CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getCat
307	return nullptr;	369	return nullptr;
308	}	370	}
309		371
310	void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::setHasChanges(~~bool~~ ~~value~~,	372	void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::setHasChanges(
311	const QModelIndex &index,	373	bool value, const QModelIndex &index, CatalogueSideBarWidget *sideBarWidget)
312	QTreeView *treeView)
313	{	374	{
		375	std::shared_ptr<DBCatalogue> catalogue = nullptr;
		376	auto item = m_TreeModel->item(index);
		377	if (item && item->type() == CATALOGUE_ITEM_TYPE) {
		378	catalogue = static_cast<CatalogueTreeItem *>(item)->catalogue();
		379	}
		380
314	auto validationIndex = index.sibling(index.row(), (int)CatalogueTreeModel::Column::Validation);	381	auto validationIndex = index.sibling(index.row(), (int)CatalogueTreeModel::Column::Validation);
315	if (value) {	382	if (value) {
316	if (!hasChanges(validationIndex, treeView)) {	383	if (!hasChanges(validationIndex, sideBarWidget->ui->treeView)) {
317	auto widget = CatalogueExplorerHelper::buildValidationWidget(	384	auto widget = CatalogueExplorerHelper::buildValidationWidget(
318	treeView, [this, validationIndex,	385	sideBarWidget->ui->treeView,
319	treeView]() { setHasChanges(false, validationIndex, treeView); },	386	[this, validationIndex, sideBarWidget, catalogue]() {
320	[this, validationIndex, treeView]() {	387	if (catalogue) {
321	setHasChanges(false, validationIndex, treeView);	388	sqpApp->catalogueController().saveCatalogue(catalogue);
		389	}
		390	setHasChanges(false, validationIndex, sideBarWidget);
		391	},
		392	[this, validationIndex, sideBarWidget, catalogue, item]() {
		393	if (catalogue) {
		394	bool removed;
		395	sqpApp->catalogueController().discardCatalogue(catalogue, removed);
		396
		397	if (removed) {
		398	m_TreeModel->removeChildItem(item,
		399	m_TreeModel->indexOf(item->parent()));
		400	}
		401	else {
		402	m_TreeModel->refresh(m_TreeModel->indexOf(item));
		403	setHasChanges(false, validationIndex, sideBarWidget);
		404	}
		405	sideBarWidget->emitSelection();
		406	}
322	});	407	});
323	treeView->setIndexWidget(validationIndex, widget);	408	sideBarWidget->ui->treeView->setIndexWidget(validationIndex, widget);
324	}	409	}
325	}	410	}
326	else {	411	else {
327	// Note: the widget is destroyed	412	// Note: the widget is destroyed
328	treeView->setIndexWidget(validationIndex, nullptr);	413	sideBarWidget->ui->treeView->setIndexWidget(validationIndex, nullptr);
329	}	414	}
330	}	415	}
331		416

gui/src/Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.cpp +6 0

                 child->impl->m_Parent = this;
             }
+            void CatalogueAbstractTreeItem::removeChild(CatalogueAbstractTreeItem *child)
+            {
+                impl->m_Children.removeAll(child);
+                delete child;
+            }
             QVector<CatalogueAbstractTreeItem *> CatalogueAbstractTreeItem::children() const
             {
                 return impl->m_Children;

gui/src/Catalogue/CatalogueTreeItems/CatalogueTreeItem.cpp +14 -4

             bool CatalogueTreeItem::canDropMimeData(const QMimeData *data, Qt::DropAction action)
             {
-                return data->hasFormat(MIME_TYPE_EVENT_LIST);
+                auto events = sqpApp->catalogueController().eventsForMimeData(data->data(MIME_TYPE_EVENT_LIST));
+                auto canDrop = data->hasFormat(MIME_TYPE_EVENT_LIST);
+                for (auto event : events) {
+                    canDrop &= (event->getRepository() == impl->m_Catalogue->getRepository());
+                }
+                return canDrop;
             }
             bool CatalogueTreeItem::dropMimeData(const QMimeData *data, Qt::DropAction action)
             {
                 Q_ASSERT(canDropMimeData(data, action));
-                auto events = sqpApp->catalogueController().eventsForMimeData(data->data(MIME_TYPE_EVENT_LIST));
-                // impl->m_Catalogue->addEvents(events); TODO: move events in the new catalogue
                 // Warning: Check that the events aren't already in the catalogue
                 // Also check for the repository !!!
+                auto events = sqpApp->catalogueController().eventsForMimeData(data->data(MIME_TYPE_EVENT_LIST));
+                for (auto event : events) {
+                    impl->m_Catalogue->addEvent(event->getUniqId());
+                    sqpApp->catalogueController().updateCatalogue(impl->m_Catalogue);
+                }
             }
             std::shared_ptr<DBCatalogue> CatalogueTreeItem::catalogue() const

gui/src/Catalogue/CatalogueTreeModel.cpp +17 0

@@ -46,6 +46,23 void CatalogueTreeModel::addChildItem(CatalogueAbstractTreeItem *child,
46	emit dataChanged(parentIndex, parentIndex);	46	emit dataChanged(parentIndex, parentIndex);
47	}	47	}
48		48
		49	void CatalogueTreeModel::removeChildItem(CatalogueAbstractTreeItem *child,
		50	const QModelIndex &parentIndex)
		51	{
		52	auto parentItem = item(parentIndex);
		53	int i = parentItem->children().indexOf(child);
		54	beginRemoveRows(parentIndex, i, i);
		55	parentItem->removeChild(child);
		56	endRemoveRows();
		57
		58	emit dataChanged(parentIndex, parentIndex);
		59	}
		60
		61	void CatalogueTreeModel::refresh(const QModelIndex &index)
		62	{
		63	emit dataChanged(index, index);
		64	}
		65
49	CatalogueAbstractTreeItem *CatalogueTreeModel::item(const QModelIndex &index) const	66	CatalogueAbstractTreeItem *CatalogueTreeModel::item(const QModelIndex &index) const
50	{	67	{
51	return static_cast<CatalogueAbstractTreeItem *>(index.internalPointer());	68	return static_cast<CatalogueAbstractTreeItem *>(index.internalPointer());

gui/ui/Catalogue/CatalogueSideBarWidget.ui +2 -3

                  <item>
                   <widget class="QToolButton" name="btnAdd">
                    <property name="enabled">
-                    <bool>false</bool>
+                    <bool>true</bool>
                    </property>
                    <property name="text">
                     <string>+</string>
                  <item>
                   <widget class="QToolButton" name="btnRemove">
                    <property name="enabled">
-                    <bool>false</bool>
+                    <bool>true</bool>
                    </property>
                    <property name="text">
                     <string> - </string>
              </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