GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1285:964109cb8b70

Drop of events on a catalogue

trabillard -

r1285:964109cb8b70

parent child

Context file:

r1285:964109cb8b70

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

             #ifndef SCIQLOP_CATALOGUECONTROLLER_H
             #define SCIQLOP_CATALOGUECONTROLLER_H
             #include "CoreGlobal.h"
             #include <Data/SqpRange.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             #include <memory>
             class DBCatalogue;
             class DBEvent;
             class DBEventProduct;
             Q_DECLARE_LOGGING_CATEGORY(LOG_CatalogueController)
             class DataSourceItem;
             class Variable;
             /**
              * @brief The CatalogueController class aims to handle catalogues and event using the CatalogueAPI
              * library.
              */
             class SCIQLOP_CORE_EXPORT CatalogueController : public QObject {
                 Q_OBJECT
             public:
                 explicit CatalogueController(QObject *parent = 0);
                 virtual ~CatalogueController();
                 // DB
                 QStringList getRepositories() const;
                 void addDB(const QString &dbPath);
                 void saveDB(const QString &destinationPath, const QString &repository);
                 // Event
                 /// retrieveEvents with empty repository retrieve them from the default repository
                 std::list<std::shared_ptr<DBEvent> > retrieveEvents(const QString &repository) const;
                 std::list<std::shared_ptr<DBEvent> > retrieveAllEvents() const;
                 std::list<std::shared_ptr<DBEvent> >
                 retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const;
                 void addEvent(std::shared_ptr<DBEvent> event);
                 void updateEvent(std::shared_ptr<DBEvent> event);
                 void updateEventProduct(std::shared_ptr<DBEventProduct> eventProduct);
                 void removeEvent(std::shared_ptr<DBEvent> event);
                 //    void trashEvent(std::shared_ptr<DBEvent> event);
                 //    void restore(QUuid eventId);
                 void saveEvent(std::shared_ptr<DBEvent> event);
                 // Catalogue
                 //    bool createCatalogue(const QString &name, QVector<QUuid> eventList);
                 /// retrieveEvents with empty repository retrieve them from the default repository
                 std::list<std::shared_ptr<DBCatalogue> > retrieveCatalogues(const QString &repository
                                                                             = QString()) const;
                 void updateCatalogue(std::shared_ptr<DBCatalogue> catalogue);
                 void removeCatalogue(std::shared_ptr<DBCatalogue> catalogue);
                 void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue);
                 void saveAll();
+                /// Returns the MIME data associated to a list of variables
+                QByteArray mimeDataForEvents(const QVector<std::shared_ptr<DBEvent> > &events) const;
+                /// Returns the list of variables contained in a MIME data
+                QVector<std::shared_ptr<DBEvent> > eventsForMimeData(const QByteArray &mimeData) const;
             public slots:
                 /// Manage init/end of the controller
                 void initialize();
                 void finalize();
             private:
                 void waitForFinish();
                 class CatalogueControllerPrivate;
                 spimpl::unique_impl_ptr<CatalogueControllerPrivate> impl;
             };
             #endif // SCIQLOP_CATALOGUECONTROLLER_H

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

             #include <Catalogue/CatalogueController.h>
             #include <Variable/Variable.h>
             #include <CatalogueDao.h>
             #include <ComparaisonPredicate.h>
             #include <CompoundPredicate.h>
             #include <DBCatalogue.h>
             #include <DBEvent.h>
             #include <DBEventProduct.h>
             #include <DBTag.h>
             #include <IRequestPredicate.h>
