GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1362:c5e93e891fc6

Move event in catalogue with Drag&Drop

trabillard -

r1362:c5e93e891fc6

parent child

Context file:

r1362:c5e93e891fc6

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

                 /// Returns the list of variables contained in a MIME data
                 QVector<std::shared_ptr<DBEvent> > eventsForMimeData(const QByteArray &mimeData) const;
+                /// Returns the MIME data associated to a list of variables
+                QByteArray
+                mimeDataForCatalogues(const QVector<std::shared_ptr<DBCatalogue> > &catalogues) const;
+                /// Returns the list of variables contained in a MIME data
+                QVector<std::shared_ptr<DBCatalogue> > cataloguesForMimeData(const QByteArray &mimeData) const;
             public slots:
                 /// Manage init/end of the controller
                 void initialize();

core/include/Common/MimeTypesDef.h +1 0

             extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_TIME_RANGE;
             extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_SELECTION_ZONE;
             extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_EVENT_LIST;
+            extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_SOURCE_CATALOGUE_LIST;
             #endif // SCIQLOP_MIMETYPESDEF_H

core/src/Catalogue/CatalogueController.cpp +40 0

@@ -382,6 +382,46 CatalogueController::eventsForMimeData(const QByteArray &mimeData) const
382	return events;	382	return events;
383	}	383	}
384		384
		385	QByteArray CatalogueController::mimeDataForCatalogues(
		386	const QVector<std::shared_ptr<DBCatalogue> > &catalogues) const
		387	{
		388	auto encodedData = QByteArray{};
		389
		390	QMap<QString, QVariantList> idsPerRepository;
		391	for (auto catalogue : catalogues) {
		392	idsPerRepository[catalogue->getRepository()] << catalogue->getUniqId();
		393	}
		394
		395	QDataStream stream{&encodedData, QIODevice::WriteOnly};
		396	stream << idsPerRepository;
		397
		398	return encodedData;
		399	}
		400
		401	QVector<std::shared_ptr<DBCatalogue> >
		402	CatalogueController::cataloguesForMimeData(const QByteArray &mimeData) const
		403	{
		404	auto catalogues = QVector<std::shared_ptr<DBCatalogue> >{};
		405	QDataStream stream{mimeData};
		406
		407	QMap<QString, QVariantList> idsPerRepository;
		408	stream >> idsPerRepository;
		409
		410	for (auto it = idsPerRepository.cbegin(); it != idsPerRepository.cend(); ++it) {
		411	auto repository = it.key();
		412	auto allRepositoryCatalogues = retrieveCatalogues(repository);
		413	for (auto uuid : it.value()) {
		414	for (auto repositoryCatalogues : allRepositoryCatalogues) {
		415	if (uuid.toUuid() == repositoryCatalogues->getUniqId()) {
		416	catalogues << repositoryCatalogues;
		417	}
		418	}
		419	}
		420	}
		421
		422	return catalogues;
		423	}
		424
