GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1363:faf6baef791f

Merge branch 'feature/CataloguePart6' into develop

trabillard -

r1363:faf6baef791f

parent child

Context file:

r1363:faf6baef791f

core/include/Catalogue/CatalogueController.h +7 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;
                 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(std::shared_ptr<DBEvent> event);
                 void saveEvent(std::shared_ptr<DBEvent> event);
                 void discardEvent(std::shared_ptr<DBEvent> event, bool &removed);
                 bool eventHasChanges(std::shared_ptr<DBEvent> event) const;
                 // Catalogue
                 std::list<std::shared_ptr<DBEvent> >
                 retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const;
                 /// retrieveEvents with empty repository retrieve them from the default repository
                 std::list<std::shared_ptr<DBCatalogue> > retrieveCatalogues(const QString &repository
                                                                             = QString()) const;
                 void addCatalogue(std::shared_ptr<DBCatalogue> catalogue);
                 void updateCatalogue(std::shared_ptr<DBCatalogue> catalogue);
                 void removeCatalogue(std::shared_ptr<DBCatalogue> catalogue);
                 void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue);
                 void discardCatalogue(std::shared_ptr<DBCatalogue> catalogue, bool &removed);
                 void saveAll();
                 bool hasChanges() const;
                 /// 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;
+                /// 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();
             private:
                 class CatalogueControllerPrivate;
                 spimpl::unique_impl_ptr<CatalogueControllerPrivate> impl;
             };
             #endif // SCIQLOP_CATALOGUECONTROLLER_H

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

             #ifndef SCIQLOP_MIMETYPESDEF_H
             #define SCIQLOP_MIMETYPESDEF_H
             #include "CoreGlobal.h"
             #include <QString>
             // ////////////////// //
             // SciQlop Mime Types //
             // ////////////////// //
             extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_GRAPH;
             extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_ZONE;
             extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_VARIABLE_LIST;
             extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_PRODUCT_LIST;
             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

             #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"};
             }
             /**
              * Possible types of an repository
              */
             enum class DBType { SYNC, WORK, TRASH };
             class CatalogueController::CatalogueControllerPrivate {
             public:
                 explicit CatalogueControllerPrivate(CatalogueController *parent) : m_Q{parent} {}
                 CatalogueDao m_CatalogueDao;
                 QStringList m_RepositoryList;
                 CatalogueController *m_Q;
                 QSet<QString> m_KeysWithChanges;
                 QString eventUniqueKey(const std::shared_ptr<DBEvent> &event) const;
                 QString catalogueUniqueKey(const std::shared_ptr<DBCatalogue> &catalogue) const;
                 void copyDBtoDB(const QString &dbFrom, const QString &dbTo);
                 QString toWorkRepository(QString repository);
                 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);
                 std::shared_ptr<IRequestPredicate> createFinder(const QUuid &uniqId, const QString &repository,
                                                                 DBType type);
             };
             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();
             }
             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()));
                 auto uniqueId = impl->eventUniqueKey(event);
                 impl->m_KeysWithChanges.insert(uniqueId);
                 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);
                 impl->savAllDB();
             }
             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);
                 }
                 auto workPred = impl->createFinder(event->getUniqId(), event->getRepository(), DBType::WORK);
                 auto workEvent = impl->m_CatalogueDao.getEvent(workPred);
                 *event = workEvent;
                 auto uniqueId = impl->eventUniqueKey(event);
                 impl->m_KeysWithChanges.insert(uniqueId);
             }
             void CatalogueController::saveEvent(std::shared_ptr<DBEvent> event)
             {
                 impl->saveEvent(event, true);
                 impl->m_KeysWithChanges.remove(impl->eventUniqueKey(event));
             }
             void CatalogueController::discardEvent(std::shared_ptr<DBEvent> event, bool &removed)
             {
                 auto syncPred = impl->createFinder(event->getUniqId(), event->getRepository(), DBType::SYNC);
                 auto workPred = impl->createFinder(event->getUniqId(), event->getRepository(), DBType::WORK);
                 auto syncEvent = impl->m_CatalogueDao.getEvent(syncPred);
                 if (!syncEvent.getUniqId().isNull()) {
                     removed = false;
                     impl->m_CatalogueDao.copyEvent(syncEvent, impl->toWorkRepository(event->getRepository()),
                                                    true);
                     auto workEvent = impl->m_CatalogueDao.getEvent(workPred);
                     *event = workEvent;
                     impl->m_KeysWithChanges.remove(impl->eventUniqueKey(event));
                 }
                 else {
                     removed = true;
                     // Since the element wasn't in sync repository. Discard it means remove it
                     event->setRepository(impl->toWorkRepository(event->getRepository()));
                     impl->m_CatalogueDao.removeEvent(*event);
                 }
             }
             bool CatalogueController::eventHasChanges(std::shared_ptr<DBEvent> event) const
             {
                 return impl->m_KeysWithChanges.contains(impl->eventUniqueKey(event));
             }
             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::addCatalogue(std::shared_ptr<DBCatalogue> catalogue)
             {
                 catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
                 auto catalogueTemp = *catalogue;
                 impl->m_CatalogueDao.addCatalogue(catalogueTemp);
                 auto workPred
                     = impl->createFinder(catalogue->getUniqId(), catalogue->getRepository(), DBType::WORK);
                 auto workCatalogue = impl->m_CatalogueDao.getCatalogue(workPred);
                 *catalogue = workCatalogue;
                 auto uniqueId = impl->catalogueUniqueKey(catalogue);
                 impl->m_KeysWithChanges.insert(uniqueId);
             }
             void CatalogueController::updateCatalogue(std::shared_ptr<DBCatalogue> catalogue)
             {
                 catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
                 auto uniqueId = impl->catalogueUniqueKey(catalogue);
                 impl->m_KeysWithChanges.insert(uniqueId);
                 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);
                 impl->savAllDB();
             }
             void CatalogueController::saveCatalogue(std::shared_ptr<DBCatalogue> catalogue)
             {
                 impl->saveCatalogue(catalogue, true);
                 impl->m_KeysWithChanges.remove(impl->catalogueUniqueKey(catalogue));
             }
             void CatalogueController::discardCatalogue(std::shared_ptr<DBCatalogue> catalogue, bool &removed)
             {
                 auto syncPred
                     = impl->createFinder(catalogue->getUniqId(), catalogue->getRepository(), DBType::SYNC);
                 auto workPred
                     = impl->createFinder(catalogue->getUniqId(), catalogue->getRepository(), DBType::WORK);
                 auto syncCatalogue = impl->m_CatalogueDao.getCatalogue(syncPred);
                 if (!syncCatalogue.getUniqId().isNull()) {
                     removed = false;
                     impl->m_CatalogueDao.copyCatalogue(
                         syncCatalogue, impl->toWorkRepository(catalogue->getRepository()), true);
                     auto workCatalogue = impl->m_CatalogueDao.getCatalogue(workPred);
                     *catalogue = workCatalogue;
                     impl->m_KeysWithChanges.remove(impl->catalogueUniqueKey(catalogue));
                 }
                 else {
                     removed = true;
                     // Since the element wasn't in sync repository. Discard it means remove it
                     catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
                     impl->m_CatalogueDao.removeCatalogue(*catalogue);
                 }
             }
             void CatalogueController::saveAll()
             {
                 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();
                 impl->m_KeysWithChanges.clear();
             }
             bool CatalogueController::hasChanges() const
             {
                 return !impl->m_KeysWithChanges.isEmpty();
             }
             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;
             }