+            #include <QDataStream>
             #include <QMutex>
             #include <QThread>
             #include <QDir>
             #include <QStandardPaths>
             Q_LOGGING_CATEGORY(LOG_CatalogueController, "CatalogueController")
             namespace {
             static QString REPOSITORY_WORK_SUFFIX = QString{"_work"};
             static QString REPOSITORY_TRASH_SUFFIX = QString{"_trash"};
             }
             class CatalogueController::CatalogueControllerPrivate {
             public:
                 explicit CatalogueControllerPrivate(CatalogueController *parent) : m_Q{parent} {}
                 QMutex m_WorkingMutex;
                 CatalogueDao m_CatalogueDao;
                 QStringList m_RepositoryList;
                 CatalogueController *m_Q;
                 void copyDBtoDB(const QString &dbFrom, const QString &dbTo);
                 QString toWorkRepository(QString repository);
                 QString toSyncRepository(QString repository);
                 void savAllDB();
                 void saveEvent(std::shared_ptr<DBEvent> event, bool persist = true);
                 void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue, bool persist = true);
             };
             CatalogueController::CatalogueController(QObject *parent)
                     : impl{spimpl::make_unique_impl<CatalogueControllerPrivate>(this)}
             {
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController construction")
                                                    << QThread::currentThread();
             }
             CatalogueController::~CatalogueController()
             {
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController destruction")
                                                    << QThread::currentThread();
                 this->waitForFinish();
             }
             QStringList CatalogueController::getRepositories() const
             {
                 return impl->m_RepositoryList;
             }
             void CatalogueController::addDB(const QString &dbPath)
             {
                 QDir dbDir(dbPath);
                 if (dbDir.exists()) {
                     auto dirName = dbDir.dirName();
                     if (std::find(impl->m_RepositoryList.cbegin(), impl->m_RepositoryList.cend(), dirName)
                         != impl->m_RepositoryList.cend()) {
                         qCCritical(LOG_CatalogueController())
                             << tr("Impossible to addDB that is already loaded");
                     }
                     if (!impl->m_CatalogueDao.addDB(dbPath, dirName)) {
                         qCCritical(LOG_CatalogueController())
                             << tr("Impossible to addDB %1 from %2 ").arg(dirName, dbPath);
                     }
                     else {
                         impl->m_RepositoryList << dirName;
                         impl->copyDBtoDB(dirName, impl->toWorkRepository(dirName));
                     }
                 }
                 else {
                     qCCritical(LOG_CatalogueController()) << tr("Impossible to addDB that not exists: ")
                                                           << dbPath;
                 }
             }
             void CatalogueController::saveDB(const QString &destinationPath, const QString &repository)
             {
                 if (!impl->m_CatalogueDao.saveDB(destinationPath, repository)) {
                     qCCritical(LOG_CatalogueController())
                         << tr("Impossible to saveDB %1 from %2 ").arg(repository, destinationPath);
                 }
             }
             std::list<std::shared_ptr<DBEvent> >
             CatalogueController::retrieveEvents(const QString &repository) const
             {
                 QString dbDireName = repository.isEmpty() ? REPOSITORY_DEFAULT : repository;
                 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
                 auto events = impl->m_CatalogueDao.getEvents(impl->toWorkRepository(dbDireName));
                 for (auto event : events) {
                     eventsShared.push_back(std::make_shared<DBEvent>(event));
                 }
                 return eventsShared;
             }
             std::list<std::shared_ptr<DBEvent> > CatalogueController::retrieveAllEvents() const
             {
                 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
                 for (auto repository : impl->m_RepositoryList) {
                     eventsShared.splice(eventsShared.end(), retrieveEvents(repository));
                 }
                 return eventsShared;
             }
             std::list<std::shared_ptr<DBEvent> >
             CatalogueController::retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const
             {
                 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
                 auto events = impl->m_CatalogueDao.getCatalogueEvents(*catalogue);
                 for (auto event : events) {
                     eventsShared.push_back(std::make_shared<DBEvent>(event));
                 }
                 return eventsShared;
             }
             void CatalogueController::updateEvent(std::shared_ptr<DBEvent> event)
             {
                 event->setRepository(impl->toWorkRepository(event->getRepository()));
                 impl->m_CatalogueDao.updateEvent(*event);
             }
             void CatalogueController::updateEventProduct(std::shared_ptr<DBEventProduct> eventProduct)
             {
                 impl->m_CatalogueDao.updateEventProduct(*eventProduct);
             }
             void CatalogueController::removeEvent(std::shared_ptr<DBEvent> event)
             {
                 // Remove it from both repository and repository_work
                 event->setRepository(impl->toWorkRepository(event->getRepository()));
                 impl->m_CatalogueDao.removeEvent(*event);
                 event->setRepository(impl->toSyncRepository(event->getRepository()));
                 impl->m_CatalogueDao.removeEvent(*event);
             }
             void CatalogueController::addEvent(std::shared_ptr<DBEvent> event)
             {
                 event->setRepository(impl->toWorkRepository(event->getRepository()));
                 auto eventTemp = *event;
                 impl->m_CatalogueDao.addEvent(eventTemp);
                 // Call update is necessary at the creation of add Event if it has some tags or some event
                 // products
                 if (!event->getEventProducts().empty() || !event->getTags().empty()) {
                     auto eventProductsTemp = eventTemp.getEventProducts();
                     auto eventProductTempUpdated = std::list<DBEventProduct>{};
                     for (auto eventProductTemp : eventProductsTemp) {
                         eventProductTemp.setEvent(eventTemp);
                         eventProductTempUpdated.push_back(eventProductTemp);
                     }
                     eventTemp.setEventProducts(eventProductTempUpdated);
                     impl->m_CatalogueDao.updateEvent(eventTemp);
                 }
             }
             void CatalogueController::saveEvent(std::shared_ptr<DBEvent> event)
             {
                 impl->saveEvent(event, true);
             }
             std::list<std::shared_ptr<DBCatalogue> >
             CatalogueController::retrieveCatalogues(const QString &repository) const
             {
                 QString dbDireName = repository.isEmpty() ? REPOSITORY_DEFAULT : repository;
                 auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};
                 auto catalogues = impl->m_CatalogueDao.getCatalogues(impl->toWorkRepository(dbDireName));
                 for (auto catalogue : catalogues) {
                     cataloguesShared.push_back(std::make_shared<DBCatalogue>(catalogue));
                 }
                 return cataloguesShared;
             }
             void CatalogueController::updateCatalogue(std::shared_ptr<DBCatalogue> catalogue)
             {
                 catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
                 impl->m_CatalogueDao.updateCatalogue(*catalogue);
             }
             void CatalogueController::removeCatalogue(std::shared_ptr<DBCatalogue> catalogue)
             {
                 // Remove it from both repository and repository_work
                 catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
                 impl->m_CatalogueDao.removeCatalogue(*catalogue);
                 catalogue->setRepository(impl->toSyncRepository(catalogue->getRepository()));
                 impl->m_CatalogueDao.removeCatalogue(*catalogue);
             }
             void CatalogueController::saveCatalogue(std::shared_ptr<DBCatalogue> catalogue)
             {
                 impl->saveCatalogue(catalogue, true);
             }
             void CatalogueController::saveAll()
             {
                 for (auto repository : impl->m_RepositoryList) {
                     // Save Event
                     auto events = this->retrieveEvents(repository);
                     for (auto event : events) {
                         impl->saveEvent(event, false);
                     }
                     // Save Catalogue
                     auto catalogues = this->retrieveCatalogues(repository);
                     for (auto catalogue : catalogues) {
                         impl->saveCatalogue(catalogue, false);
                     }
                 }
                 impl->savAllDB();
             }