385	void CatalogueController::initialize()	425	void CatalogueController::initialize()
386	{	426	{
387	qCDebug(LOG_CatalogueController()) << tr("CatalogueController init")	427	qCDebug(LOG_CatalogueController()) << tr("CatalogueController init")

core/src/Common/MimeTypesDef.cpp +1 0

             const QString MIME_TYPE_TIME_RANGE = QStringLiteral("sciqlop/time-range");
             const QString MIME_TYPE_SELECTION_ZONE = QStringLiteral("sciqlop/selection-zone");
             const QString MIME_TYPE_EVENT_LIST = QStringLiteral("sciqlop/event-list");
+            const QString MIME_TYPE_SOURCE_CATALOGUE_LIST = QStringLiteral("sciqlop/source-catalogue-list");

gui/include/Catalogue/CatalogueEventsModel.h +2 0

             #include <QLoggingCategory>
             #include <unordered_set>
+            class DBCatalogue;
             class DBEvent;
             class DBEventProduct;
                 enum class Column { Name, TStart, TEnd, Tags, Product, Validation, NbColumn };
+                void setSourceCatalogues(const QVector<std::shared_ptr<DBCatalogue> > &catalogues);
                 void setEvents(const QVector<std::shared_ptr<DBEvent> > &events);
                 void addEvent(const std::shared_ptr<DBEvent> &event);
                 void removeEvent(const std::shared_ptr<DBEvent> &event);

gui/include/Catalogue/CatalogueTreeModel.h +1 -1

             signals:
                 void itemRenamed(const QModelIndex &index);
-                void itemDropped(const QModelIndex &parentIndex);
+                void itemDropped(const QModelIndex &parentIndex, const QMimeData *data, Qt::DropAction action);
             public:
                 CatalogueTreeModel(QObject *parent = nullptr);

gui/src/Catalogue/CatalogueEventsModel.cpp +13 -2

             struct CatalogueEventsModel::CatalogueEventsModelPrivate {
                 QVector<std::shared_ptr<DBEvent> > m_Events;
                 std::unordered_map<DBEvent *, QVector<std::shared_ptr<DBEventProduct> > > m_EventProducts;
+                QVector<std::shared_ptr<DBCatalogue> > m_SourceCatalogue;
                 QStringList columnNames()
                 {
             {
             }
+            void CatalogueEventsModel::setSourceCatalogues(
+                const QVector<std::shared_ptr<DBCatalogue> > &catalogues)
+            {
+                impl->m_SourceCatalogue = catalogues;
+            }
             void CatalogueEventsModel::setEvents(const QVector<std::shared_ptr<DBEvent> > &events)
             {
                 beginResetModel();
             Qt::DropActions CatalogueEventsModel::supportedDragActions() const
             {
-                return Qt::CopyAction;
+                return Qt::CopyAction | Qt::MoveAction;
             }
             QStringList CatalogueEventsModel::mimeTypes() const
             {
-                return {MIME_TYPE_EVENT_LIST, MIME_TYPE_TIME_RANGE};
+                return {MIME_TYPE_EVENT_LIST, MIME_TYPE_SOURCE_CATALOGUE_LIST, MIME_TYPE_TIME_RANGE};
             }
             QMimeData *CatalogueEventsModel::mimeData(const QModelIndexList &indexes) const
                 if (!eventList.isEmpty() && eventProductList.isEmpty()) {
                     auto eventsEncodedData = sqpApp->catalogueController().mimeDataForEvents(eventList);
                     mimeData->setData(MIME_TYPE_EVENT_LIST, eventsEncodedData);
+                    auto sourceCataloguesEncodedData
+                        = sqpApp->catalogueController().mimeDataForCatalogues(impl->m_SourceCatalogue);
+                    mimeData->setData(MIME_TYPE_SOURCE_CATALOGUE_LIST, sourceCataloguesEncodedData);
                 }
                 if (eventList.count() + eventProductList.count() == 1) {

gui/src/Catalogue/CatalogueEventsWidget.cpp +1 0

                 void setEvents(const QVector<std::shared_ptr<DBEvent> > &events, CatalogueEventsWidget *widget)
                 {
                     widget->ui->treeView->setSortingEnabled(false);
+                    m_Model->setSourceCatalogues(m_DisplayedCatalogues);
                     m_Model->setEvents(events);
                     widget->ui->treeView->setSortingEnabled(true);

gui/src/Catalogue/CatalogueSideBarWidget.cpp +17 -2

             #include <Catalogue/CatalogueTreeItems/CatalogueTreeItem.h>
             #include <Catalogue/CatalogueTreeModel.h>
             #include <CatalogueDao.h>
+            #include <Common/MimeTypesDef.h>
             #include <ComparaisonPredicate.h>
             #include <DBCatalogue.h>
             #include <QMenu>
             #include <QMessageBox>
+            #include <QMimeData>
             Q_LOGGING_CATEGORY(LOG_CatalogueSideBarWidget, "CatalogueSideBarWidget")
                 });
-                connect(impl->m_TreeModel, &CatalogueTreeModel::itemDropped, [this](auto index) {
+                connect(impl->m_TreeModel, &CatalogueTreeModel::itemDropped,
+                        [this](auto index, auto mimeData, auto action) {
                             auto item = impl->m_TreeModel->item(index);
                             if (item && item->type() == CATALOGUE_ITEM_TYPE) {
                                 auto catalogue = static_cast<CatalogueTreeItem *>(item)->catalogue();
                                 this->setCatalogueChanges(catalogue, true);
                             }
+                            if (action == Qt::MoveAction) {
+                                /// Display a save button on source catalogues
+                                auto sourceCatalogues = sqpApp->catalogueController().cataloguesForMimeData(
+                                    mimeData->data(MIME_TYPE_SOURCE_CATALOGUE_LIST));
+                                for (auto catalogue : sourceCatalogues) {
+                                    if (auto catalogueItem = impl->getCatalogueItem(catalogue)) {
+                                        this->setCatalogueChanges(catalogue, true);
+                                    }
+                                }
+                            }
                         });
                 connect(ui->btnRemove, &QToolButton::clicked, [this]() {
                     QVector<QPair<std::shared_ptr<DBCatalogue>, CatalogueAbstractTreeItem *> >
                         cataloguesToItems;
                         for (auto childItem : item->children()) {
                             if (childItem->type() == CATALOGUE_ITEM_TYPE) {
                                 auto catalogueItem = static_cast<CatalogueTreeItem *>(childItem);
-                                if (catalogueItem->catalogue() == catalogue) {
+                                if (catalogueItem->catalogue()->getUniqId() == catalogue->getUniqId()) {
                                     return catalogueItem;
                                 }
                             }

gui/src/Catalogue/CatalogueTreeItems/CatalogueTreeItem.cpp +26 -2

             bool CatalogueTreeItem::canDropMimeData(const QMimeData *data, Qt::DropAction action)
             {
+                // Check that the event is not dropped on the same catalogue
+                auto sourceCatalogues = sqpApp->catalogueController().cataloguesForMimeData(
+                    data->data(MIME_TYPE_SOURCE_CATALOGUE_LIST));
+                for (auto catalogue : sourceCatalogues) {
+                    if (catalogue->getUniqId() == impl->m_Catalogue->getUniqId()) {
+                        return false;
+                    }
+                }
                 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;
             }
             {
                 Q_ASSERT(canDropMimeData(data, action));
                 // Warning: Check that the events aren't already in the catalogue
-                // Also check for the repository !!!
+                // No need to check check for the repository: inter-repository drop is forbidden in
+                // canDropMimeData
                 auto events = sqpApp->catalogueController().eventsForMimeData(data->data(MIME_TYPE_EVENT_LIST));
+                auto sourceCatalogues = sqpApp->catalogueController().cataloguesForMimeData(
+                    data->data(MIME_TYPE_SOURCE_CATALOGUE_LIST));
                 for (auto event : events) {
+                    if (action == Qt::MoveAction) {
+                        for (auto catalogue : sourceCatalogues) {
+                            catalogue->removeEvent(event->getUniqId());
+                        }
+                    }
                     impl->m_Catalogue->addEvent(event->getUniqId());
-                    sqpApp->catalogueController().updateCatalogue(impl->m_Catalogue);
                 }
+                for (auto catalogue : sourceCatalogues) {
+                    sqpApp->catalogueController().updateCatalogue(catalogue);
+                }
+                sqpApp->catalogueController().updateCatalogue(impl->m_Catalogue);
             }
             std::shared_ptr<DBCatalogue> CatalogueTreeItem::catalogue() const

gui/src/Catalogue/CatalogueTreeModel.cpp +3 -2

                 return false;
             }
             bool CatalogueTreeModel::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row,
                                                      int column, const QModelIndex &parent) const
             {
                 if (draggedItem) {
                     result = draggedItem->dropMimeData(data, action);
                     if (result) {
-                        emit itemDropped(draggedIndex);
+                        emit itemDropped(draggedIndex, data, action);
                     }
                 }
             QStringList CatalogueTreeModel::mimeTypes() const
             {
-                return {MIME_TYPE_EVENT_LIST};
+                return {MIME_TYPE_EVENT_LIST, MIME_TYPE_SOURCE_CATALOGUE_LIST};
             }

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