+            QByteArray CatalogueController::mimeDataForCatalogues(
+                const QVector<std::shared_ptr<DBCatalogue> > &catalogues) const
+            {
+                auto encodedData = QByteArray{};
+                QMap<QString, QVariantList> idsPerRepository;
+                for (auto catalogue : catalogues) {
+                    idsPerRepository[catalogue->getRepository()] << catalogue->getUniqId();
+                }
+                QDataStream stream{&encodedData, QIODevice::WriteOnly};
+                stream << idsPerRepository;
+                return encodedData;
+            }
+            QVector<std::shared_ptr<DBCatalogue> >
+            CatalogueController::cataloguesForMimeData(const QByteArray &mimeData) const
+            {
+                auto catalogues = QVector<std::shared_ptr<DBCatalogue> >{};
+                QDataStream stream{mimeData};
+                QMap<QString, QVariantList> idsPerRepository;
+                stream >> idsPerRepository;
+                for (auto it = idsPerRepository.cbegin(); it != idsPerRepository.cend(); ++it) {
+                    auto repository = it.key();
+                    auto allRepositoryCatalogues = retrieveCatalogues(repository);
+                    for (auto uuid : it.value()) {
+                        for (auto repositoryCatalogues : allRepositoryCatalogues) {
+                            if (uuid.toUuid() == repositoryCatalogues->getUniqId()) {
+                                catalogues << repositoryCatalogues;
+                            }
+                        }
+                    }
+                }
+                return catalogues;
+            }
             void CatalogueController::initialize()
             {
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController init")
                                                    << QThread::currentThread();
                 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;
                     QDir dbDir(defaultRepository);
                     impl->m_RepositoryList << REPOSITORY_DEFAULT;
                     if (dbDir.exists()) {
                         auto dirName = dbDir.dirName();
                         if (impl->m_CatalogueDao.addDB(defaultRepository, dirName)) {
                             impl->copyDBtoDB(dirName, impl->toWorkRepository(dirName));
                         }
                     }
                     else {
                         qCInfo(LOG_CatalogueController()) << tr("Initialisation of Default repository detected")
                                                           << defaultRepository;
                     }
                 }
                 else {
                     qCWarning(LOG_CatalogueController())
                         << tr("Cannot load the persistent default repository from ")
                         << defaultRepositoryLocation;
                 }
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController init END");
             }
             QString CatalogueController::CatalogueControllerPrivate::eventUniqueKey(
                 const std::shared_ptr<DBEvent> &event) const
             {
                 return event->getUniqId().toString().append(event->getRepository());
             }
             QString CatalogueController::CatalogueControllerPrivate::catalogueUniqueKey(
                 const std::shared_ptr<DBCatalogue> &catalogue) const
             {
                 return catalogue->getUniqId().toString().append(catalogue->getRepository());
             }
             void CatalogueController::CatalogueControllerPrivate::copyDBtoDB(const QString &dbFrom,
                                                                              const QString &dbTo)
             {
                 //    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();
                 }
             }
             std::shared_ptr<IRequestPredicate> CatalogueController::CatalogueControllerPrivate::createFinder(
                 const QUuid &uniqId, const QString &repository, DBType type)
             {
                 // update catalogue parameter
                 auto uniqIdPredicate = std::make_shared<ComparaisonPredicate>(QString{"uniqId"}, uniqId,
                                                                               ComparaisonOperation::EQUALEQUAL);
                 auto repositoryType = repository;
                 switch (type) {
                     case DBType::SYNC:
                         repositoryType = toSyncRepository(repositoryType);
                         break;
                     case DBType::WORK:
                         repositoryType = toWorkRepository(repositoryType);
                         break;
                     case DBType::TRASH:
                     default:
                         break;
                 }
                 auto repositoryPredicate = std::make_shared<ComparaisonPredicate>(
                     QString{"repository"}, repositoryType, ComparaisonOperation::EQUALEQUAL);
                 auto finderPred = std::make_shared<CompoundPredicate>(CompoundOperation::AND);
                 finderPred->AddRequestPredicate(uniqIdPredicate);
                 finderPred->AddRequestPredicate(repositoryPredicate);
                 return finderPred;
             }

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

             #include "Common/MimeTypesDef.h"
             const QString MIME_TYPE_GRAPH = QStringLiteral("sciqlop/graph");
             const QString MIME_TYPE_ZONE = QStringLiteral("sciqlop/zone");
             const QString MIME_TYPE_VARIABLE_LIST = QStringLiteral("sciqlop/var-list");
             const QString MIME_TYPE_PRODUCT_LIST = QStringLiteral("sciqlop/product-list");
             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

             #ifndef SCIQLOP_CATALOGUEEVENTSMODEL_H
             #define SCIQLOP_CATALOGUEEVENTSMODEL_H
             #include <Common/spimpl.h>
             #include <QAbstractItemModel>
             #include <QLoggingCategory>
             #include <unordered_set>
+            class DBCatalogue;
             class DBEvent;
             class DBEventProduct;
             Q_DECLARE_LOGGING_CATEGORY(LOG_CatalogueEventsModel)
             class CatalogueEventsModel : public QAbstractItemModel {
                 Q_OBJECT
             signals:
                 void modelSorted();
             public:
                 CatalogueEventsModel(QObject *parent = nullptr);
                 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);
                 QVector<std::shared_ptr<DBEvent> > events() const;
                 enum class ItemType { Root, Event, EventProduct };
                 ItemType itemTypeOf(const QModelIndex &index) const;
                 std::shared_ptr<DBEvent> getEvent(const QModelIndex &index) const;
                 std::shared_ptr<DBEvent> getParentEvent(const QModelIndex &index) const;
                 std::shared_ptr<DBEventProduct> getEventProduct(const QModelIndex &index) const;
                 /// Refresh the data for the specified event
                 void refreshEvent(const std::shared_ptr<DBEvent> &event, bool refreshEventProducts = false);
                 /// Returns a QModelIndex which represent the specified event
                 QModelIndex indexOf(const std::shared_ptr<DBEvent> &event) const;
                 /// Marks a change flag on the specified event to allow sorting on the validation column
                 void setEventHasChanges(const std::shared_ptr<DBEvent> &event, bool hasChanges);
                 /// Returns true if the specified event has unsaved changes
                 bool eventsHasChanges(const std::shared_ptr<DBEvent> &event) const;
                 // Model
                 QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const;
                 QModelIndex parent(const QModelIndex &index) const;
                 int rowCount(const QModelIndex &parent = QModelIndex()) const override;
                 int columnCount(const QModelIndex &parent = QModelIndex()) const override;
                 Qt::ItemFlags flags(const QModelIndex &index) const override;
                 QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
                 QVariant headerData(int section, Qt::Orientation orientation,
                                     int role = Qt::DisplayRole) const override;
                 void sort(int column, Qt::SortOrder order = Qt::AscendingOrder) override;
                 Qt::DropActions supportedDragActions() const override;
                 QStringList mimeTypes() const override;
                 QMimeData *mimeData(const QModelIndexList &indexes) const override;
             private:
                 class CatalogueEventsModelPrivate;
                 spimpl::unique_impl_ptr<CatalogueEventsModelPrivate> impl;
             };
             #endif // SCIQLOP_CATALOGUEEVENTSMODEL_H

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

             #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);
+                void itemDropped(const QModelIndex &parentIndex, const QMimeData *data, Qt::DropAction action);
             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);
                 void removeChildItem(CatalogueAbstractTreeItem *child, const QModelIndex &parentIndex);
                 /// Refresh the data for the specified index
                 void refresh(const QModelIndex &index);
                 CatalogueAbstractTreeItem *item(const QModelIndex &index) const;
                 QModelIndex indexOf(CatalogueAbstractTreeItem *item, int column = 0) const;
                 // 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/include/Visualization/VisualizationZoneWidget.h +3 0

             #ifndef SCIQLOP_VISUALIZATIONZONEWIDGET_H
             #define SCIQLOP_VISUALIZATIONZONEWIDGET_H
             #include "Data/SqpRange.h"
             #include "Visualization/IVisualizationWidget.h"
             #include "Visualization/VisualizationDragWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
             #include <memory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationZoneWidget)
             namespace Ui {
             class VisualizationZoneWidget;
             } // namespace Ui
             class Variable;
             class VisualizationGraphWidget;
             class VisualizationZoneWidget : public VisualizationDragWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationZoneWidget();
                 /// Sets the range of the zone, only works if there is at least one graph in the zone
                 /// Note: calibrations between graphs are lost.
                 void setZoneRange(const SqpRange &range);
                 /// Adds a graph widget
                 void addGraph(VisualizationGraphWidget *graphWidget);
                 /// Inserts a graph widget
                 void insertGraph(int index, VisualizationGraphWidget *graphWidget);
                 /**
                  * Creates a graph using a variable. The variable will be displayed in the new graph.
                  * The graph is added at the end.
                  * @param variable the variable for which to create the graph
                  * @return the pointer to the created graph
                  */
                 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable);
                 /**
                  * Creates a graph using a variable. The variable will be displayed in the new graph.
                  * The graph is inserted at the specified index.
                  * @param variable the variable for which to create the graph
                  * @param index The index where the graph should be inserted in the layout
                  * @return the pointer to the created graph
                  */
                 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable, int index);
                 /**
                  * Creates a graph using a list of variables. The variables will be displayed in the new graph.
                  * The graph is inserted at the specified index.
                  * @param variables List of variables to be added to the graph
                  * @param index The index where the graph should be inserted in the layout
                  * @return the pointer to the created graph
                  */
                 VisualizationGraphWidget *createGraph(const QList<std::shared_ptr<Variable> > variables,
                                                       int index);
                 /// Returns the first graph in the zone or nullptr if there is no graph inside
                 VisualizationGraphWidget *firstGraph() const;
+                /// Closes all graphes inside the zone
+                void closeAllGraphs();
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
                 bool contains(const Variable &variable) const override;
                 QString name() const override;
                 // VisualisationDragWidget
                 QMimeData *mimeData(const QPoint &position) const override;
                 bool isDragAllowed() const override;
                 void notifyMouseMoveInGraph(const QPointF &graphPosition, const QPointF &plotPosition,
                                             VisualizationGraphWidget *graphWidget);
                 void notifyMouseLeaveGraph(VisualizationGraphWidget *graphWidget);
             protected:
                 void closeEvent(QCloseEvent *event) override;
             private:
                 Ui::VisualizationZoneWidget *ui;
                 class VisualizationZoneWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationZoneWidgetPrivate> impl;
             private slots:
                 void onVariableAdded(std::shared_ptr<Variable> variable);
                 /// Slot called when a variable is about to be removed from a graph contained in the zone
                 void onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable);
                 void dropMimeData(int index, const QMimeData *mimeData);
                 void dropMimeDataOnGraph(VisualizationDragWidget *dragWidget, const QMimeData *mimeData);
             };
             #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H