+            QByteArray
+            CatalogueController::mimeDataForEvents(const QVector<std::shared_ptr<DBEvent> > &events) const
+            {
+                auto encodedData = QByteArray{};
+                QMap<QString, QVariantList> idsPerRepository;
+                for (auto event : events) {
+                    idsPerRepository[event->getRepository()] << event->getUniqId();
+                }
+                QDataStream stream{&encodedData, QIODevice::WriteOnly};
+                stream << idsPerRepository;
+                return encodedData;
+            }
+            QVector<std::shared_ptr<DBEvent> >
+            CatalogueController::eventsForMimeData(const QByteArray &mimeData) const
+            {
+                auto events = QVector<std::shared_ptr<DBEvent> >{};
+                QDataStream stream{mimeData};
+                QMap<QString, QVariantList> idsPerRepository;
+                stream >> idsPerRepository;
+                for (auto it = idsPerRepository.cbegin(); it != idsPerRepository.cend(); ++it) {
+                    auto repository = it.key();
+                    auto allRepositoryEvent = retrieveEvents(repository);
+                    for (auto uuid : it.value()) {
+                        for (auto repositoryEvent : allRepositoryEvent) {
+                            if (uuid.toUuid() == repositoryEvent->getUniqId()) {
+                                events << repositoryEvent;
+                            }
+                        }
+                    }
+                }
+                return events;
+            }
             void CatalogueController::initialize()
             {
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController init")
                                                    << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 impl->m_CatalogueDao.initialize();
                 auto defaultRepositoryLocation
                     = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
                 QDir defaultRepositoryLocationDir;
                 if (defaultRepositoryLocationDir.mkpath(defaultRepositoryLocation)) {
                     defaultRepositoryLocationDir.cd(defaultRepositoryLocation);
                     auto defaultRepository = defaultRepositoryLocationDir.absoluteFilePath(REPOSITORY_DEFAULT);
                     qCInfo(LOG_CatalogueController()) << tr("Persistant data loading from: ")
                                                       << defaultRepository;
                     this->addDB(defaultRepository);
                 }
                 else {
                     qCWarning(LOG_CatalogueController())
                         << tr("Cannot load the persistent default repository from ")
                         << defaultRepositoryLocation;
                 }
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController init END");
             }
             void CatalogueController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void CatalogueController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }
             void CatalogueController::CatalogueControllerPrivate::copyDBtoDB(const QString &dbFrom,
                                                                              const QString &dbTo)
             {
                 //    auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};
                 auto catalogues = m_CatalogueDao.getCatalogues(dbFrom);
                 auto events = m_CatalogueDao.getEvents(dbFrom);
                 for (auto catalogue : catalogues) {
                     m_CatalogueDao.copyCatalogue(catalogue, dbTo, true);
                 }
                 for (auto event : events) {
                     m_CatalogueDao.copyEvent(event, dbTo, true);
                 }
             }
             QString CatalogueController::CatalogueControllerPrivate::toWorkRepository(QString repository)
             {
                 auto syncRepository = toSyncRepository(repository);
                 return QString("%1%2").arg(syncRepository, REPOSITORY_WORK_SUFFIX);
             }
             QString CatalogueController::CatalogueControllerPrivate::toSyncRepository(QString repository)
             {
                 auto syncRepository = repository;
                 if (repository.endsWith(REPOSITORY_WORK_SUFFIX)) {
                     syncRepository.remove(REPOSITORY_WORK_SUFFIX);
                 }
                 else if (repository.endsWith(REPOSITORY_TRASH_SUFFIX)) {
                     syncRepository.remove(REPOSITORY_TRASH_SUFFIX);
                 }
                 return syncRepository;
             }
             void CatalogueController::CatalogueControllerPrivate::savAllDB()
             {
                 for (auto repository : m_RepositoryList) {
                     auto defaultRepositoryLocation
                         = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
                     m_CatalogueDao.saveDB(defaultRepositoryLocation, repository);
                 }
             }
             void CatalogueController::CatalogueControllerPrivate::saveEvent(std::shared_ptr<DBEvent> event,
                                                                             bool persist)
             {
                 m_CatalogueDao.copyEvent(*event, toSyncRepository(event->getRepository()), true);
                 if (persist) {
                     savAllDB();
                 }
             }
             void CatalogueController::CatalogueControllerPrivate::saveCatalogue(
                 std::shared_ptr<DBCatalogue> catalogue, bool persist)
             {
                 m_CatalogueDao.copyCatalogue(*catalogue, toSyncRepository(catalogue->getRepository()), true);
                 if (persist) {
                     savAllDB();
                 }
             }

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

             #ifndef SCIQLOP_CATALOGUEABSTRACTTREEITEM_H
             #define SCIQLOP_CATALOGUEABSTRACTTREEITEM_H
             #include <Common/spimpl.h>
             #include <QVariant>
             #include <QVector>
             class QMimeData;
             class CatalogueAbstractTreeItem {
             public:
                 constexpr static const int DEFAULT_TYPE = -1;
                 CatalogueAbstractTreeItem(int type = DEFAULT_TYPE);
                 virtual ~CatalogueAbstractTreeItem();
                 void addChild(CatalogueAbstractTreeItem *child);
                 QVector<CatalogueAbstractTreeItem *> children() const;
                 CatalogueAbstractTreeItem *parent() const;
                 int type() const;
                 QString text(int column = 0) const;
                 virtual QVariant data(int column, int role) const;
                 virtual Qt::ItemFlags flags(int column) const;
                 virtual bool setData(int column, int role, const QVariant &value);
                 virtual bool canDropMimeData(const QMimeData *data, Qt::DropAction action);
+                virtual bool dropMimeData(const QMimeData *data, Qt::DropAction action);
             private:
                 class CatalogueAbstractTreeItemPrivate;
                 spimpl::unique_impl_ptr<CatalogueAbstractTreeItemPrivate> impl;
             };
             #endif // SCIQLOP_CATALOGUEABSTRACTTREEITEM_H

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

             #ifndef SCIQLOP_CATALOGUETREEITEM_H
             #define SCIQLOP_CATALOGUETREEITEM_H
             #include <Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h>
             #include <Common/spimpl.h>
             class DBCatalogue;
             class CatalogueTreeItem : public CatalogueAbstractTreeItem {
             public:
                 CatalogueTreeItem(std::shared_ptr<DBCatalogue> catalogue, const QIcon &icon, int type);
                 QVariant data(int column, int role) const override;
                 bool setData(int column, int role, const QVariant &value) override;
                 Qt::ItemFlags flags(int column) const override;
                 bool canDropMimeData(const QMimeData *data, Qt::DropAction action) override;
+                bool dropMimeData(const QMimeData *data, Qt::DropAction action) override;
                 /// Returns the catalogue represented by the item
                 std::shared_ptr<DBCatalogue> catalogue() const;
             private:
                 class CatalogueTreeItemPrivate;
                 spimpl::unique_impl_ptr<CatalogueTreeItemPrivate> impl;
             };
             #endif // SCIQLOP_CATALOGUETREEITEM_H

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

             #ifndef SCIQLOP_CATALOGUETREEMODEL_H
             #define SCIQLOP_CATALOGUETREEMODEL_H
             #include <Common/spimpl.h>
             #include <QAbstractItemModel>
             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
              */
             class CatalogueTreeModel : public QAbstractItemModel {
                 Q_OBJECT
             signals:
                 void itemRenamed(const QModelIndex &index);
+                void itemDropped(const QModelIndex &parentIndex);
             public:
                 CatalogueTreeModel(QObject *parent = nullptr);
                 enum class Column { Name, Validation, Count };
                 QModelIndex addTopLevelItem(CatalogueAbstractTreeItem *item);
                 QVector<CatalogueAbstractTreeItem *> topLevelItems() const;
                 void addChildItem(CatalogueAbstractTreeItem *child, const QModelIndex &parentIndex);
                 CatalogueAbstractTreeItem *item(const QModelIndex &index) 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/src/Catalogue/CatalogueEventsModel.cpp +6 -4

             #include "Catalogue/CatalogueEventsModel.h"
+            #include <Catalogue/CatalogueController.h>
             #include <Common/DateUtils.h>
             #include <Common/MimeTypesDef.h>
             #include <DBEvent.h>
             #include <DBEventProduct.h>
             #include <DBTag.h>
             #include <Data/SqpRange.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <list>
             #include <unordered_map>
             #include <QHash>
             #include <QMimeData>
             Q_LOGGING_CATEGORY(LOG_CatalogueEventsModel, "CatalogueEventsModel")
             const auto EVENT_ITEM_TYPE = 1;
             const auto EVENT_PRODUCT_ITEM_TYPE = 2;
             struct CatalogueEventsModel::CatalogueEventsModelPrivate {
                 QVector<std::shared_ptr<DBEvent> > m_Events;
                 std::unordered_map<DBEvent *, QVector<std::shared_ptr<DBEventProduct> > > m_EventProducts;
                 std::unordered_set<std::shared_ptr<DBEvent> > m_EventsWithChanges;
                 QStringList columnNames()
                 {
                     return QStringList{tr("Event"), tr("TStart"),  tr("TEnd"),
                                        tr("Tags"),  tr("Product"), tr("")};
                 }
                 QVariant sortData(int col, const std::shared_ptr<DBEvent> &event) const
                 {
                     if (col == (int)CatalogueEventsModel::Column::Validation) {
                         return m_EventsWithChanges.find(event) != m_EventsWithChanges.cend() ? true
                                                                                              : QVariant();
                     }
                     return eventData(col, event);
                 }
                 QVariant eventData(int col, const std::shared_ptr<DBEvent> &event) const
                 {
                     switch (static_cast<Column>(col)) {
                         case CatalogueEventsModel::Column::Name:
                             return event->getName();
                         case CatalogueEventsModel::Column::TStart:
                             return nbEventProducts(event) > 0 ? DateUtils::dateTime(event->getTStart())
                                                               : QVariant{};
                         case CatalogueEventsModel::Column::TEnd:
                             return nbEventProducts(event) > 0 ? DateUtils::dateTime(event->getTEnd())
                                                               : QVariant{};
                         case CatalogueEventsModel::Column::Product:
                             return QString::number(nbEventProducts(event)) + " product(s)";
                         case CatalogueEventsModel::Column::Tags: {
                             QString tagList;
                             auto tags = event->getTags();
                             for (auto tag : tags) {
                                 tagList += tag.getName();
                                 tagList += ' ';
                             }
                             return tagList;
                         }
                         case CatalogueEventsModel::Column::Validation:
                             return QVariant();
                         default:
                             break;
                     }
                     Q_ASSERT(false);
                     return QStringLiteral("Unknown Data");
                 }
                 void parseEventProduct(const std::shared_ptr<DBEvent> &event)
                 {
                     for (auto product : event->getEventProducts()) {
                         m_EventProducts[event.get()].append(std::make_shared<DBEventProduct>(product));
                     }
                 }
                 int nbEventProducts(const std::shared_ptr<DBEvent> &event) const
                 {
                     auto eventProductsIt = m_EventProducts.find(event.get());
                     if (eventProductsIt != m_EventProducts.cend()) {
                         return m_EventProducts.at(event.get()).count();
                     }
                     else {
                         return 0;
                     }
                 }
                 QVariant eventProductData(int col, const std::shared_ptr<DBEventProduct> &eventProduct) const
                 {
                     switch (static_cast<Column>(col)) {
                         case CatalogueEventsModel::Column::Name:
                             return eventProduct->getProductId();
                         case CatalogueEventsModel::Column::TStart:
                             return DateUtils::dateTime(eventProduct->getTStart());
                         case CatalogueEventsModel::Column::TEnd:
                             return DateUtils::dateTime(eventProduct->getTEnd());
                         case CatalogueEventsModel::Column::Product:
                             return eventProduct->getProductId();
                         case CatalogueEventsModel::Column::Tags:
                             return QString();
                         case CatalogueEventsModel::Column::Validation:
                             return QVariant();
                         default:
                             break;
                     }
                     Q_ASSERT(false);
                     return QStringLiteral("Unknown Data");
                 }
             };
             CatalogueEventsModel::CatalogueEventsModel(QObject *parent)
                     : QAbstractItemModel(parent), impl{spimpl::make_unique_impl<CatalogueEventsModelPrivate>()}
             {
             }
             void CatalogueEventsModel::setEvents(const QVector<std::shared_ptr<DBEvent> > &events)
             {
                 beginResetModel();
                 impl->m_Events = events;
                 impl->m_EventProducts.clear();
                 impl->m_EventsWithChanges.clear();
                 for (auto event : events) {
                     impl->parseEventProduct(event);
                 }
                 endResetModel();
             }
             std::shared_ptr<DBEvent> CatalogueEventsModel::getEvent(const QModelIndex &index) const
             {
                 if (itemTypeOf(index) == CatalogueEventsModel::ItemType::Event) {
                     return impl->m_Events.value(index.row());
                 }
                 else {
                     return nullptr;
                 }
             }
             std::shared_ptr<DBEvent> CatalogueEventsModel::getParentEvent(const QModelIndex &index) const
             {
                 if (itemTypeOf(index) == CatalogueEventsModel::ItemType::EventProduct) {
                     return getEvent(index.parent());
                 }
                 else {
                     return nullptr;
                 }
             }
             std::shared_ptr<DBEventProduct>
             CatalogueEventsModel::getEventProduct(const QModelIndex &index) const
             {
                 if (itemTypeOf(index) == CatalogueEventsModel::ItemType::EventProduct) {
                     auto event = static_cast<DBEvent *>(index.internalPointer());
                     return impl->m_EventProducts.at(event).value(index.row());
                 }
                 else {
                     return nullptr;
                 }
             }
             void CatalogueEventsModel::addEvent(const std::shared_ptr<DBEvent> &event)
             {
                 beginInsertRows(QModelIndex(), impl->m_Events.count() - 1, impl->m_Events.count() - 1);
                 impl->m_Events.append(event);
                 impl->parseEventProduct(event);
                 endInsertRows();
             }
             void CatalogueEventsModel::removeEvent(const std::shared_ptr<DBEvent> &event)
             {
                 auto index = impl->m_Events.indexOf(event);
                 if (index >= 0) {
                     beginRemoveRows(QModelIndex(), index, index);
                     impl->m_Events.removeAt(index);
                     impl->m_EventProducts.erase(event.get());
                     impl->m_EventsWithChanges.erase(event);
                     endRemoveRows();
                 }
             }
             QVector<std::shared_ptr<DBEvent> > CatalogueEventsModel::events() const
             {
                 return impl->m_Events;
             }
             void CatalogueEventsModel::refreshEvent(const std::shared_ptr<DBEvent> &event)
             {
                 auto eventIndex = indexOf(event);
                 if (eventIndex.isValid()) {
                     // Refreshes the event line
                     auto colCount = columnCount();
                     emit dataChanged(eventIndex, index(eventIndex.row(), colCount));
                     // Also refreshes its children event products
                     auto childCount = rowCount(eventIndex);
                     emit dataChanged(index(0, 0, eventIndex), index(childCount, colCount, eventIndex));
                 }
                 else {
                     qCWarning(LOG_CatalogueEventsModel()) << "refreshEvent: event not found.";
                 }
             }
             QModelIndex CatalogueEventsModel::indexOf(const std::shared_ptr<DBEvent> &event) const
             {
                 auto row = impl->m_Events.indexOf(event);
                 if (row >= 0) {
                     return index(row, 0);
                 }
                 return QModelIndex();
             }
             void CatalogueEventsModel::setEventHasChanges(const std::shared_ptr<DBEvent> &event,
                                                           bool hasChanges)
             {
                 if (hasChanges) {
                     impl->m_EventsWithChanges.insert(event);
                 }
                 else {
                     impl->m_EventsWithChanges.erase(event);
                 }
             }
             bool CatalogueEventsModel::eventsHasChanges(const std::shared_ptr<DBEvent> &event) const
             {
                 return impl->m_EventsWithChanges.find(event) != impl->m_EventsWithChanges.cend();
             }
             QModelIndex CatalogueEventsModel::index(int row, int column, const QModelIndex &parent) const
             {
                 if (!hasIndex(row, column, parent)) {
                     return QModelIndex();
                 }
                 switch (itemTypeOf(parent)) {
                     case CatalogueEventsModel::ItemType::Root:
                         return createIndex(row, column);
                     case CatalogueEventsModel::ItemType::Event: {
                         auto event = getEvent(parent);
                         return createIndex(row, column, event.get());
                     }
                     case CatalogueEventsModel::ItemType::EventProduct:
                         break;
                     default:
                         break;
                 }
                 return QModelIndex();
             }
             QModelIndex CatalogueEventsModel::parent(const QModelIndex &index) const
             {
                 switch (itemTypeOf(index)) {
                     case CatalogueEventsModel::ItemType::EventProduct: {
                         auto parentEvent = static_cast<DBEvent *>(index.internalPointer());
                         auto it
                             = std::find_if(impl->m_Events.cbegin(), impl->m_Events.cend(),
                                            [parentEvent](auto event) { return event.get() == parentEvent; });
                         if (it != impl->m_Events.cend()) {
                             return createIndex(it - impl->m_Events.cbegin(), 0);
                         }
                         else {
                             return QModelIndex();
                         }
                     }
                     case CatalogueEventsModel::ItemType::Root:
                         break;
                     case CatalogueEventsModel::ItemType::Event:
                         break;
                     default:
                         break;
                 }
                 return QModelIndex();
             }
             int CatalogueEventsModel::rowCount(const QModelIndex &parent) const
             {
                 if (parent.column() > 0) {
                     return 0;
                 }
                 switch (itemTypeOf(parent)) {
                     case CatalogueEventsModel::ItemType::Root:
                         return impl->m_Events.count();
                     case CatalogueEventsModel::ItemType::Event: {
                         auto event = getEvent(parent);
                         return impl->m_EventProducts[event.get()].count();
                     }
                     case CatalogueEventsModel::ItemType::EventProduct:
                         break;
                     default:
                         break;
                 }
                 return 0;
             }
             int CatalogueEventsModel::columnCount(const QModelIndex &parent) const
             {
                 return static_cast<int>(CatalogueEventsModel::Column::NbColumn);
             }
             Qt::ItemFlags CatalogueEventsModel::flags(const QModelIndex &index) const
             {
                 return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
             }
             QVariant CatalogueEventsModel::data(const QModelIndex &index, int role) const
             {
                 if (index.isValid()) {
                     auto type = itemTypeOf(index);
                     if (type == CatalogueEventsModel::ItemType::Event) {
                         auto event = getEvent(index);
                         switch (role) {
                             case Qt::DisplayRole:
                                 return impl->eventData(index.column(), event);
                                 break;
                         }
                     }
                     else if (type == CatalogueEventsModel::ItemType::EventProduct) {
                         auto product = getEventProduct(index);
                         switch (role) {
                             case Qt::DisplayRole:
                                 return impl->eventProductData(index.column(), product);
                                 break;
                         }
                     }
                 }
                 return QVariant{};
             }
             QVariant CatalogueEventsModel::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
                     return impl->columnNames().value(section);
                 }
                 return QVariant();
             }
             void CatalogueEventsModel::sort(int column, Qt::SortOrder order)
             {
                 std::sort(impl->m_Events.begin(), impl->m_Events.end(),
                           [this, column, order](auto e1, auto e2) {
                               auto data1 = impl->sortData(column, e1);
                               auto data2 = impl->sortData(column, e2);
                               auto result = data1.toString() < data2.toString();
                               return order == Qt::AscendingOrder ? result : !result;
                           });
                 emit dataChanged(QModelIndex(), QModelIndex());
                 emit modelSorted();
             }
             Qt::DropActions CatalogueEventsModel::supportedDragActions() const
             {
-                return Qt::CopyAction | Qt::MoveAction;
+                return Qt::CopyAction;
             }
             QStringList CatalogueEventsModel::mimeTypes() const
             {
                 return {MIME_TYPE_EVENT_LIST, MIME_TYPE_TIME_RANGE};
             }
             QMimeData *CatalogueEventsModel::mimeData(const QModelIndexList &indexes) const
             {
                 auto mimeData = new QMimeData;
                 bool isFirst = true;
                 QVector<std::shared_ptr<DBEvent> > eventList;
                 QVector<std::shared_ptr<DBEventProduct> > eventProductList;
                 SqpRange firstTimeRange;
                 for (const auto &index : indexes) {
                     if (index.column() == 0) { // only the first column
                         auto type = itemTypeOf(index);
                         if (type == ItemType::Event) {
                             auto event = getEvent(index);
                             eventList << event;
                             if (isFirst) {
                                 isFirst = false;
                                 firstTimeRange.m_TStart = event->getTStart();
                                 firstTimeRange.m_TEnd = event->getTEnd();
                             }
                         }
                         else if (type == ItemType::EventProduct) {
                             auto product = getEventProduct(index);
                             eventProductList << product;
                             if (isFirst) {
                                 isFirst = false;
                                 firstTimeRange.m_TStart = product->getTStart();
                                 firstTimeRange.m_TEnd = product->getTEnd();
                             }
                         }
                     }
                 }
-                auto eventsEncodedData
+                if (!eventList.isEmpty() && eventProductList.isEmpty()) {
-                    = QByteArray{}; // sqpApp->catalogueController().->mimeDataForEvents(eventList); //TODO
+                    auto eventsEncodedData = sqpApp->catalogueController().mimeDataForEvents(eventList);
-                mimeData->setData(MIME_TYPE_EVENT_LIST, eventsEncodedData);
+                    mimeData->setData(MIME_TYPE_EVENT_LIST, eventsEncodedData);
+                }
                 if (eventList.count() + eventProductList.count() == 1) {
                     // No time range MIME data if multiple events are dragged
                     auto timeEncodedData = TimeController::mimeDataForTimeRange(firstTimeRange);
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeEncodedData);
                 }
                 return mimeData;
             }
             CatalogueEventsModel::ItemType CatalogueEventsModel::itemTypeOf(const QModelIndex &index) const
             {
                 if (!index.isValid()) {
                     return ItemType::Root;
                 }
                 else if (index.internalPointer() == nullptr) {
                     return ItemType::Event;
                 }
                 else {
                     return ItemType::EventProduct;
                 }
             }