gui/src/Catalogue/CatalogueActionManager.cpp 0 -2

             #include "Catalogue/CatalogueActionManager.h"
             #include <Actions/ActionsGuiController.h>
             #include <Catalogue/CatalogueController.h>
             #include <DataSource/DataSourceItem.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <Visualization/VisualizationGraphWidget.h>
             #include <Visualization/VisualizationSelectionZoneItem.h>
             #include <Catalogue/CatalogueEventsWidget.h>
             #include <Catalogue/CatalogueExplorer.h>
             #include <Catalogue/CatalogueSideBarWidget.h>
             #include <Catalogue/CreateEventDialog.h>
             #include <CatalogueDao.h>
             #include <DBCatalogue.h>
             #include <DBEvent.h>
             #include <DBEventProduct.h>
             #include <QBoxLayout>
             #include <QComboBox>
             #include <QDialog>
             #include <QDialogButtonBox>
             #include <QLineEdit>
             #include <memory>
             struct CatalogueActionManager::CatalogueActionManagerPrivate {
                 CatalogueExplorer *m_CatalogueExplorer = nullptr;
                 CatalogueActionManagerPrivate(CatalogueExplorer *catalogueExplorer)
                         : m_CatalogueExplorer(catalogueExplorer)
                 {
                 }
                 void createEventFromZones(const QString &eventName,
                                           const QVector<VisualizationSelectionZoneItem *> &zones,
                                           const std::shared_ptr<DBCatalogue> &catalogue = nullptr)
                 {
                     auto event = std::make_shared<DBEvent>();
                     event->setName(eventName);
                     std::list<DBEventProduct> productList;
                     for (auto zone : zones) {
                         auto graph = zone->parentGraphWidget();
                         for (auto var : graph->variables()) {
                             auto eventProduct = std::make_shared<DBEventProduct>();
                             eventProduct->setEvent(*event);
                             auto productId
                                 = var->metadata().value(DataSourceItem::ID_DATA_KEY, "UnknownID").toString();
                             auto zoneRange = zone->range();
                             eventProduct->setTStart(zoneRange.m_TStart);
                             eventProduct->setTEnd(zoneRange.m_TEnd);
                             eventProduct->setProductId(productId);
                             productList.push_back(*eventProduct);
-                            m_CatalogueExplorer->addSelectionZoneItem(event, productId, zone);
                         }
                     }
                     event->setEventProducts(productList);
                     sqpApp->catalogueController().addEvent(event);
                     if (catalogue) {
                         catalogue->addEvent(event->getUniqId());
                         sqpApp->catalogueController().updateCatalogue(catalogue);
                         m_CatalogueExplorer->sideBarWidget().setCatalogueChanges(catalogue, true);
                         if (m_CatalogueExplorer->eventsWidget().displayedCatalogues().contains(catalogue)) {
                             m_CatalogueExplorer->eventsWidget().addEvent(event);
                             m_CatalogueExplorer->eventsWidget().setEventChanges(event, true);
                         }
                     }
                     else if (m_CatalogueExplorer->eventsWidget().isAllEventsDisplayed()) {
                         m_CatalogueExplorer->eventsWidget().addEvent(event);
                         m_CatalogueExplorer->eventsWidget().setEventChanges(event, true);
                     }
                 }
             };
             CatalogueActionManager::CatalogueActionManager(CatalogueExplorer *catalogueExplorer)
                     : impl{spimpl::make_unique_impl<CatalogueActionManagerPrivate>(catalogueExplorer)}
             {
             }
             void CatalogueActionManager::installSelectionZoneActions()
             {
                 auto &actionController = sqpApp->actionsGuiController();
                 auto createEventEnableFuntion = [](auto zones) {
                     // Checks that all variables in the zones doesn't refer to the same product
                     QSet<QString> usedDatasource;
                     for (auto zone : zones) {
                         auto graph = zone->parentGraphWidget();
                         auto variables = graph->variables();
                         for (auto var : variables) {
                             auto datasourceId = var->metadata().value(DataSourceItem::ID_DATA_KEY).toString();
                             if (!usedDatasource.contains(datasourceId)) {
                                 usedDatasource.insert(datasourceId);
                             }
                             else {
                                 return false;
                             }
                         }
                     }
                     return true;
                 };
                 auto createEventAction = actionController.addSectionZoneAction(
                     {QObject::tr("Catalogues")}, QObject::tr("New Event..."), [this](auto zones) {
                         CreateEventDialog dialog(
                             impl->m_CatalogueExplorer->sideBarWidget().getCatalogues(REPOSITORY_DEFAULT));
                         dialog.hideCatalogueChoice();
                         if (dialog.exec() == QDialog::Accepted) {
                             impl->createEventFromZones(dialog.eventName(), zones);
                         }
                     });
                 createEventAction->setEnableFunction(createEventEnableFuntion);
                 auto createEventInCatalogueAction = actionController.addSectionZoneAction(
                     {QObject::tr("Catalogues")}, QObject::tr("New Event in Catalogue..."), [this](auto zones) {
                         CreateEventDialog dialog(
                             impl->m_CatalogueExplorer->sideBarWidget().getCatalogues(REPOSITORY_DEFAULT));
                         if (dialog.exec() == QDialog::Accepted) {
                             auto selectedCatalogue = dialog.selectedCatalogue();
                             if (!selectedCatalogue) {
                                 selectedCatalogue = std::make_shared<DBCatalogue>();
                                 selectedCatalogue->setName(dialog.catalogueName());
                                 sqpApp->catalogueController().addCatalogue(selectedCatalogue);
                                 impl->m_CatalogueExplorer->sideBarWidget().addCatalogue(selectedCatalogue,
                                                                                         REPOSITORY_DEFAULT);
                             }
                             impl->createEventFromZones(dialog.eventName(), zones, selectedCatalogue);
                         }
                     });
                 createEventInCatalogueAction->setEnableFunction(createEventEnableFuntion);
             }

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

             #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;
+                QVector<std::shared_ptr<DBCatalogue> > m_SourceCatalogue;
                 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) {
                         auto hasChanges = sqpApp->catalogueController().eventHasChanges(event);
                         return hasChanges ? 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");
                 }
                 void refreshChildrenOfIndex(CatalogueEventsModel *model, const QModelIndex &index) const
                 {
                     auto childCount = model->rowCount(index);
                     auto colCount = model->columnCount();
                     emit model->dataChanged(model->index(0, 0, index),
                                             model->index(childCount, colCount, index));
                 }
             };
             CatalogueEventsModel::CatalogueEventsModel(QObject *parent)
                     : QAbstractItemModel(parent), impl{spimpl::make_unique_impl<CatalogueEventsModelPrivate>()}
             {
             }
+            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();
                 impl->m_Events = events;
                 impl->m_EventProducts.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(), impl->m_Events.count());
                 impl->m_Events.append(event);
                 impl->parseEventProduct(event);
                 endInsertRows();
                 // Also refreshes its children event products
                 auto eventIndex = index(impl->m_Events.count(), 0);
                 impl->refreshChildrenOfIndex(this, eventIndex);
             }
             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());
                     endRemoveRows();
                 }
             }
             QVector<std::shared_ptr<DBEvent> > CatalogueEventsModel::events() const
             {
                 return impl->m_Events;
             }
             void CatalogueEventsModel::refreshEvent(const std::shared_ptr<DBEvent> &event,
                                                     bool refreshEventProducts)
             {
                 auto eventIndex = indexOf(event);
                 if (eventIndex.isValid()) {
                     if (refreshEventProducts) {
                         // Reparse the associated event products
                         auto nbEventProducts = impl->nbEventProducts(event);
                         auto newNbOfEventProducts = event->getEventProducts().size();
                         if (newNbOfEventProducts < nbEventProducts) {
                             beginRemoveRows(eventIndex, newNbOfEventProducts, nbEventProducts - 1);
                             impl->m_EventProducts.erase(event.get());
                             impl->parseEventProduct(event);
                             endRemoveRows();
                         }
                         else if (newNbOfEventProducts > nbEventProducts) {
                             beginInsertRows(eventIndex, nbEventProducts, newNbOfEventProducts - 1);
                             impl->m_EventProducts.erase(event.get());
                             impl->parseEventProduct(event);
                             endInsertRows();
                         }
                         else { // newNbOfEventProducts == nbEventProducts
                             impl->m_EventProducts.erase(event.get());
                             impl->parseEventProduct(event);
                         }
                     }
                     // Refreshes the event line
                     auto colCount = columnCount();
                     emit dataChanged(eventIndex, index(eventIndex.row(), colCount));
                     // Also refreshes its children event products
                     impl->refreshChildrenOfIndex(this, 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();
             }
             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)
             {
                 beginResetModel();
                 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;
                           });
                 endResetModel();
                 emit modelSorted();
             }
             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
             {
                 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();
                             }
                         }
                     }
                 }
                 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) {
                     // 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/CatalogueEventsWidget.cpp +5 -1

             #include "Catalogue/CatalogueEventsWidget.h"
             #include "ui_CatalogueEventsWidget.h"
             #include <Catalogue/CatalogueController.h>
             #include <Catalogue/CatalogueEventsModel.h>
             #include <Catalogue/CatalogueExplorerHelper.h>
             #include <CatalogueDao.h>
             #include <DBCatalogue.h>
             #include <DBEventProduct.h>
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/VisualizationGraphWidget.h>
             #include <Visualization/VisualizationTabWidget.h>
             #include <Visualization/VisualizationWidget.h>
             #include <Visualization/VisualizationZoneWidget.h>
             #include <QDialog>
             #include <QDialogButtonBox>
             #include <QListWidget>
             #include <QMessageBox>
             Q_LOGGING_CATEGORY(LOG_CatalogueEventsWidget, "CatalogueEventsWidget")
             /// Fixed size of the validation column
             const auto VALIDATION_COLUMN_SIZE = 35;
             /// Percentage added to the range of a event when it is displayed
             const auto EVENT_RANGE_MARGE = 30; // in %
             struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
                 CatalogueEventsModel *m_Model = nullptr;
                 QStringList m_ZonesForTimeMode;
                 QString m_ZoneForGraphMode;
                 QVector<std::shared_ptr<DBCatalogue> > m_DisplayedCatalogues;
                 bool m_AllEventDisplayed = false;
                 QVector<VisualizationGraphWidget *> m_CustomGraphs;
                 VisualizationWidget *m_VisualizationWidget = nullptr;
                 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);
                     for (auto event : events) {
                         if (sqpApp->catalogueController().eventHasChanges(event)) {
                             auto index = m_Model->indexOf(event);
                             widget->setEventChanges(event, true);
                         }
                     }
                 }
                 void addEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
                 {
                     treeView->setSortingEnabled(false);
                     m_Model->addEvent(event);
                     treeView->setSortingEnabled(true);
                 }
                 void removeEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
                 {
                     treeView->setSortingEnabled(false);
                     m_Model->removeEvent(event);
                     treeView->setSortingEnabled(true);
                 }
                 QStringList getAvailableVisualizationZoneList() const
                 {
                     if (m_VisualizationWidget) {
                         if (auto tab = m_VisualizationWidget->currentTabWidget()) {
                             return tab->availableZoneWidgets();
                         }
                     }
                     return QStringList{};
                 }
                 QStringList selectZone(QWidget *parent, const QStringList &selectedZones,
                                        bool allowMultiSelection, const QPoint &location)
                 {
                     auto availableZones = getAvailableVisualizationZoneList();
                     if (availableZones.isEmpty()) {
                         return QStringList{};
                     }
                     QDialog d(parent, Qt::Tool);
                     d.setWindowTitle("Choose a zone");
                     auto layout = new QVBoxLayout{&d};
                     layout->setContentsMargins(0, 0, 0, 0);
                     auto listWidget = new QListWidget{&d};
                     layout->addWidget(listWidget);
                     QSet<QListWidgetItem *> checkedItems;
                     for (auto zone : availableZones) {
                         auto item = new QListWidgetItem{zone};
                         item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
                         if (selectedZones.contains(zone)) {
                             item->setCheckState(Qt::Checked);
                             checkedItems << item;
                         }
                         else {
                             item->setCheckState(Qt::Unchecked);
                         }
                         listWidget->addItem(item);
                     }
                     auto buttonBox = new QDialogButtonBox{QDialogButtonBox::Ok, &d};
                     layout->addWidget(buttonBox);
                     QObject::connect(buttonBox, &QDialogButtonBox::accepted, &d, &QDialog::accept);
                     QObject::connect(buttonBox, &QDialogButtonBox::rejected, &d, &QDialog::reject);
                     QObject::connect(listWidget, &QListWidget::itemChanged,
                                      [&checkedItems, allowMultiSelection, listWidget](auto item) {
                                          if (item->checkState() == Qt::Checked) {
                                              if (!allowMultiSelection) {
                                                  for (auto checkedItem : checkedItems) {
                                                      listWidget->blockSignals(true);
                                                      checkedItem->setCheckState(Qt::Unchecked);
                                                      listWidget->blockSignals(false);
                                                  }
                                                  checkedItems.clear();
                                              }
                                              checkedItems << item;
                                          }
                                          else {
                                              checkedItems.remove(item);
                                          }
                                      });
                     QStringList result;
                     d.setMinimumWidth(120);
                     d.resize(d.minimumSizeHint());
                     d.move(location);
                     if (d.exec() == QDialog::Accepted) {
                         for (auto item : checkedItems) {
                             result += item->text();
                         }
                     }
                     else {
                         result = selectedZones;
                     }
                     return result;
                 }
                 void updateForTimeMode(QTreeView *treeView)
                 {
                     auto selectedRows = treeView->selectionModel()->selectedRows();
                     if (selectedRows.count() == 1) {
                         auto event = m_Model->getEvent(selectedRows.first());
                         if (event) {
                             if (m_VisualizationWidget) {
                                 if (auto tab = m_VisualizationWidget->currentTabWidget()) {
                                     for (auto zoneName : m_ZonesForTimeMode) {
                                         if (auto zone = tab->getZoneWithName(zoneName)) {
                                             SqpRange eventRange;
                                             eventRange.m_TStart = event->getTStart();
                                             eventRange.m_TEnd = event->getTEnd();
                                             zone->setZoneRange(eventRange);
                                         }
                                     }
                                 }
                                 else {
                                     qCWarning(LOG_CatalogueEventsWidget())
                                         << "updateTimeZone: no tab found in the visualization";
                                 }
                             }
                             else {
                                 qCWarning(LOG_CatalogueEventsWidget())
                                     << "updateTimeZone: visualization widget not found";
                             }
                         }
                     }
                     else {
                         qCWarning(LOG_CatalogueEventsWidget())
                             << "updateTimeZone: not compatible with multiple events selected";
                     }
                 }
                 QVector<SqpRange> getGraphRanges(const std::shared_ptr<DBEvent> &event)
                 {
                     // Retrieves the range of each product and the maximum size
                     QVector<SqpRange> graphRanges;
                     double maxDt = 0;
                     for (auto eventProduct : event->getEventProducts()) {
                         SqpRange eventRange;
                         eventRange.m_TStart = eventProduct.getTStart();
                         eventRange.m_TEnd = eventProduct.getTEnd();
                         graphRanges << eventRange;
                         auto dt = eventRange.m_TEnd - eventRange.m_TStart;
                         if (dt > maxDt) {
                             maxDt = dt;
                         }
                     }
                     // Adds the marge
                     maxDt *= (100.0 + EVENT_RANGE_MARGE) / 100.0;
                     // Corrects the graph ranges so that they all have the same size
                     QVector<SqpRange> correctedGraphRanges;
                     for (auto range : graphRanges) {
                         auto dt = range.m_TEnd - range.m_TStart;
                         auto diff = qAbs((maxDt - dt) / 2.0);
                         SqpRange correctedRange;
                         correctedRange.m_TStart = range.m_TStart - diff;
                         correctedRange.m_TEnd = range.m_TEnd + diff;
                         correctedGraphRanges << correctedRange;
                     }
                     return correctedGraphRanges;
                 }
                 void updateForGraphMode(CatalogueEventsWidget *catalogueEventWidget)
                 {
                     auto selectedRows = catalogueEventWidget->ui->treeView->selectionModel()->selectedRows();
                     if (selectedRows.count() != 1) {
                         qCWarning(LOG_CatalogueEventsWidget())
                             << "updateGraphMode: not compatible with multiple events selected";
                         return;
                     }
                     if (!m_VisualizationWidget) {
                         qCWarning(LOG_CatalogueEventsWidget())
                             << "updateGraphMode: visualization widget not found";
                         return;
                     }
                     auto event = m_Model->getEvent(selectedRows.first());
                     if (!event) {
                         // A event product is probably selected
                         qCInfo(LOG_CatalogueEventsWidget()) << "updateGraphMode: no events are selected";
                         return;
                     }
                     auto tab = m_VisualizationWidget->currentTabWidget();
                     if (!tab) {
                         qCWarning(LOG_CatalogueEventsWidget())
                             << "updateGraphMode: no tab found in the visualization";
                         return;
                     }
                     auto zone = tab->getZoneWithName(m_ZoneForGraphMode);
                     if (!zone) {
                         qCWarning(LOG_CatalogueEventsWidget()) << "updateGraphMode: zone not found";
                         return;
                     }
-                    // Close the previous graph and delete the asociated variables
+                    // Closes the previous graph and delete the asociated variables
                     for (auto graph : m_CustomGraphs) {
                         graph->close();
                         auto variables = graph->variables().toVector();
                         QMetaObject::invokeMethod(&sqpApp->variableController(), "deleteVariables",
                                                   Qt::QueuedConnection,
                                                   Q_ARG(QVector<std::shared_ptr<Variable> >, variables));
                     }
                     m_CustomGraphs.clear();
+                    // Closes the remaining graphs inside the zone
+                    zone->closeAllGraphs();
                     // Calculates the range of each graph which will be created
                     auto graphRange = getGraphRanges(event);
                     // Loops through the event products and create the graph
                     auto itRange = graphRange.cbegin();
                     for (auto eventProduct : event->getEventProducts()) {
                         auto productId = eventProduct.getProductId();
                         auto range = *itRange;
                         ++itRange;
                         SqpRange productRange;
                         productRange.m_TStart = eventProduct.getTStart();
                         productRange.m_TEnd = eventProduct.getTEnd();
                         auto context = new QObject{catalogueEventWidget};
                         QObject::connect(
                             &sqpApp->variableController(), &VariableController::variableAdded, context,
                             [this, catalogueEventWidget, zone, context, event, range, productRange,
                              productId](auto variable) {
                                 if (variable->metadata().value(DataSourceItem::ID_DATA_KEY).toString()
                                     == productId) {
                                     auto graph = zone->createGraph(variable);
                                     graph->setAutoRangeOnVariableInitialization(false);
                                     auto selectionZone
                                         = graph->addSelectionZone(event->getName(), productRange);
                                     emit catalogueEventWidget->selectionZoneAdded(event, productId,
                                                                                   selectionZone);
                                     m_CustomGraphs << graph;
                                     graph->setGraphRange(range, true);
                                     // Removes the graph from the graph list if it is closed manually
                                     QObject::connect(graph, &VisualizationGraphWidget::destroyed,
                                                      [this, graph]() { m_CustomGraphs.removeAll(graph); });
                                     delete context; // removes the connection
                                 }
                             },
                             Qt::QueuedConnection);
                         QMetaObject::invokeMethod(&sqpApp->dataSourceController(),
                                                   "requestVariableFromProductIdKey", Qt::QueuedConnection,
                                                   Q_ARG(QString, productId));
                     }
                 }
                 void getSelectedItems(
                     QTreeView *treeView, QVector<std::shared_ptr<DBEvent> > &events,
                     QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > &eventProducts)
                 {
                     for (auto rowIndex : treeView->selectionModel()->selectedRows()) {
                         auto itemType = m_Model->itemTypeOf(rowIndex);
                         if (itemType == CatalogueEventsModel::ItemType::Event) {
                             events << m_Model->getEvent(rowIndex);
                         }
                         else if (itemType == CatalogueEventsModel::ItemType::EventProduct) {
                             eventProducts << qMakePair(m_Model->getParentEvent(rowIndex),
                                                        m_Model->getEventProduct(rowIndex));
                         }
                     }
                 }
             };
             CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
                     : QWidget(parent),
                       ui(new Ui::CatalogueEventsWidget),
                       impl{spimpl::make_unique_impl<CatalogueEventsWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 impl->m_Model = new CatalogueEventsModel{this};
                 ui->treeView->setModel(impl->m_Model);
                 ui->treeView->setSortingEnabled(true);
                 ui->treeView->setDragDropMode(QAbstractItemView::DragDrop);
                 ui->treeView->setDragEnabled(true);
                 connect(ui->btnTime, &QToolButton::clicked, [this](auto checked) {
                     if (checked) {
                         ui->btnChart->setChecked(false);
                         impl->m_ZonesForTimeMode
                             = impl->selectZone(this, impl->m_ZonesForTimeMode, true,
                                                this->mapToGlobal(ui->btnTime->frameGeometry().center()));
                         impl->updateForTimeMode(ui->treeView);
                     }
                 });
                 connect(ui->btnChart, &QToolButton::clicked, [this](auto checked) {
                     if (checked) {
                         ui->btnTime->setChecked(false);
                         impl->m_ZoneForGraphMode
                             = impl->selectZone(this, {impl->m_ZoneForGraphMode}, false,
                                                this->mapToGlobal(ui->btnChart->frameGeometry().center()))
                                   .value(0);
                         impl->updateForGraphMode(this);
                     }
                 });
                 connect(ui->btnRemove, &QToolButton::clicked, [this]() {
                     QVector<std::shared_ptr<DBEvent> > events;
                     QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
                     impl->getSelectedItems(ui->treeView, events, eventProducts);
                     if (!events.isEmpty() && eventProducts.isEmpty()) {
                         if (QMessageBox::warning(this, tr("Remove Event(s)"),
                                                  tr("The selected event(s) will be permanently removed "
                                                     "from the repository!\nAre you sure you want to continue?"),
                                                  QMessageBox::Yes | QMessageBox::No, QMessageBox::No)
                             == QMessageBox::Yes) {
                             for (auto event : events) {
                                 sqpApp->catalogueController().removeEvent(event);
                                 impl->removeEvent(event, ui->treeView);
                             }
                             emit this->eventsRemoved(events);
                         }
                     }
                 });
                 connect(ui->treeView, &QTreeView::clicked, this, &CatalogueEventsWidget::emitSelection);
                 connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, this,
                         &CatalogueEventsWidget::emitSelection);
                 ui->btnRemove->setEnabled(false); // Disabled by default when nothing is selected
                 connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, [this]() {
                     auto isNotMultiSelection = ui->treeView->selectionModel()->selectedRows().count() <= 1;
                     ui->btnChart->setEnabled(isNotMultiSelection);
                     ui->btnTime->setEnabled(isNotMultiSelection);
                     if (isNotMultiSelection && ui->btnTime->isChecked()) {
                         impl->updateForTimeMode(ui->treeView);
                     }
                     else if (isNotMultiSelection && ui->btnChart->isChecked()) {
                         impl->updateForGraphMode(this);
                     }
                     QVector<std::shared_ptr<DBEvent> > events;
                     QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
                     impl->getSelectedItems(ui->treeView, events, eventProducts);
                     ui->btnRemove->setEnabled(!events.isEmpty() && eventProducts.isEmpty());
                 });
                 ui->treeView->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
                 ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Tags,
                                                              QHeaderView::Stretch);
                 ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Validation,
                                                              QHeaderView::Fixed);
                 ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Name,
                                                              QHeaderView::Interactive);
                 ui->treeView->header()->resizeSection((int)CatalogueEventsModel::Column::Validation,
                                                       VALIDATION_COLUMN_SIZE);
                 ui->treeView->header()->setSortIndicatorShown(true);
                 connect(impl->m_Model, &CatalogueEventsModel::modelSorted, [this]() {
                     auto allEvents = impl->m_Model->events();
                     for (auto event : allEvents) {
                         setEventChanges(event, sqpApp->catalogueController().eventHasChanges(event));
                     }
                 });
                 populateWithAllEvents();
             }
             CatalogueEventsWidget::~CatalogueEventsWidget()
             {
                 delete ui;
             }
             void CatalogueEventsWidget::setVisualizationWidget(VisualizationWidget *visualization)
             {
                 impl->m_VisualizationWidget = visualization;
             }
             void CatalogueEventsWidget::addEvent(const std::shared_ptr<DBEvent> &event)
             {
                 impl->addEvent(event, ui->treeView);
             }
             void CatalogueEventsWidget::setEventChanges(const std::shared_ptr<DBEvent> &event, bool hasChanges)
             {
                 impl->m_Model->refreshEvent(event);
                 auto eventIndex = impl->m_Model->indexOf(event);
                 auto validationIndex
                     = eventIndex.sibling(eventIndex.row(), (int)CatalogueEventsModel::Column::Validation);
                 if (validationIndex.isValid()) {
                     if (hasChanges) {
                         if (ui->treeView->indexWidget(validationIndex) == nullptr) {
                             auto widget = CatalogueExplorerHelper::buildValidationWidget(
                                 ui->treeView,
                                 [this, event]() {
                                     sqpApp->catalogueController().saveEvent(event);
                                     setEventChanges(event, false);
                                 },
                                 [this, event]() {
                                     bool removed = false;
                                     sqpApp->catalogueController().discardEvent(event, removed);
                                     if (removed) {
                                         impl->m_Model->removeEvent(event);
                                     }
                                     else {
                                         setEventChanges(event, false);
                                         impl->m_Model->refreshEvent(event, true);
                                     }
                                     emitSelection();
                                 });
                             ui->treeView->setIndexWidget(validationIndex, widget);
                         }
                     }
                     else {
                         // Note: the widget is destroyed
                         ui->treeView->setIndexWidget(validationIndex, nullptr);
                     }
                 }
                 else {
                     qCWarning(LOG_CatalogueEventsWidget())
                         << "setEventChanges: the event is not displayed in the model.";
                 }
             }
             QVector<std::shared_ptr<DBCatalogue> > CatalogueEventsWidget::displayedCatalogues() const
             {
                 return impl->m_DisplayedCatalogues;
             }
             bool CatalogueEventsWidget::isAllEventsDisplayed() const
             {
                 return impl->m_AllEventDisplayed;
             }
             bool CatalogueEventsWidget::isEventDisplayed(const std::shared_ptr<DBEvent> &event) const
             {
                 return impl->m_Model->indexOf(event).isValid();
             }
             void CatalogueEventsWidget::refreshEvent(const std::shared_ptr<DBEvent> &event)
             {
                 impl->m_Model->refreshEvent(event, true);
             }
             void CatalogueEventsWidget::populateWithCatalogues(
                 const QVector<std::shared_ptr<DBCatalogue> > &catalogues)
             {
                 impl->m_DisplayedCatalogues = catalogues;
                 impl->m_AllEventDisplayed = false;
                 QSet<QUuid> eventIds;
                 QVector<std::shared_ptr<DBEvent> > events;
                 for (auto catalogue : catalogues) {
                     auto catalogueEvents = sqpApp->catalogueController().retrieveEventsFromCatalogue(catalogue);
                     for (auto event : catalogueEvents) {
                         if (!eventIds.contains(event->getUniqId())) {
                             events << event;
                             eventIds.insert(event->getUniqId());
                         }
                     }
                 }
                 impl->setEvents(events, this);
             }
             void CatalogueEventsWidget::populateWithAllEvents()
             {
                 impl->m_DisplayedCatalogues.clear();
                 impl->m_AllEventDisplayed = true;
                 auto allEvents = sqpApp->catalogueController().retrieveAllEvents();
                 QVector<std::shared_ptr<DBEvent> > events;
                 for (auto event : allEvents) {
                     events << event;
                 }
                 impl->setEvents(events, this);
             }
             void CatalogueEventsWidget::clear()
             {
                 impl->m_DisplayedCatalogues.clear();
                 impl->m_AllEventDisplayed = false;
                 impl->setEvents({}, this);
             }
             void CatalogueEventsWidget::refresh()
             {
                 if (isAllEventsDisplayed()) {
                     populateWithAllEvents();
                 }
                 else if (!impl->m_DisplayedCatalogues.isEmpty()) {
                     populateWithCatalogues(impl->m_DisplayedCatalogues);
                 }
             }
             void CatalogueEventsWidget::emitSelection()
             {
                 QVector<std::shared_ptr<DBEvent> > events;
                 QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
                 impl->getSelectedItems(ui->treeView, events, eventProducts);
                 if (!events.isEmpty() && eventProducts.isEmpty()) {
                     emit eventsSelected(events);
                 }
                 else if (events.isEmpty() && !eventProducts.isEmpty()) {
                     emit eventProductsSelected(eventProducts);
                 }
                 else {
                     emit selectionCleared();
                 }
             }

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

             #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 <Common/MimeTypesDef.h>
             #include <ComparaisonPredicate.h>
             #include <DBCatalogue.h>
             #include <QMenu>
             #include <QMessageBox>