gui/src/Catalogue/CatalogueSideBarWidget.cpp +74 -56

             #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 <CatalogueDao.h>
             #include <ComparaisonPredicate.h>
             #include <DBCatalogue.h>
             #include <QMenu>
             Q_LOGGING_CATEGORY(LOG_CatalogueSideBarWidget, "CatalogueSideBarWidget")
             constexpr auto ALL_EVENT_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 1;
             constexpr auto TRASH_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 2;
             constexpr auto CATALOGUE_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 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);
                 CatalogueAbstractTreeItem *getDatabaseItem(const QString &name);
                 void addCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue,
                                       const QModelIndex &databaseIndex);
                 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);
+                int selectionType(QTreeView *treeView) const
+                {
+                    auto selectedItems = treeView->selectionModel()->selectedRows();
+                    if (selectedItems.isEmpty()) {
+                        return CatalogueAbstractTreeItem::DEFAULT_TYPE;
+                    }
+                    else {
+                        auto firstIndex = selectedItems.first();
+                        auto firstItem = m_TreeModel->item(firstIndex);
+                        if (!firstItem) {
+                            Q_ASSERT(false);
+                            return CatalogueAbstractTreeItem::DEFAULT_TYPE;
+                        }
+                        auto selectionType = firstItem->type();
+                        for (auto itemIndex : selectedItems) {
+                            auto item = m_TreeModel->item(itemIndex);
+                            if (!item || item->type() != selectionType) {
+                                // Incoherent multi selection
+                                selectionType = CatalogueAbstractTreeItem::DEFAULT_TYPE;
+                                break;
+                            }
+                        }
+                        return selectionType;
+                    }
+                }
+                QVector<std::shared_ptr<DBCatalogue> > selectedCatalogues(QTreeView *treeView) const
+                {
+                    QVector<std::shared_ptr<DBCatalogue> > catalogues;
+                    auto selectedItems = treeView->selectionModel()->selectedRows();
+                    for (auto itemIndex : selectedItems) {
+                        auto item = m_TreeModel->item(itemIndex);
+                        if (item && item->type() == CATALOGUE_ITEM_TYPE) {
+                            catalogues.append(static_cast<CatalogueTreeItem *>(item)->catalogue());
+                        }
+                    }
+                    return catalogues;
+                }
+                QStringList selectedRepositories(QTreeView *treeView) const
+                {
+                    QStringList repositories;
+                    auto selectedItems = treeView->selectionModel()->selectedRows();
+                    for (auto itemIndex : selectedItems) {
+                        auto item = m_TreeModel->item(itemIndex);
+                        if (item && item->type() == DATABASE_ITEM_TYPE) {
+                            repositories.append(item->text());
+                        }
+                    }
+                    return repositories;
+                }
             };
             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();