+            #include <QMimeData>
             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);
                 CatalogueAbstractTreeItem *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, CatalogueSideBarWidget *sideBarWidget);
                 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);
                 connect(ui->treeView, &QTreeView::clicked, this, &CatalogueSideBarWidget::emitSelection);
                 connect(ui->treeView->selectionModel(), &QItemSelectionModel::currentChanged, this,
                         &CatalogueSideBarWidget::emitSelection);
                 connect(ui->btnAdd, &QToolButton::clicked, [this]() {
                     auto catalogue = std::make_shared<DBCatalogue>();
                     catalogue->setName(QString("Cat"));
                     sqpApp->catalogueController().addCatalogue(catalogue);
                     auto item = this->addCatalogue(catalogue, REPOSITORY_DEFAULT);
                     this->setCatalogueChanges(catalogue, true);
                     ui->treeView->edit(impl->m_TreeModel->indexOf(item));
                 });
-                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;
                     auto selectedIndexes = ui->treeView->selectionModel()->selectedRows();
                     for (auto index : selectedIndexes) {
                         auto item = impl->m_TreeModel->item(index);
                         if (item && item->type() == CATALOGUE_ITEM_TYPE) {
                             auto catalogue = static_cast<CatalogueTreeItem *>(item)->catalogue();
                             cataloguesToItems << qMakePair(catalogue, item);
                         }
                     }
                     if (!cataloguesToItems.isEmpty()) {
                         if (QMessageBox::warning(this, tr("Remove Catalogue(s)"),
                                                  tr("The selected catalogues(s) will be completly removed "
                                                     "from the repository!\nAre you sure you want to continue?"),
                                                  QMessageBox::Yes | QMessageBox::No, QMessageBox::No)
                             == QMessageBox::Yes) {
                             for (auto catalogueToItem : cataloguesToItems) {
                                 sqpApp->catalogueController().removeCatalogue(catalogueToItem.first);
                                 impl->m_TreeModel->removeChildItem(
                                     catalogueToItem.second,
                                     impl->m_TreeModel->indexOf(catalogueToItem.second->parent()));
                             }
                         }
                     }
                 });
                 connect(impl->m_TreeModel, &CatalogueTreeModel::itemRenamed, [this](auto index) {
                     auto selectedIndexes = ui->treeView->selectionModel()->selectedRows();
                     if (selectedIndexes.contains(index)) {
                         this->emitSelection();
                     }
                     impl->setHasChanges(true, index, this);
                 });
                 ui->treeView->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->treeView, &QTreeView::customContextMenuRequested, this,
                         &CatalogueSideBarWidget::onContextMenuRequested);
             }
             CatalogueSideBarWidget::~CatalogueSideBarWidget()
             {
                 delete ui;
             }
             CatalogueAbstractTreeItem *
             CatalogueSideBarWidget::addCatalogue(const std::shared_ptr<DBCatalogue> &catalogue,
                                                  const QString &repository)
             {
                 auto repositoryItem = impl->getDatabaseItem(repository);
                 return impl->addCatalogueItem(catalogue, impl->m_TreeModel->indexOf(repositoryItem));
             }
             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, this);
                     // catalogueItem->refresh();
                 }
             }
             QVector<std::shared_ptr<DBCatalogue> >
             CatalogueSideBarWidget::getCatalogues(const QString &repository) const
             {
                 QVector<std::shared_ptr<DBCatalogue> > result;
                 auto repositoryItem = impl->getDatabaseItem(repository);
                 for (auto child : repositoryItem->children()) {
                     if (child->type() == CATALOGUE_ITEM_TYPE) {
                         auto catalogueItem = static_cast<CatalogueTreeItem *>(child);
                         result << catalogueItem->catalogue();
                     }
                     else {
                         qCWarning(LOG_CatalogueSideBarWidget()) << "getCatalogues: invalid structure";
                     }
                 }
                 return result;
             }
             void CatalogueSideBarWidget::emitSelection()
             {
                 auto selectionType = impl->selectionType(ui->treeView);
                 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;
                 }
             }
             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};
                 auto allEventIndex = m_TreeModel->addTopLevelItem(allEventsItem);
                 treeView->setCurrentIndex(allEventIndex);
                 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;
             }
             CatalogueAbstractTreeItem *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);
                 return catalogueItem;
             }
             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) {
+                                if (catalogueItem->catalogue()->getUniqId() == catalogue->getUniqId()) {
                                     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, CatalogueSideBarWidget *sideBarWidget)
             {
                 std::shared_ptr<DBCatalogue> catalogue = nullptr;
                 auto item = m_TreeModel->item(index);
                 if (item && item->type() == CATALOGUE_ITEM_TYPE) {
                     catalogue = static_cast<CatalogueTreeItem *>(item)->catalogue();
                 }
                 auto validationIndex = index.sibling(index.row(), (int)CatalogueTreeModel::Column::Validation);
                 if (value) {
                     if (!hasChanges(validationIndex, sideBarWidget->ui->treeView)) {
                         auto widget = CatalogueExplorerHelper::buildValidationWidget(
                             sideBarWidget->ui->treeView,
                             [this, validationIndex, sideBarWidget, catalogue]() {
                                 if (catalogue) {
                                     sqpApp->catalogueController().saveCatalogue(catalogue);
                                 }
                                 setHasChanges(false, validationIndex, sideBarWidget);
                             },
                             [this, validationIndex, sideBarWidget, catalogue, item]() {
                                 if (catalogue) {
                                     bool removed;
                                     sqpApp->catalogueController().discardCatalogue(catalogue, removed);
                                     if (removed) {
                                         m_TreeModel->removeChildItem(item,
                                                                      m_TreeModel->indexOf(item->parent()));
                                     }
                                     else {
                                         m_TreeModel->refresh(m_TreeModel->indexOf(item));
                                         setHasChanges(false, validationIndex, sideBarWidget);
                                     }
                                     sideBarWidget->emitSelection();
                                 }
                             });
                         sideBarWidget->ui->treeView->setIndexWidget(validationIndex, widget);
                     }
                 }
                 else {
                     // Note: the widget is destroyed
                     sideBarWidget->ui->treeView->setIndexWidget(validationIndex, nullptr);
                 }
             }
             bool CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::hasChanges(const QModelIndex &index,
                                                                                    QTreeView *treeView)
             {
                 auto validationIndex = index.sibling(index.row(), (int)CatalogueTreeModel::Column::Validation);
                 return treeView->indexWidget(validationIndex) != nullptr;
             }

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

             #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)
             {
+                // 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;
             }
             bool CatalogueTreeItem::dropMimeData(const QMimeData *data, Qt::DropAction action)
             {
                 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
             {
                 return impl->m_Catalogue;
             }

gui/src/Catalogue/CatalogueTreeModel.cpp +3 -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(parentIndex, parentIndex);
             }
             void CatalogueTreeModel::removeChildItem(CatalogueAbstractTreeItem *child,
                                                      const QModelIndex &parentIndex)
             {
                 auto parentItem = item(parentIndex);
                 int i = parentItem->children().indexOf(child);
                 beginRemoveRows(parentIndex, i, i);
                 parentItem->removeChild(child);
                 endRemoveRows();
                 emit dataChanged(parentIndex, parentIndex);
             }
             void CatalogueTreeModel::refresh(const QModelIndex &index)
             {
                 emit dataChanged(index, index);
             }
             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)
             {
                 bool result = false;
                 auto draggedIndex = parent;
                 auto draggedItem = item(draggedIndex);
                 if (draggedItem) {
                     result = draggedItem->dropMimeData(data, action);
                     if (result) {
-                        emit itemDropped(draggedIndex);
+                        emit itemDropped(draggedIndex, data, action);
                     }
                 }
                 return result;
             }
             Qt::DropActions CatalogueTreeModel::supportedDropActions() const
             {
                 return Qt::CopyAction | Qt::MoveAction;
             }
             QStringList CatalogueTreeModel::mimeTypes() const
             {
-                return {MIME_TYPE_EVENT_LIST};
+                return {MIME_TYPE_EVENT_LIST, MIME_TYPE_SOURCE_CATALOGUE_LIST};
             }

gui/src/Visualization/VisualizationZoneWidget.cpp +6 0

             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/QCustomPlotSynchronizer.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationWidget.h"
             #include "ui_VisualizationZoneWidget.h"
             #include "Common/MimeTypesDef.h"
             #include "Common/VisualizationDef.h"
             #include <Data/SqpRange.h>
             #include <DataSource/DataSourceController.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/operations/FindVariableOperation.h>
             #include <DragAndDrop/DragDropGuiController.h>
             #include <QUuid>
             #include <SqpApplication.h>
             #include <cmath>
             #include <QLayout>
             Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
             namespace {
             /**
              * Applies a function to all graphs of the zone represented by its layout
              * @param layout the layout that contains graphs
              * @param fun the function to apply to each graph
              */
             template <typename Fun>
             void processGraphs(QLayout &layout, Fun fun)
             {
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (auto item = layout.itemAt(i)) {
                         if (auto visualizationGraphWidget
                             = qobject_cast<VisualizationGraphWidget *>(item->widget())) {
                             fun(*visualizationGraphWidget);
                         }
                     }
                 }
             }
             /// Generates a default name for a new graph, according to the number of graphs already displayed in
             /// the zone
             QString defaultGraphName(QLayout &layout)
             {
                 QSet<QString> existingNames;
                 processGraphs(
                     layout, [&existingNames](auto &graphWidget) { existingNames.insert(graphWidget.name()); });
                 int zoneNum = 1;
                 QString name;
                 do {
                     name = QObject::tr("Graph ").append(QString::number(zoneNum));
                     ++zoneNum;
                 } while (existingNames.contains(name));
                 return name;
             }
             } // namespace
             struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
                 explicit VisualizationZoneWidgetPrivate()
                         : m_SynchronisationGroupId{QUuid::createUuid()},
                           m_Synchronizer{std::make_unique<QCustomPlotSynchronizer>()}
                 {
                 }
                 QUuid m_SynchronisationGroupId;
                 std::unique_ptr<IGraphSynchronizer> m_Synchronizer;
                 void dropGraph(int index, VisualizationZoneWidget *zoneWidget);
                 void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
                                    VisualizationZoneWidget *zoneWidget);
                 void dropProducts(const QVariantList &productsData, int index,
                                   VisualizationZoneWidget *zoneWidget);
             };
             VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
                     : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationZoneWidget},
                       impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 ui->zoneNameLabel->setText(name);
                 ui->dragDropContainer->setPlaceHolderType(DragDropGuiController::PlaceHolderType::Graph);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_GRAPH,
                                                    VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setMimeType(
                     MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
                 ui->dragDropContainer->setMimeType(
                     MIME_TYPE_PRODUCT_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_TIME_RANGE,
                                                    VisualizationDragDropContainer::DropBehavior::Merged);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_ZONE,
                                                    VisualizationDragDropContainer::DropBehavior::Forbidden);
                 ui->dragDropContainer->setMimeType(MIME_TYPE_SELECTION_ZONE,
                                                    VisualizationDragDropContainer::DropBehavior::Forbidden);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropGuiController().checkMimeDataForVisualization(mimeData,
                                                                                          ui->dragDropContainer);
                 });
                 auto acceptDragWidgetFun = [](auto dragWidget, auto mimeData) {
                     if (!mimeData) {
                         return false;
                     }
                     if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                         auto variables = sqpApp->variableController().variablesForMimeData(
                             mimeData->data(MIME_TYPE_VARIABLE_LIST));
                         if (variables.count() != 1) {
                             return false;
                         }
                         auto variable = variables.first();
                         if (auto graphWidget = dynamic_cast<const VisualizationGraphWidget *>(dragWidget)) {
                             return graphWidget->canDrop(*variable);
                         }
                     }
                     return true;
                 };
                 ui->dragDropContainer->setAcceptDragWidgetFunction(acceptDragWidgetFun);
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
                         &VisualizationZoneWidget::dropMimeData);
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredOnWidget, this,
                         &VisualizationZoneWidget::dropMimeDataOnGraph);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                 // Synchronisation id
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             VisualizationZoneWidget::~VisualizationZoneWidget()
             {
                 delete ui;
             }
             void VisualizationZoneWidget::setZoneRange(const SqpRange &range)
             {
                 if (auto graph = firstGraph()) {
                     graph->setGraphRange(range);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("setZoneRange:Cannot set the range of an empty zone.");
                 }
             }
             void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
             {
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->addDragWidget(graphWidget);
             }
             void VisualizationZoneWidget::insertGraph(int index, VisualizationGraphWidget *graphWidget)
             {
                 // Synchronize new graph with others in the zone
                 impl->m_Synchronizer->addGraph(*graphWidget);
                 ui->dragDropContainer->insertDragWidget(index, graphWidget);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
             {
                 return createGraph(variable, -1);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable,
                                                                            int index)
             {
                 auto graphWidget
                     = new VisualizationGraphWidget{defaultGraphName(*ui->dragDropContainer->layout()), this};
                 // Set graph properties
                 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
                 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
                 // Lambda to synchronize zone widget
                 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &graphRange,
                                                                  const SqpRange &oldGraphRange) {
                     auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
                     auto frameLayout = ui->dragDropContainer->layout();
                     for (auto i = 0; i < frameLayout->count(); ++i) {
                         auto graphChild
                             = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
                         if (graphChild && (graphChild != graphWidget)) {
                             auto graphChildRange = graphChild->graphRange();
                             switch (zoomType) {
                                 case AcquisitionZoomType::ZoomIn: {
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                            << deltaLeft;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                            << deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::ZoomOut: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                            << deltaLeft;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                            << deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanRight: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanLeft: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     break;
                                 }
                                 case AcquisitionZoomType::Unknown: {
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type unknown");
                                     break;
                                 }
                                 default:
                                     qCCritical(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type not take into account");
                                     // No action
                                     break;
                             }
                             graphChild->setFlags(GraphFlag::DisableAll);
                             qCDebug(LOG_VisualizationZoneWidget())
                                 << tr("TORM: Range before: ") << graphChild->graphRange();
                             qCDebug(LOG_VisualizationZoneWidget())
                                 << tr("TORM: Range after : ") << graphChildRange;
                             qCDebug(LOG_VisualizationZoneWidget())
                                 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                             graphChild->setGraphRange(graphChildRange);
                             graphChild->setFlags(GraphFlag::EnableAll);
                         }
                     }
                 };
                 // connection for synchronization
                 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
                 connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
                         &VisualizationZoneWidget::onVariableAdded);
                 connect(graphWidget, &VisualizationGraphWidget::variableAboutToBeRemoved, this,
                         &VisualizationZoneWidget::onVariableAboutToBeRemoved);
                 auto range = SqpRange{};
                 if (auto firstGraph = this->firstGraph()) {
                     // Case of a new graph in a existant zone
                     range = firstGraph->graphRange();
                 }
                 else {
                     // Case of a new graph as the first of the zone
                     range = variable->range();
                 }
                 this->insertGraph(index, graphWidget);
                 graphWidget->addVariable(variable, range);
                 graphWidget->setYRange(variable);
                 return graphWidget;
             }
             VisualizationGraphWidget *
             VisualizationZoneWidget::createGraph(const QList<std::shared_ptr<Variable> > variables, int index)
             {
                 if (variables.isEmpty()) {
                     return nullptr;
                 }
                 auto graphWidget = createGraph(variables.first(), index);
                 for (auto variableIt = variables.cbegin() + 1; variableIt != variables.cend(); ++variableIt) {
                     graphWidget->addVariable(*variableIt, graphWidget->graphRange());
                 }
                 return graphWidget;
             }
             VisualizationGraphWidget *VisualizationZoneWidget::firstGraph() const
             {
                 VisualizationGraphWidget *firstGraph = nullptr;
                 auto layout = ui->dragDropContainer->layout();
                 if (layout->count() > 0) {
                     if (auto visualizationGraphWidget
                         = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                         firstGraph = visualizationGraphWidget;
                     }
                 }
                 return firstGraph;
             }
+            void VisualizationZoneWidget::closeAllGraphs()
+            {
+                processGraphs(*ui->dragDropContainer->layout(),
+                              [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
+            }
             void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to graph children: widgets different from graphs are not visited (no
                     // action)
                     processGraphs(
                         *ui->dragDropContainer->layout(),
                         [visitor](VisualizationGraphWidget &graphWidget) { graphWidget.accept(visitor); });
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationZoneWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationZoneWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationZoneWidget::name() const
             {
                 return ui->zoneNameLabel->text();
             }
             QMimeData *VisualizationZoneWidget::mimeData(const QPoint &position) const
             {
                 Q_UNUSED(position);
                 auto mimeData = new QMimeData;
                 mimeData->setData(MIME_TYPE_ZONE, QByteArray{});
                 if (auto firstGraph = this->firstGraph()) {
                     auto timeRangeData = TimeController::mimeDataForTimeRange(firstGraph->graphRange());
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
                 }
                 return mimeData;
             }
             bool VisualizationZoneWidget::isDragAllowed() const
             {
                 return true;
             }
             void VisualizationZoneWidget::notifyMouseMoveInGraph(const QPointF &graphPosition,
                                                                  const QPointF &plotPosition,
                                                                  VisualizationGraphWidget *graphWidget)
             {
                 processGraphs(*ui->dragDropContainer->layout(), [&graphPosition, &plotPosition, &graphWidget](
                                                                     VisualizationGraphWidget &processedGraph) {
                     switch (sqpApp->plotsCursorMode()) {
                         case SqpApplication::PlotsCursorMode::Vertical:
                             processedGraph.removeHorizontalCursor();
                             processedGraph.addVerticalCursorAtViewportPosition(graphPosition.x());
                             break;
                         case SqpApplication::PlotsCursorMode::Temporal:
                             processedGraph.addVerticalCursor(plotPosition.x());
                             processedGraph.removeHorizontalCursor();
                             break;
                         case SqpApplication::PlotsCursorMode::Horizontal:
                             processedGraph.removeVerticalCursor();
                             if (&processedGraph == graphWidget) {
                                 processedGraph.addHorizontalCursorAtViewportPosition(graphPosition.y());
                             }
                             else {
                                 processedGraph.removeHorizontalCursor();
                             }
                             break;
                         case SqpApplication::PlotsCursorMode::Cross:
                             if (&processedGraph == graphWidget) {
                                 processedGraph.addVerticalCursorAtViewportPosition(graphPosition.x());
                                 processedGraph.addHorizontalCursorAtViewportPosition(graphPosition.y());
                             }
                             else {
                                 processedGraph.removeHorizontalCursor();
                                 processedGraph.removeVerticalCursor();
                             }
                             break;
                         case SqpApplication::PlotsCursorMode::NoCursor:
                             processedGraph.removeHorizontalCursor();
                             processedGraph.removeVerticalCursor();
                             break;
                     }
                 });
             }
             void VisualizationZoneWidget::notifyMouseLeaveGraph(VisualizationGraphWidget *graphWidget)
             {
                 processGraphs(*ui->dragDropContainer->layout(), [](VisualizationGraphWidget &processedGraph) {
                     processedGraph.removeHorizontalCursor();
                     processedGraph.removeVerticalCursor();
                 });
             }
             void VisualizationZoneWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes graphs in the zone
                 processGraphs(*ui->dragDropContainer->layout(),
                               [](VisualizationGraphWidget &graphWidget) { graphWidget.close(); });
                 // Delete synchronization group from variable controller
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onRemoveSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
                 QWidget::closeEvent(event);
             }
             void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
                                           Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::onVariableAboutToBeRemoved(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "desynchronize", Qt::QueuedConnection,
                                           Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             void VisualizationZoneWidget::dropMimeData(int index, const QMimeData *mimeData)
             {
                 if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
                     impl->dropGraph(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     impl->dropVariables(variables, index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
                     auto products = sqpApp->dataSourceController().productsDataForMimeData(
                         mimeData->data(MIME_TYPE_PRODUCT_LIST));
                     impl->dropProducts(products, index, this);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeData, unknown MIME data received.");
                 }
             }
             void VisualizationZoneWidget::dropMimeDataOnGraph(VisualizationDragWidget *dragWidget,
                                                               const QMimeData *mimeData)
             {
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(dragWidget);
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeDataOnGraph, dropping in an unknown widget, "
                               "drop aborted");
                     Q_ASSERT(false);
                     return;
                 }
                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     for (const auto &var : variables) {
                         graphWidget->addVariable(var, graphWidget->graphRange());
                     }
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
                     auto products = sqpApp->dataSourceController().productsDataForMimeData(
                         mimeData->data(MIME_TYPE_PRODUCT_LIST));
                     auto context = new QObject{this};
                     connect(&sqpApp->variableController(), &VariableController::variableAdded, context,
                             [this, graphWidget, context](auto variable) {
                                 graphWidget->addVariable(variable, graphWidget->graphRange());
                                 delete context; // removes the connection
                             },
                             Qt::QueuedConnection);
                     auto productData = products.first().toHash();
                     QMetaObject::invokeMethod(&sqpApp->dataSourceController(), "requestVariable",
                                               Qt::QueuedConnection, Q_ARG(QVariantHash, productData));
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_TIME_RANGE)) {
                     auto range = TimeController::timeRangeForMimeData(mimeData->data(MIME_TYPE_TIME_RANGE));
                     graphWidget->setGraphRange(range);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropMimeDataOnGraph, unknown MIME data received.");
                 }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropGraph(
                 int index, VisualizationZoneWidget *zoneWidget)
             {
                 auto &helper = sqpApp->dragDropGuiController();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the dropped graph is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropGraph, drop aborted, the parent container of "
                               "the dropped graph is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 const auto &variables = graphWidget->variables();
                 if (parentDragDropContainer != zoneWidget->ui->dragDropContainer && !variables.isEmpty()) {
                     // The drop didn't occur in the same zone
                     // Abort the requests for the variables (if any)
                     // Commented, because it's not sure if it's needed or not
                     // for (const auto& var : variables)
                     //{
                     //    sqpApp->variableController().onAbortProgressRequested(var);
                     //}
                     auto previousParentZoneWidget = graphWidget->parentZoneWidget();
                     auto nbGraph = parentDragDropContainer->countDragWidget();
                     if (nbGraph == 1) {
                         // This is the only graph in the previous zone, close the zone
                         helper.delayedCloseWidget(previousParentZoneWidget);
                     }
                     else {
                         // Close the graph
                         helper.delayedCloseWidget(graphWidget);
                     }
                     // Creates the new graph in the zone
                     auto newGraphWidget = zoneWidget->createGraph(variables, index);
                     newGraphWidget->addSelectionZones(graphWidget->selectionZoneRanges());
                 }
                 else {
                     // The drop occurred in the same zone or the graph is empty
                     // Simple move of the graph, no variable operation associated
                     parentDragDropContainer->layout()->removeWidget(graphWidget);
                     if (variables.isEmpty() && parentDragDropContainer != zoneWidget->ui->dragDropContainer) {
                         // The graph is empty and dropped in a different zone.
                         // Take the range of the first graph in the zone (if existing).
                         auto layout = zoneWidget->ui->dragDropContainer->layout();
                         if (layout->count() > 0) {
                             if (auto visualizationGraphWidget
                                 = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                                 graphWidget->setGraphRange(visualizationGraphWidget->graphRange());
                             }
                         }
                     }
                     zoneWidget->ui->dragDropContainer->insertDragWidget(index, graphWidget);
                 }
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropVariables(
                 const QList<std::shared_ptr<Variable> > &variables, int index,
                 VisualizationZoneWidget *zoneWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
                 if (variables.count() > 1) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationZoneWidget::dropVariables, dropping multiple variables, operation "
                               "aborted.");
                     return;
                 }
                 zoneWidget->createGraph(variables, index);
             }
             void VisualizationZoneWidget::VisualizationZoneWidgetPrivate::dropProducts(
                 const QVariantList &productsData, int index, VisualizationZoneWidget *zoneWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
                 if (productsData.count() != 1) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropProducts, dropping multiple products, operation "
                               "aborted.");
                     return;
                 }
                 auto context = new QObject{zoneWidget};
                 connect(&sqpApp->variableController(), &VariableController::variableAdded, context,
                         [this, index, zoneWidget, context](auto variable) {
                             zoneWidget->createGraph(variable, index);
                             delete context; // removes the connection
                         },
                         Qt::QueuedConnection);
                 auto productData = productsData.first().toHash();
                 QMetaObject::invokeMethod(&sqpApp->dataSourceController(), "requestVariable",
                                           Qt::QueuedConnection, Q_ARG(QVariantHash, productData));
             }

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