+                    auto selectionType = impl->selectionType(ui->treeView);
-                    if (selectedItems.isEmpty()) {
-                        emit this->selectionCleared();
+                    switch (selectionType) {
+                        case CATALOGUE_ITEM_TYPE:
+                            emit this->catalogueSelected(impl->selectedCatalogues(ui->treeView));
+                            break;
+                        case DATABASE_ITEM_TYPE:
+                            emit this->databaseSelected(impl->selectedRepositories(ui->treeView));
+                            break;
+                        case ALL_EVENT_ITEM_TYPE:
+                            emit this->allEventsSelected();
+                            break;
+                        case TRASH_ITEM_TYPE:
+                            emit this->trashSelected();
+                            break;
+                        default:
+                            emit this->selectionCleared();
+                            break;
                     }
-                    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(static_cast<CatalogueTreeItem *>(item)->catalogue());
-                                        break;
-                                    case DATABASE_ITEM_TYPE:
-                                        databases.append(item->text());
-                                    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, &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();
                 }
             }
             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 CatalogueTextTreeItem{QIcon{":/icones/allEvents.png"}, "All Events",
                                                                ALL_EVENT_ITEM_TYPE};
                 m_TreeModel->addTopLevelItem(allEventsItem);
                 auto trashItem
                     = 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 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 CatalogueTextTreeItem{QIcon{":/icones/database.png"}, {name}, DATABASE_ITEM_TYPE};
                 auto databaseIndex = m_TreeModel->addTopLevelItem(databaseItem);
                 return databaseIndex;
             }
             CatalogueAbstractTreeItem *
             CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getDatabaseItem(const QString &name)
             {
                 for (auto item : m_TreeModel->topLevelItems()) {
                     if (item->type() == DATABASE_ITEM_TYPE && item->text() == name) {
                         return item;
                     }
                 }
                 return nullptr;
             }
             void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addCatalogueItem(
                 const std::shared_ptr<DBCatalogue> &catalogue, const QModelIndex &databaseIndex)
             {
                 auto catalogueItem
                     = new CatalogueTreeItem{catalogue, QIcon{":/icones/catalogue.png"}, CATALOGUE_ITEM_TYPE};
                 m_TreeModel->addChildItem(catalogueItem, databaseIndex);
             }
             CatalogueTreeItem *CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getCatalogueItem(
                 const std::shared_ptr<DBCatalogue> &catalogue) const
             {
                 for (auto item : m_TreeModel->topLevelItems()) {
                     if (item->type() == DATABASE_ITEM_TYPE) {
                         for (auto childItem : item->children()) {
                             if (childItem->type() == CATALOGUE_ITEM_TYPE) {
                                 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/CatalogueAbstractTreeItem.cpp +7 0

             #include "Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h"
             struct CatalogueAbstractTreeItem::CatalogueAbstractTreeItemPrivate {
                 int m_Type;
                 QVector<CatalogueAbstractTreeItem *> m_Children;
                 CatalogueAbstractTreeItem *m_Parent = nullptr;
                 CatalogueAbstractTreeItemPrivate(int type) : m_Type(type) {}
             };
             CatalogueAbstractTreeItem::CatalogueAbstractTreeItem(int type)
                     : impl{spimpl::make_unique_impl<CatalogueAbstractTreeItemPrivate>(type)}
             {
             }
             CatalogueAbstractTreeItem::~CatalogueAbstractTreeItem()
             {
                 qDeleteAll(impl->m_Children);
             }
             void CatalogueAbstractTreeItem::addChild(CatalogueAbstractTreeItem *child)
             {
                 impl->m_Children << child;
                 child->impl->m_Parent = this;
             }
             QVector<CatalogueAbstractTreeItem *> CatalogueAbstractTreeItem::children() const
             {
                 return impl->m_Children;
             }
             CatalogueAbstractTreeItem *CatalogueAbstractTreeItem::parent() const
             {
                 return impl->m_Parent;
             }
             int CatalogueAbstractTreeItem::type() const
             {
                 return impl->m_Type;
             }
             QString CatalogueAbstractTreeItem::text(int column) const
             {
                 return data(0, Qt::DisplayRole).toString();
             }
             QVariant CatalogueAbstractTreeItem::data(int column, int role) const
             {
                 Q_UNUSED(column);
                 Q_UNUSED(role);
                 return QVariant();
             }
             Qt::ItemFlags CatalogueAbstractTreeItem::flags(int column) const
             {
                 Q_UNUSED(column);
                 return Qt::NoItemFlags;
             }
             bool CatalogueAbstractTreeItem::setData(int column, int role, const QVariant &value)
             {
                 Q_UNUSED(column);
                 Q_UNUSED(role);
                 Q_UNUSED(value);
                 return false;
             }
             bool CatalogueAbstractTreeItem::canDropMimeData(const QMimeData *data, Qt::DropAction action)
             {
                 Q_UNUSED(data);
                 Q_UNUSED(action);
                 return false;
             }
+            bool CatalogueAbstractTreeItem::dropMimeData(const QMimeData *data, Qt::DropAction action)
+            {
+                Q_UNUSED(data);
+                Q_UNUSED(action);
+                return false;
+            }

gui/src/Catalogue/CatalogueTreeItems/CatalogueTreeItem.cpp +10 0

             #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>
             struct CatalogueTreeItem::CatalogueTreeItemPrivate {
                 std::shared_ptr<DBCatalogue> m_Catalogue;
                 QIcon m_Icon;
                 CatalogueTreeItemPrivate(std::shared_ptr<DBCatalogue> catalogue, const QIcon &icon)
                         : m_Catalogue(catalogue), m_Icon(icon)
                 {
                 }
             };
             CatalogueTreeItem::CatalogueTreeItem(std::shared_ptr<DBCatalogue> catalogue, const QIcon &icon,
                                                  int type)
                     : CatalogueAbstractTreeItem(type),
                       impl{spimpl::make_unique_impl<CatalogueTreeItemPrivate>(catalogue, icon)}
             {
             }
             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 QVariant();
             }
             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()) {
                         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 {
                     return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
                 }
             }
             bool CatalogueTreeItem::canDropMimeData(const QMimeData *data, Qt::DropAction action)
             {
                 return data->hasFormat(MIME_TYPE_EVENT_LIST);
             }
+            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 !!!
+            }
             std::shared_ptr<DBCatalogue> CatalogueTreeItem::catalogue() const
             {
                 return impl->m_Catalogue;
             }

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

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

gui/ui/Catalogue/CatalogueSideBarWidget.ui +3 0

             <?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::DragDrop</enum>
                  </property>
+                 <property name="selectionMode">
+                  <enum>QAbstractItemView::ExtendedSelection</enum>
+                 </property>
                  <attribute name="headerVisible">
                   <bool>false</bool>
                  </attribute>
                  <attribute name="headerStretchLastSection">
                   <bool>false</bool>
                  </attribute>
                 </widget>
                </item>
               </layout>
              </widget>
              <resources>
               <include location="../../resources/sqpguiresources.qrc"/>
               <include location="../../resources/sqpguiresources.qrc"/>
              </resources>
              <connections/>
             </ui>

General Comments 3

perrinel

|

Auto status change to "Under Review"

perrinel

|

Status change > Approved

Write
Preview

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

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages