From 3d2098c906924befde4087aee05f095102292eea 2017-12-15 16:37:29
From: perrinel <mperrinel@itlink.fr>
Date: 2017-12-15 16:37:29
Subject: [PATCH] Merge pull request #390 from SciQLop-fork develop

 Develop

---

diff --git a/.gitignore b/.gitignore
index 062b58d..2e25f0f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,5 @@ CMakeLists.txt.user
 core/src/Version.cpp
 core/include/Version.h
 3rdparty/
+subprojects/CatalogueAPI/
+subprojects/QxOrm/
diff --git a/app/src/Main.cpp b/app/src/Main.cpp
index 30db0fe..9246498 100644
--- a/app/src/Main.cpp
+++ b/app/src/Main.cpp
@@ -25,6 +25,7 @@
 #include <SqpApplication.h>
 #include <qglobal.h>
 
+#include <QtPlugin>
 #include <Plugin/PluginManager.h>
 #include <QDir>
 
@@ -41,6 +42,13 @@ const auto PLUGIN_DIRECTORY_NAME = QStringLiteral("plugins");
 
 int main(int argc, char *argv[])
 {
+#ifdef QT_STATICPLUGIN
+    Q_IMPORT_PLUGIN(MockPlugin)
+    Q_IMPORT_PLUGIN(AmdaPlugin)
+    Q_INIT_RESOURCE(amdaresources);
+#endif
+    Q_INIT_RESOURCE(sqpguiresources);
+
     SqpApplication a{argc, argv};
     SqpApplication::setOrganizationName("LPP");
     SqpApplication::setOrganizationDomain("lpp.fr");
@@ -75,6 +83,7 @@ int main(int argc, char *argv[])
             pluginManager.loadPlugins(directory);
         }
     }
+    pluginManager.loadStaticPlugins();
 
     return a.exec();
 }
diff --git a/app/src/MainWindow.cpp b/app/src/MainWindow.cpp
index c96666f..eda17cd 100644
--- a/app/src/MainWindow.cpp
+++ b/app/src/MainWindow.cpp
@@ -86,6 +86,8 @@ MainWindow::MainWindow(QWidget *parent)
     m_Ui->splitter->setCollapsible(LEFTINSPECTORSIDEPANESPLITTERINDEX, false);
     m_Ui->splitter->setCollapsible(RIGHTINSPECTORSIDEPANESPLITTERINDEX, false);
 
+    impl->m_CatalogExplorer->setVisualizationWidget(m_Ui->view);
+
 
     auto leftSidePane = m_Ui->leftInspectorSidePane->sidePane();
     auto openLeftInspectorAction = new QAction{QIcon{
diff --git a/core/include/Catalogue/CatalogueController.h b/core/include/Catalogue/CatalogueController.h
index 8878f81..9d839af 100644
--- a/core/include/Catalogue/CatalogueController.h
+++ b/core/include/Catalogue/CatalogueController.h
@@ -11,17 +11,19 @@
 
 #include <Common/spimpl.h>
 
+#include <memory>
+
+class DBCatalogue;
+class DBEvent;
+
 Q_DECLARE_LOGGING_CATEGORY(LOG_CatalogueController)
 
 class DataSourceItem;
 class Variable;
 
 /**
- * @brief The CatalogueController class aims to make the link between SciQlop and its plugins.
- * This is the intermediate class that SciQlop has to use in the way to connect a data source.
- * Please first use register method to initialize a plugin specified by its metadata name (JSON
- * plugin source) then others specifics method will be able to access it. You can load a data source
- * driver plugin then create a data source.
+ * @brief The CatalogueController class aims to handle catalogues and event using the CatalogueAPI
+ * library.
  */
 class SCIQLOP_CORE_EXPORT CatalogueController : public QObject {
     Q_OBJECT
@@ -29,12 +31,28 @@ public:
     explicit CatalogueController(QObject *parent = 0);
     virtual ~CatalogueController();
 
-signals:
-    /// Signal emitted when a variable is about to be deleted from SciQlop
-    void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
+    // DB
+    //    QStringList getRepositories() const;
+    void addDB(const QString &dbPath);
+    void saveDB(const QString &destinationPath, const QString &repository);
+
+    // Event
+    //    bool createEvent(const QString &name);
+    std::list<std::shared_ptr<DBEvent> > retrieveEvents(const QString &repository) const;
+    std::list<std::shared_ptr<DBEvent> > retrieveAllEvents() const;
+    std::list<std::shared_ptr<DBEvent> >
+    retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const;
+    //    void updateEvent(std::shared_ptr<DBEvent> event);
+    //    void trashEvent(std::shared_ptr<DBEvent> event);
+    //    void removeEvent(std::shared_ptr<DBEvent> event);
+    //    void restore(QUuid eventId);
+    //    void saveEvent(std::shared_ptr<DBEvent> event);
 
-    /// Signal emitted when a data acquisition is requested on a range for a variable
-    void rangeChanged(std::shared_ptr<Variable> variable, const SqpRange &range);
+    // Catalogue
+    //    bool createCatalogue(const QString &name, QVector<QUuid> eventList);
+    std::list<std::shared_ptr<DBCatalogue> > getCatalogues(const QString &repository) const;
+    //    void removeEvent(QUuid catalogueId, const QString &repository);
+    //    void saveCatalogue(std::shared_ptr<DBEvent> event);
 
 public slots:
     /// Manage init/end of the controller
diff --git a/core/include/Common/MimeTypesDef.h b/core/include/Common/MimeTypesDef.h
index 27535fa..cb8113a 100644
--- a/core/include/Common/MimeTypesDef.h
+++ b/core/include/Common/MimeTypesDef.h
@@ -15,6 +15,7 @@ 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;
 
 
 #endif // SCIQLOP_MIMETYPESDEF_H
diff --git a/core/include/Plugin/PluginManager.h b/core/include/Plugin/PluginManager.h
index dd76163..025e42b 100644
--- a/core/include/Plugin/PluginManager.h
+++ b/core/include/Plugin/PluginManager.h
@@ -25,11 +25,16 @@ public:
      */
     void loadPlugins(const QDir &pluginDir);
 
+    /**
+     * Loads static plugins into SciQlop. SciQLOP supports statically linked plugins.
+     */
+    void loadStaticPlugins();
+
     /// @returns the number of plugins loaded
     int nbPluginsLoaded() const noexcept;
 
 private:
-    class PluginManagerPrivate;
+    struct PluginManagerPrivate;
     spimpl::unique_impl_ptr<PluginManagerPrivate> impl;
 };
 
diff --git a/core/src/Catalogue/CatalogueController.cpp b/core/src/Catalogue/CatalogueController.cpp
index 4932adf..9e2ad7c 100644
--- a/core/src/Catalogue/CatalogueController.cpp
+++ b/core/src/Catalogue/CatalogueController.cpp
@@ -4,6 +4,13 @@
 
 #include <CatalogueDao.h>
 
+#include <ComparaisonPredicate.h>
+#include <CompoundPredicate.h>
+#include <DBCatalogue.h>
+#include <DBEvent.h>
+#include <DBTag.h>
+#include <IRequestPredicate.h>
+
 #include <QMutex>
 #include <QThread>
 
@@ -12,10 +19,18 @@
 
 Q_LOGGING_CATEGORY(LOG_CatalogueController, "CatalogueController")
 
+namespace {
+
+static QString REPOSITORY_WORK_SUFFIX = QString{"Work"};
+
+}
+
 class CatalogueController::CatalogueControllerPrivate {
 public:
     QMutex m_WorkingMutex;
     CatalogueDao m_CatalogueDao;
+
+    std::list<QString> m_RepositoryList;
 };
 
 CatalogueController::CatalogueController(QObject *parent)
@@ -32,12 +47,106 @@ CatalogueController::~CatalogueController()
     this->waitForFinish();
 }
 
+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.push_back(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
+{
+    auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
+    auto events = impl->m_CatalogueDao.getEvents(repository);
+    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;
+}
+
+std::list<std::shared_ptr<DBCatalogue> >
+CatalogueController::getCatalogues(const QString &repository) const
+{
+    auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};
+    auto catalogues = impl->m_CatalogueDao.getCatalogues(repository);
+    for (auto catalogue : catalogues) {
+        cataloguesShared.push_back(std::make_shared<DBCatalogue>(catalogue));
+    }
+    return cataloguesShared;
+}
+
 void CatalogueController::initialize()
 {
     qCDebug(LOG_CatalogueController()) << tr("CatalogueController init")
                                        << QThread::currentThread();
     impl->m_WorkingMutex.lock();
     impl->m_CatalogueDao.initialize();
+    auto defaultRepositoryLocation
+        = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
+
+    QDir defaultRepositoryLocationDir;
+    if (defaultRepositoryLocationDir.mkpath(defaultRepositoryLocation)) {
+        defaultRepositoryLocationDir.cd(defaultRepositoryLocation);
+        auto defaultRepository = defaultRepositoryLocationDir.absoluteFilePath(REPOSITORY_DEFAULT);
+        qCInfo(LOG_CatalogueController())
+            << tr("Persistant data loading from: ") << defaultRepository;
+        this->addDB(defaultRepository);
+    }
+    else {
+        qCWarning(LOG_CatalogueController())
+            << tr("Cannot load the persistent default repository from ")
+            << defaultRepositoryLocation;
+    }
+
     qCDebug(LOG_CatalogueController()) << tr("CatalogueController init END");
 }
 
diff --git a/core/src/Common/MimeTypesDef.cpp b/core/src/Common/MimeTypesDef.cpp
index c057895..85a5347 100644
--- a/core/src/Common/MimeTypesDef.cpp
+++ b/core/src/Common/MimeTypesDef.cpp
@@ -6,3 +6,4 @@ 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");
diff --git a/core/src/Plugin/PluginManager.cpp b/core/src/Plugin/PluginManager.cpp
index c1fa918..2f07645 100644
--- a/core/src/Plugin/PluginManager.cpp
+++ b/core/src/Plugin/PluginManager.cpp
@@ -95,6 +95,15 @@ struct PluginManager::PluginManagerPrivate {
         loadState.log();
     }
 
+    void loadStaticPlugins()
+    {
+        for (QObject *plugin : QPluginLoader::staticInstances())
+        {
+            qobject_cast<IPlugin *>(plugin)->initialize();
+            m_RegisteredPlugins.insert(plugin->metaObject()->className(), "StaticPlugin");
+        }
+    }
+
     /// Registered plugins (key: plugin name, value: plugin path)
     QHash<QString, QString> m_RegisteredPlugins;
 };
@@ -118,6 +127,11 @@ void PluginManager::loadPlugins(const QDir &pluginDir)
     }
 }
 
+void PluginManager::loadStaticPlugins()
+{
+    impl->loadStaticPlugins();
+}
+
 int PluginManager::nbPluginsLoaded() const noexcept
 {
     return impl->m_RegisteredPlugins.size();
diff --git a/core/src/Variable/VariableController.cpp b/core/src/Variable/VariableController.cpp
index b5a2eef..e76989b 100644
--- a/core/src/Variable/VariableController.cpp
+++ b/core/src/Variable/VariableController.cpp
@@ -669,7 +669,7 @@ AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const
         qCDebug(LOG_VariableController()) << "zoomtype: PanLeft";
         zoomType = AcquisitionZoomType::PanLeft;
     }
-    else if (range.m_TStart > oldRange.m_TStart && oldRange.m_TEnd > range.m_TEnd) {
+    else if (range.m_TStart >= oldRange.m_TStart && oldRange.m_TEnd >= range.m_TEnd) {
         qCDebug(LOG_VariableController()) << "zoomtype: ZoomIn";
         zoomType = AcquisitionZoomType::ZoomIn;
     }
diff --git a/extern/CatalogueAPI.cmake b/extern/CatalogueAPI.cmake
index 7bacfa1..c18078c 100644
--- a/extern/CatalogueAPI.cmake
+++ b/extern/CatalogueAPI.cmake
@@ -40,7 +40,7 @@ ExternalProject_Add(
     GIT_REPOSITORY https://perrinel@hephaistos.lpp.polytechnique.fr/rhodecode/GIT_REPOSITORIES/LPP/Users/mperrinel/CatalogueAPI
     GIT_TAG develop
 
-    UPDATE_COMMAND ${GIT_EXECUTABLE} pull
+    UPDATE_COMMAND ${GIT_EXECUTABLE} pull origin develop
     PATCH_COMMAND ""
 
     SOURCE_DIR "${CATALOGUEAPI_SOURCES_PATH}"
diff --git a/gui/CMakeLists.txt b/gui/CMakeLists.txt
index dab081d..119546f 100644
--- a/gui/CMakeLists.txt
+++ b/gui/CMakeLists.txt
@@ -75,6 +75,16 @@ INSTALL(TARGETS ${SQPGUI_LIBRARY_NAME}
 )
 add_dependencies(${SQPGUI_LIBRARY_NAME} ${SQPCORE_LIBRARY_NAME})
 
+# Find CATALOGUE_API
+include_directories("${CATALOGUEAPI_INCLUDE}")
+TARGET_LINK_LIBRARIES(${SQPGUI_LIBRARY_NAME} ${CATALOGUEAPI_LIBRARIES})
+INSTALL(TARGETS ${SQPGUI_LIBRARY_NAME}
+  RUNTIME DESTINATION ${INSTALL_BINARY_DIR}
+  LIBRARY DESTINATION ${INSTALL_LIBRARY_DIR}
+  ARCHIVE DESTINATION ${INSTALL_LIBRARY_DIR}
+)
+
+add_dependencies(${SQPGUI_LIBRARY_NAME} CatalogueAPI)
 
 # From cmake documentation: http://www.cmake.org/cmake/help/v3.0/manual/cmake-buildsystem.7.html
 # Entries in the COMPILE_DEFINITIONS are prefixed with -D or /D and added to the compile line in an unspecified order.
diff --git a/gui/include/Catalogue/CatalogueEventsModel.h b/gui/include/Catalogue/CatalogueEventsModel.h
new file mode 100644
index 0000000..bc0bd70
--- /dev/null
+++ b/gui/include/Catalogue/CatalogueEventsModel.h
@@ -0,0 +1,46 @@
+#ifndef SCIQLOP_CATALOGUEEVENTSMODEL_H
+#define SCIQLOP_CATALOGUEEVENTSMODEL_H
+
+#include <Common/spimpl.h>
+#include <QAbstractItemModel>
+
+class DBEvent;
+class DBEventProduct;
+
+class CatalogueEventsModel : public QAbstractItemModel {
+public:
+    CatalogueEventsModel(QObject *parent = nullptr);
+
+    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);
+
+    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;
+
+    void refreshEvent(const std::shared_ptr<DBEvent> &event);
+
+    // 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
diff --git a/gui/include/Catalogue/CatalogueEventsWidget.h b/gui/include/Catalogue/CatalogueEventsWidget.h
index deae927..e7ce270 100644
--- a/gui/include/Catalogue/CatalogueEventsWidget.h
+++ b/gui/include/Catalogue/CatalogueEventsWidget.h
@@ -2,24 +2,40 @@
 #define SCIQLOP_CATALOGUEEVENTSWIDGET_H
 
 #include <Common/spimpl.h>
+#include <QLoggingCategory>
 #include <QWidget>
 
+class DBCatalogue;
+class DBEvent;
+class DBEventProduct;
+class VisualizationWidget;
+
 namespace Ui {
 class CatalogueEventsWidget;
 }
 
+Q_DECLARE_LOGGING_CATEGORY(LOG_CatalogueEventsWidget)
+
 class CatalogueEventsWidget : public QWidget {
     Q_OBJECT
 
 signals:
-    void eventSelected(const QString &event);
+    void eventsSelected(const QVector<std::shared_ptr<DBEvent> > &event);
+    void eventProductsSelected(
+        const QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > >
+            &eventproducts);
+    void selectionCleared();
 
 public:
     explicit CatalogueEventsWidget(QWidget *parent = 0);
     virtual ~CatalogueEventsWidget();
 
+    void setVisualizationWidget(VisualizationWidget *visualization);
+
+    void setEventChanges(const std::shared_ptr<DBEvent> &event, bool hasChanges);
+
 public slots:
-    void populateWithCatalogue(const QString &catalogue);
+    void populateWithCatalogues(const QVector<std::shared_ptr<DBCatalogue> > &catalogues);
 
 private:
     Ui::CatalogueEventsWidget *ui;
diff --git a/gui/include/Catalogue/CatalogueExplorer.h b/gui/include/Catalogue/CatalogueExplorer.h
index 0e433f2..9baa58f 100644
--- a/gui/include/Catalogue/CatalogueExplorer.h
+++ b/gui/include/Catalogue/CatalogueExplorer.h
@@ -1,12 +1,15 @@
 #ifndef SCIQLOP_CATALOGUEEXPLORER_H
 #define SCIQLOP_CATALOGUEEXPLORER_H
 
+#include <Common/spimpl.h>
 #include <QDialog>
 
 namespace Ui {
 class CatalogueExplorer;
 }
 
+class VisualizationWidget;
+
 class CatalogueExplorer : public QDialog {
     Q_OBJECT
 
@@ -14,8 +17,13 @@ public:
     explicit CatalogueExplorer(QWidget *parent = 0);
     virtual ~CatalogueExplorer();
 
+    void setVisualizationWidget(VisualizationWidget *visualization);
+
 private:
     Ui::CatalogueExplorer *ui;
+
+    class CatalogueExplorerPrivate;
+    spimpl::unique_impl_ptr<CatalogueExplorerPrivate> impl;
 };
 
 #endif // SCIQLOP_CATALOGUEEXPLORER_H
diff --git a/gui/include/Catalogue/CatalogueInspectorWidget.h b/gui/include/Catalogue/CatalogueInspectorWidget.h
index b78fd55..51c42b9 100644
--- a/gui/include/Catalogue/CatalogueInspectorWidget.h
+++ b/gui/include/Catalogue/CatalogueInspectorWidget.h
@@ -1,15 +1,27 @@
 #ifndef SCIQLOP_CATALOGUEINSPECTORWIDGET_H
 #define SCIQLOP_CATALOGUEINSPECTORWIDGET_H
 
+#include <Common/spimpl.h>
 #include <QWidget>
+#include <memory>
 
 namespace Ui {
 class CatalogueInspectorWidget;
 }
 
+class DBCatalogue;
+class DBEvent;
+class DBEventProduct;
+
 class CatalogueInspectorWidget : public QWidget {
     Q_OBJECT
 
+signals:
+    void catalogueUpdated(const std::shared_ptr<DBCatalogue> &catalogue);
+    void eventUpdated(const std::shared_ptr<DBEvent> &event);
+    void eventProductUpdated(const std::shared_ptr<DBEvent> &event,
+                             const std::shared_ptr<DBEventProduct> &eventProduct);
+
 public:
     explicit CatalogueInspectorWidget(QWidget *parent = 0);
     virtual ~CatalogueInspectorWidget();
@@ -19,14 +31,19 @@ public:
 
     Page currentPage() const;
 
-    void setEvent(const QString &event);
-    void setCatalogue(const QString &catalogue);
+    void setEvent(const std::shared_ptr<DBEvent> &event);
+    void setEventProduct(const std::shared_ptr<DBEvent> &event,
+                         const std::shared_ptr<DBEventProduct> &eventProduct);
+    void setCatalogue(const std::shared_ptr<DBCatalogue> &catalogue);
 
 public slots:
     void showPage(Page page);
 
 private:
     Ui::CatalogueInspectorWidget *ui;
+
+    class CatalogueInspectorWidgetPrivate;
+    spimpl::unique_impl_ptr<CatalogueInspectorWidgetPrivate> impl;
 };
 
 #endif // SCIQLOP_CATALOGUEINSPECTORWIDGET_H
diff --git a/gui/include/Catalogue/CatalogueSideBarWidget.h b/gui/include/Catalogue/CatalogueSideBarWidget.h
index b9855dd..0af2b26 100644
--- a/gui/include/Catalogue/CatalogueSideBarWidget.h
+++ b/gui/include/Catalogue/CatalogueSideBarWidget.h
@@ -2,30 +2,42 @@
 #define SCIQLOP_CATALOGUESIDEBARWIDGET_H
 
 #include <Common/spimpl.h>
+#include <QLoggingCategory>
 #include <QTreeWidgetItem>
 #include <QWidget>
 
+class DBCatalogue;
+
 namespace Ui {
 class CatalogueSideBarWidget;
 }
 
+Q_DECLARE_LOGGING_CATEGORY(LOG_CatalogueSideBarWidget)
+
 class CatalogueSideBarWidget : public QWidget {
     Q_OBJECT
 
 signals:
-    void catalogueSelected(const QString &catalogue);
+    void catalogueSelected(const QVector<std::shared_ptr<DBCatalogue> > &catalogues);
+    void databaseSelected(const QStringList &databases);
     void allEventsSelected();
     void trashSelected();
+    void selectionCleared();
 
 public:
     explicit CatalogueSideBarWidget(QWidget *parent = 0);
     virtual ~CatalogueSideBarWidget();
 
+    void setCatalogueChanges(const std::shared_ptr<DBCatalogue> &catalogue, bool hasChanges);
+
 private:
     Ui::CatalogueSideBarWidget *ui;
 
     class CatalogueSideBarWidgetPrivate;
     spimpl::unique_impl_ptr<CatalogueSideBarWidgetPrivate> impl;
+
+private slots:
+    void onContextMenuRequested(const QPoint &pos);
 };
 
 #endif // SCIQLOP_CATALOGUESIDEBARWIDGET_H
diff --git a/gui/include/Catalogue/CatalogueTreeWidgetItem.h b/gui/include/Catalogue/CatalogueTreeWidgetItem.h
new file mode 100644
index 0000000..a8b4f14
--- /dev/null
+++ b/gui/include/Catalogue/CatalogueTreeWidgetItem.h
@@ -0,0 +1,33 @@
+#ifndef SCIQLOP_CATALOGUETREEWIDGETITEM_H
+#define SCIQLOP_CATALOGUETREEWIDGETITEM_H
+
+#include <Common/spimpl.h>
+#include <QTreeWidgetItem>
+
+class DBCatalogue;
+
+
+class CatalogueTreeWidgetItem : public QTreeWidgetItem {
+public:
+    CatalogueTreeWidgetItem(std::shared_ptr<DBCatalogue> catalogue,
+                            int type = QTreeWidgetItem::Type);
+
+    QVariant data(int column, int role) const override;
+    void setData(int column, int role, const QVariant &value) override;
+
+    /// Returns the catalogue represented by the item
+    std::shared_ptr<DBCatalogue> catalogue() const;
+
+    /// Displays or hides the save and cancel buttons indicating that the catalogue has unsaved
+    /// changes
+    void setHasChanges(bool value);
+
+    /// Refreshes the data displayed by the item from the catalogue
+    void refresh();
+
+private:
+    class CatalogueTreeWidgetItemPrivate;
+    spimpl::unique_impl_ptr<CatalogueTreeWidgetItemPrivate> impl;
+};
+
+#endif // SCIQLOP_CATALOGUETREEWIDGETITEM_H
diff --git a/gui/include/SqpApplication.h b/gui/include/SqpApplication.h
index 91f5f13..fad8eb6 100644
--- a/gui/include/SqpApplication.h
+++ b/gui/include/SqpApplication.h
@@ -22,6 +22,7 @@ class VariableController;
 class VisualizationController;
 class DragDropGuiController;
 class ActionsGuiController;
+class CatalogueController;
 
 /**
  * @brief The SqpApplication class aims to make the link between SciQlop
@@ -45,6 +46,7 @@ public:
     TimeController &timeController() noexcept;
     VariableController &variableController() noexcept;
     VisualizationController &visualizationController() noexcept;
+    CatalogueController &catalogueController() noexcept;
 
     /// Accessors for the differents sciqlop helpers, these helpers classes are like controllers but
     /// doesn't live in a thread and access gui
diff --git a/gui/include/Visualization/VisualizationMultiZoneSelectionDialog.h b/gui/include/Visualization/VisualizationMultiZoneSelectionDialog.h
index f3ebcfb..9e17083 100644
--- a/gui/include/Visualization/VisualizationMultiZoneSelectionDialog.h
+++ b/gui/include/Visualization/VisualizationMultiZoneSelectionDialog.h
@@ -15,7 +15,7 @@ class VisualizationMultiZoneSelectionDialog : public QDialog {
 
 public:
     explicit VisualizationMultiZoneSelectionDialog(QWidget *parent = 0);
-    ~VisualizationMultiZoneSelectionDialog();
+    virtual ~VisualizationMultiZoneSelectionDialog();
 
     void setZones(const QVector<VisualizationSelectionZoneItem *> &zones);
     QMap<VisualizationSelectionZoneItem *, bool> selectedZones() const;
diff --git a/gui/include/Visualization/VisualizationTabWidget.h b/gui/include/Visualization/VisualizationTabWidget.h
index 4df7113..5299e6e 100644
--- a/gui/include/Visualization/VisualizationTabWidget.h
+++ b/gui/include/Visualization/VisualizationTabWidget.h
@@ -25,11 +25,19 @@ public:
     explicit VisualizationTabWidget(const QString &name = {}, QWidget *parent = 0);
     virtual ~VisualizationTabWidget();
 
-    /// Add a zone widget
+    /// Adds a zone widget
     void addZone(VisualizationZoneWidget *zoneWidget);
 
+    /// Inserts a zone widget at the specified position
     void insertZone(int index, VisualizationZoneWidget *zoneWidget);
 
+    /// Returns the list of zone widget names in the order they are displayed
+    QStringList availableZoneWidgets() const;
+
+    /// Returns the zone with the specified name.
+    /// If multiple zone with the same name exist, the first one is returned.
+    VisualizationZoneWidget *getZoneWithName(const QString &zoneName);
+
     /**
      * Creates a zone using a variable. The variable will be displayed in a new graph of the new
      * zone. The zone is added at the end.
diff --git a/gui/include/Visualization/VisualizationWidget.h b/gui/include/Visualization/VisualizationWidget.h
index fedb137..adcfe8a 100644
--- a/gui/include/Visualization/VisualizationWidget.h
+++ b/gui/include/Visualization/VisualizationWidget.h
@@ -30,6 +30,8 @@ public:
     /// Returns the class which manage the selection of selection zone across the visualization
     VisualizationSelectionZoneManager &selectionZoneManager() const;
 
+    VisualizationTabWidget *currentTabWidget() const;
+
     // IVisualizationWidget interface
     void accept(IVisualizationWidgetVisitor *visitor) override;
     bool canDrop(const Variable &variable) const override;
diff --git a/gui/include/Visualization/VisualizationZoneWidget.h b/gui/include/Visualization/VisualizationZoneWidget.h
index c13f26f..daa2525 100644
--- a/gui/include/Visualization/VisualizationZoneWidget.h
+++ b/gui/include/Visualization/VisualizationZoneWidget.h
@@ -1,6 +1,7 @@
 #ifndef SCIQLOP_VISUALIZATIONZONEWIDGET_H
 #define SCIQLOP_VISUALIZATIONZONEWIDGET_H
 
+#include "Data/SqpRange.h"
 #include "Visualization/IVisualizationWidget.h"
 #include "Visualization/VisualizationDragWidget.h"
 
@@ -27,6 +28,10 @@ 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);
 
diff --git a/gui/meson.build b/gui/meson.build
index 55e755d..727fa0d 100644
--- a/gui/meson.build
+++ b/gui/meson.build
@@ -1,4 +1,7 @@
 
+qxorm_dep = dependency('QxOrm', required : true, fallback:['QxOrm','qxorm_dep'])
+catalogueapi_dep = dependency('CatalogueAPI', required : true, fallback:['CatalogueAPI','CatalogueAPI_dep'])
+
 gui_moc_headers = [
   'include/DataSource/DataSourceWidget.h',
   'include/Settings/SqpSettingsDialog.h',
@@ -103,7 +106,9 @@ gui_sources = [
   'src/Catalogue/CatalogueExplorer.cpp',
   'src/Catalogue/CatalogueEventsWidget.cpp',
   'src/Catalogue/CatalogueSideBarWidget.cpp',
-  'src/Catalogue/CatalogueInspectorWidget.cpp'
+  'src/Catalogue/CatalogueInspectorWidget.cpp',
+  'src/Catalogue/CatalogueTreeWidgetItem.cpp',
+  'src/Catalogue/CatalogueEventsModel.cpp'
 ]
 
 gui_inc = include_directories(['include'])
@@ -112,11 +117,11 @@ sciqlop_gui_lib = library('sciqlopgui',
                        gui_sources,
                        gui_moc_files,
                        include_directories : [gui_inc],
-                       dependencies : [ qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core],
+                       dependencies : [ qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core, catalogueapi_dep],
                        install : true
                        )
 
 sciqlop_gui = declare_dependency(link_with : sciqlop_gui_lib,
                                 include_directories : gui_inc,
-                                dependencies : [qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core])
+                                dependencies : [qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core, catalogueapi_dep])
 
diff --git a/gui/resources/icones/discard.png b/gui/resources/icones/discard.png
new file mode 100644
index 0000000000000000000000000000000000000000..bfc6b097e9fa0c1093924faeca285fd4cf9c262d
GIT binary patch
literal 1864
zc$@)92e<f%P)<h;3K|Lk000e1NJLTq004jh004jp1^@s6!#-il00004b3#c}2nYxW
zd<bNS00009a7bBm000XU000XU0RWnu7ytkU>PbXFRCt{2omr?=RUF2D`<y#9nWkoz
z7!`$KR5q#2qxo77Jp@4nK@dR@S(Z5!1ws)vPijSlVe_mIL=c)eWZEQ+RHRvYt+bc2
zhkX~`dpyHF`>eJ8Yx>}O@G9Kz+uzT7&pG?-eLz-M0?z?m!Z{?A0rP;l!a2lr74R>x
z2Utp65UBC@40x_+8UbAm{Kwt{5EBHo<15dR3}sW-u<!V>K+tIXXdt+j#^pnYpw;-n
zLvS6f%ZCa<(eagM%fvLN>nUD7Gzi)qKR5_(p#AcpK#&3RDc|3F2yUc&dEX)EbbRGI
zYzNn+o9Mi}uMp@O-&+V~ps&1d5a=FXd6vx*ooFWd%liU>sqwvmU>4@eyAFZr@tucY
z4(7|d3W2Thm2bCGtC-3@&kY3v+v7V0K?dA~{qn9rkO6nr$rS|z8E{XXP_aNDJ-+g7
zri<271}rEMHWUb48D9i~47k@o311*^ZG7dKCQB=2!2JT{T!FyV@vT6R0Sg@{DFuP+
z;~Ryb0zBkEIVlKy8DIHUjoqmLk2+9F3IgB8*9t)ec*21)QV>YL&LIjx1$fGV5>gQO
zKECoTCAw1umN*bz3W89^F9ksrc*cRyQV@hTzVeI$-RUB~R7*On6a=A;UkHLO-~|Ul
zN<k3%_)Q_`23~X^oD>AHjIVt2pzd@7%Nz(L1wm}%4}qXMF#hGlr-{G>U=l*7RE2d3
zu&WFBPCAL8u8<BOtjnsv3Sby8RX9wNU9AMBR|o#EoCHBkS_Mo8c2);{aXD}>FhwL%
zk}a(QE(Q7_e-JoW34*ZoF@wg3eF1<Rg5e|xLepw$#)tX<0K7+nASA5@rU5%@|Dq89
zkRS*}pU_}@Xbu465R3pOYYvrUM{8&@KC}h^5(K_#4f(5m+nfEPA^<=R!676Fe9>A8
zj1R>D0C<-Kfe%_o!STx|10F#BOjdGzuO<IaYE%gVH@yxE<11yrgN6$ww>SRCri&R+
zg1`;0M__!V48JZJ3(cPbqgt+HSP6oN$5+aLhmk)hv3LUxjjxm-us8nbf}2=Zg21dl
z!{PCjDkKO@cq4FV8#{=q0z88JK?}uRjjxm-(Bn;bIKGmvcNcNRn}9KGA9cr+ASmb0
z31EDs3h)^62h|sU0UTE9NIR?qLB!)LRe;BlKgh27OJHp2qw9$h1QCy~<ooUCbo(nJ
z8eb_vuy_2!J3N-9RgwC}<mI;tet%cA4%i|c!nR_)ElVRmO?&Uq_F8HDh#^ShM+`w4
zKVk^d_z^>p#*Y|+G=9Vor12w$z}Jsian(!k2!b?z#1N$MBZeT2A29@J{D>h)<3|iZ
z8b4wP()ez82?7vg!2AwEC+qcMEJBdRchgoNNaMS0qY$L={jd=T()fN^D+FnLKdl9V
zG``>N2!b?z7%l}t2F!CHe6k)dqK%7y()eMz5Cm!bu-z1bG=3be3qcw`E)RhqjUT5M
z0hQ{&__IlhO_PA}74n||v1%LnhhfF4Gav`xZsdO?+4eTzM4%gZ$$>n!J>))w8L+^C
zP`1ZciVcFgx1!5{`y2>o+P?!Q)s`oR;AIE$nRe3~Qf0tG2SS=0|KvvH2_J&5DR4uo
zP(K6c5AsL8t<*!95NrmHD9|4W?*`9B$5-kBUU49|E`I}zYokAqL-3>n;dP9EO1tF=
z2ZC>b@g@2LIRuLxC{fniDL1}S5Ado3J<9rf;K&a81NoZ?o^_y1nek8Uv^@So@B?s^
zhW<bf!SfE3YG?e@bd|?H2z~^P*4Q6_E?}tx<yv_MddFAl0bX;UUn~Cv9AltAkUvje
z=0M3t?gvgcRUY>t_!&6XSo;BW<L0B|eg;l%7*-GPx<J2H{slPBVDBMv?I836lZ`eW
zD%bk|3QRECxQ=>(w>k{2!#jZ~hP&2NFK$4v1vuVt*M{mNKc61k_)5LN8+CHo@>XD?
z@s=&LAFu+M@uyno*Gf_l{05w0p<f~G54?}P@_zznT4`2Hy}+B;>tFkR1}Ag?@B#6S
zuVf2?R;RQ@bs+E|=F0yCoMo*|`!Wqd*%Mn<brA3oX2w6;Vvn*i_3TL3xeY5C2CPKy
z_~%${(3x~YumiKNa2nBYU^RNiKi6`09qL051h!w~(y9@_TFRII8$ZWa>I2@Ue1GZJ
zIkadbu%2?`pC^!4x5`4`>a(3v8U<{iz46bN2x>@uz&o_}YtM%VylrVTu#wi~cM;b3
zN<|^?{nuVojUm4(rP=rwh@~^HRuF^={}7EOzdEJ1{BGbv!Cbb~=mc6U{ek=fh0P2t
zf01Y+yQ+m?H*m3NA_0vfzhEKC^6Z7+A7GkPi2ng4RV#XARMfcu0000<MNUMnLSTZN
CZ9%gD

literal 0
Hc$@<O00001

diff --git a/gui/resources/icones/save.png b/gui/resources/icones/save.png
new file mode 100644
index 0000000000000000000000000000000000000000..37b0c2113dd6a28d47bdf0d2174fd65ce5736796
GIT binary patch
literal 1334
zc$}?N|3A}t9DnbNSu|WOB-HAfSn1387F`~z$%ZsN5I5X<aIPzi=8;yoZPglT)peXO
z370}czLnPcxRLHQvlfz=&(*^a%OvHYS+^c{|G+&S_k28`ujk|WdOTmhzH(_{K{yLX
z3jhF)N+BOGIp?#m7}J#PIwUt4nzfr6fi)oun<y~lWoeWc766vEpM?O$r4FXfAeBst
zI8mw_*>^ZD(BaYSPZf5_OEv3wUBQ)b&`MHXK`I$d{5JM(INEJOY4L=YQAr?u;iGQO
zYft|T4yJjoi&ly9^We6A!p;7I)n==|^6u<vrZpTJ-I4i5!s`8KU_4GzDo*vXj|C{d
z`N2c*FDO`B=ho+78uJFx3a0X+JT*qN9ajbgLH1Db(ZI7hAiV7I%Mkp2eS`JgD!DSX
z$BMD)lgLk~+XAy;-t+^F05=ivko*yMm&h9R`77Lz8Gmg^DjAt!B0h-*+Pq6xK$4yR
z$!aR0q{kN{7QTGgv^bQcJJ)d$sd{Qt8kbgA&F#g!dyblR_Z?r`&Do*8KjR?=Nt}Ir
zDGN%6cfkV+c2by8)H5u0lz+_`d(|W7rw6x0!o`PN-cjin=0wH?CPp(wn@i@NYziGH
zYpB=&Q@H6;M2>P;%Yx(KT!k*_rW0?MIim%RcJ)hc!YEKrufB-Hk*=Xsd8a*{kY?q=
zq&?-J?`b0TOHO;SB^OB>CBd_bl)ZLHGpHNkxQvU0t8;BO0_m`+x4^=2kt#mQSL7W9
zhPGYYW4daMur}?=#Q2Gf>$i}q8y@%*h{3D=mys$lo59q2*Q3VAlgmMKN&p)_NY;j!
z%F<z*P}J(%qLrN4OSZf@PEZ|+2wo)w=&KrMWDd-wgW!=oA3Dd+d4_mK$3&QtqyBv3
zjHoay+X{*?>-MXLqh)@f?bBJ8QVKg3oj7ji_n$@$qmw<hhEZo67DHn&?(Cz{M+wxa
zcRS4u!6z3L+em);{VT<_XX<g;9(R`ajRO#CC3zXwi8UllRPIM?kJf>VdtFCj>rU9K
z0(D?hR9XFvN{v}YxId^KaC}`-&-qT0KT&ZU6moprdt+p!nTR;HWLYU;gf(hkk7S;*
ze^L+xj3CwAYKJ0D?XKUXFUrKr^nTWQ|H;_-FgOR^tA18=o4&r^=r;MfWKEWQRoQrM
zxtH39UdU`qBxkJK=xet2zp<CdBTxhIA3z$aLDOhwEr))E=#aT*&b_Q#*Dm;vZHH}T
zMd3quSbct}O}<t8p^&>X9_c}FHoS1sruI8S-O$+<*Y{W`1ZuIGYfUBom;%)tF^7-9
z9e=WfS4N-$FV{L}&V6F9Pb%T@sV!d3Lx`=L=_`gKy<BUZInsK{f#2JUuS}9@X`78f
zQcH<8u2V3L&*n4t<|7tzjhZckeI4cx&}XUv`hVfUx5{!If40@((bb9$|HBq;^9xKj
znkB<<fvt8VMKbAy*PS~WR^-Pcc}*C&lTv#rJi0OC4u+8~*xh+<vM2_nH`<&PTr>-D
zohpImp-f1t9HZ<Dsrr80=+gIOad|`NV!_N9KJRBg;T2&&bb7SwxZ1)+6H;3vy0;nm
z!Z-tqa_2X|8RJOn%L9gzinldUZ`Tm3P!ECR4}ozmko*r46-$=45?0-5U(Yv~9v`3v
LhLOd)8N9y%!!=w!

literal 0
Hc$@<O00001

diff --git a/gui/resources/sqpguiresources.qrc b/gui/resources/sqpguiresources.qrc
index 76f0625..60a79a6 100644
--- a/gui/resources/sqpguiresources.qrc
+++ b/gui/resources/sqpguiresources.qrc
@@ -25,5 +25,7 @@
 		<file>icones/allEvents.png</file>
 		<file>icones/trash.png</file>
 		<file>icones/database.png</file>
+		<file>icones/save.png</file>
+		<file>icones/discard.png</file>
     </qresource>
 </RCC>
diff --git a/gui/src/Catalogue/CatalogueEventsModel.cpp b/gui/src/Catalogue/CatalogueEventsModel.cpp
new file mode 100644
index 0000000..ad78d41
--- /dev/null
+++ b/gui/src/Catalogue/CatalogueEventsModel.cpp
@@ -0,0 +1,381 @@
+#include "Catalogue/CatalogueEventsModel.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>
+
+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;
+
+    enum class Column { Name, TStart, TEnd, Tags, Product, NbColumn };
+    QStringList columnNames()
+    {
+        return QStringList{tr("Event"), tr("TStart"), tr("TEnd"), tr("Tags"), tr("Product")};
+    }
+
+    QVariant eventData(int col, const std::shared_ptr<DBEvent> &event) const
+    {
+        switch (static_cast<Column>(col)) {
+            case Column::Name:
+                return event->getName();
+            case Column::TStart:
+                return DateUtils::dateTime(event->getTStart());
+            case Column::TEnd:
+                return DateUtils::dateTime(event->getTEnd());
+            case Column::Product: {
+                auto eventProductsIt = m_EventProducts.find(event.get());
+                if (eventProductsIt != m_EventProducts.cend()) {
+                    return QString::number(m_EventProducts.at(event.get()).count()) + " product(s)";
+                }
+                else {
+                    return "0 product";
+                }
+            }
+            case Column::Tags: {
+                QString tagList;
+                auto tags = event->getTags();
+                for (auto tag : tags) {
+                    tagList += tag.getName();
+                    tagList += ' ';
+                }
+
+                return tagList;
+            }
+            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));
+        }
+    }
+
+    QVariant eventProductData(int col, const std::shared_ptr<DBEventProduct> &eventProduct) const
+    {
+        switch (static_cast<Column>(col)) {
+            case Column::Name:
+                return eventProduct->getProductId();
+            case Column::TStart:
+                return DateUtils::dateTime(eventProduct->getTStart());
+            case Column::TEnd:
+                return DateUtils::dateTime(eventProduct->getTEnd());
+            case Column::Product:
+                return eventProduct->getProductId();
+            case Column::Tags: {
+                return QString();
+            }
+            default:
+                break;
+        }
+
+        Q_ASSERT(false);
+        return QStringLiteral("Unknown Data");
+    }
+};
+
+CatalogueEventsModel::CatalogueEventsModel(QObject *parent)
+        : QAbstractItemModel(parent), impl{spimpl::make_unique_impl<CatalogueEventsModelPrivate>()}
+{
+}
+
+void CatalogueEventsModel::setEvents(const QVector<std::shared_ptr<DBEvent> > &events)
+{
+    beginResetModel();
+
+    impl->m_Events = events;
+    impl->m_EventProducts.clear();
+    for (auto event : events) {
+        impl->parseEventProduct(event);
+    }
+
+    endResetModel();
+}
+
+std::shared_ptr<DBEvent> CatalogueEventsModel::getEvent(const QModelIndex &index) const
+{
+    if (itemTypeOf(index) == CatalogueEventsModel::ItemType::Event) {
+        return impl->m_Events.value(index.row());
+    }
+    else {
+        return nullptr;
+    }
+}
+
+std::shared_ptr<DBEvent> CatalogueEventsModel::getParentEvent(const QModelIndex &index) const
+{
+    if (itemTypeOf(index) == CatalogueEventsModel::ItemType::EventProduct) {
+        return getEvent(index.parent());
+    }
+    else {
+        return nullptr;
+    }
+}
+
+std::shared_ptr<DBEventProduct>
+CatalogueEventsModel::getEventProduct(const QModelIndex &index) const
+{
+    if (itemTypeOf(index) == CatalogueEventsModel::ItemType::EventProduct) {
+        auto event = static_cast<DBEvent *>(index.internalPointer());
+        return impl->m_EventProducts.at(event).value(index.row());
+    }
+    else {
+        return nullptr;
+    }
+}
+
+void CatalogueEventsModel::addEvent(const std::shared_ptr<DBEvent> &event)
+{
+    beginInsertRows(QModelIndex(), impl->m_Events.count() - 1, impl->m_Events.count() - 1);
+    impl->m_Events.append(event);
+    impl->parseEventProduct(event);
+    endInsertRows();
+}
+
+void CatalogueEventsModel::removeEvent(const std::shared_ptr<DBEvent> &event)
+{
+    auto index = impl->m_Events.indexOf(event);
+    if (index >= 0) {
+        beginRemoveRows(QModelIndex(), index, index);
+        impl->m_Events.removeAt(index);
+        impl->m_EventProducts.erase(event.get());
+        endRemoveRows();
+    }
+}
+
+void CatalogueEventsModel::refreshEvent(const std::shared_ptr<DBEvent> &event)
+{
+    auto i = impl->m_Events.indexOf(event);
+    if (i >= 0) {
+        auto eventIndex = index(i, 0);
+        auto colCount = columnCount();
+        emit dataChanged(eventIndex, index(i, colCount));
+
+        auto childCount = rowCount(eventIndex);
+        emit dataChanged(index(0, 0, eventIndex), index(childCount, colCount, eventIndex));
+    }
+}
+
+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>(CatalogueEventsModelPrivate::Column::NbColumn);
+}
+
+Qt::ItemFlags CatalogueEventsModel::flags(const QModelIndex &index) const
+{
+    return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
+}
+
+QVariant CatalogueEventsModel::data(const QModelIndex &index, int role) const
+{
+    if (index.isValid()) {
+
+        auto type = itemTypeOf(index);
+        if (type == CatalogueEventsModel::ItemType::Event) {
+            auto event = getEvent(index);
+            switch (role) {
+                case Qt::DisplayRole:
+                    return impl->eventData(index.column(), event);
+                    break;
+            }
+        }
+        else if (type == CatalogueEventsModel::ItemType::EventProduct) {
+            auto product = getEventProduct(index);
+            switch (role) {
+                case Qt::DisplayRole:
+                    return impl->eventProductData(index.column(), product);
+                    break;
+            }
+        }
+    }
+
+    return QVariant{};
+}
+
+QVariant CatalogueEventsModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+    if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
+        return impl->columnNames().value(section);
+    }
+
+    return QVariant();
+}
+
+void CatalogueEventsModel::sort(int column, Qt::SortOrder order)
+{
+    std::sort(impl->m_Events.begin(), impl->m_Events.end(),
+              [this, column, order](auto e1, auto e2) {
+                  auto data1 = impl->eventData(column, e1);
+                  auto data2 = impl->eventData(column, e2);
+
+                  auto result = data1.toString() < data2.toString();
+
+                  return order == Qt::AscendingOrder ? result : !result;
+              });
+
+    emit dataChanged(QModelIndex(), QModelIndex());
+}
+
+Qt::DropActions CatalogueEventsModel::supportedDragActions() const
+{
+    return Qt::CopyAction | Qt::MoveAction;
+}
+
+QStringList CatalogueEventsModel::mimeTypes() const
+{
+    return {MIME_TYPE_EVENT_LIST, MIME_TYPE_TIME_RANGE};
+}
+
+QMimeData *CatalogueEventsModel::mimeData(const QModelIndexList &indexes) const
+{
+    auto mimeData = new QMimeData;
+
+    bool isFirst = true;
+
+    QVector<std::shared_ptr<DBEvent> > eventList;
+    QVector<std::shared_ptr<DBEventProduct> > eventProductList;
+
+    SqpRange firstTimeRange;
+    for (const auto &index : indexes) {
+        if (index.column() == 0) { // only the first column
+
+            auto type = itemTypeOf(index);
+            if (type == ItemType::Event) {
+                auto event = getEvent(index);
+                eventList << event;
+
+                if (isFirst) {
+                    isFirst = false;
+                    firstTimeRange.m_TStart = event->getTStart();
+                    firstTimeRange.m_TEnd = event->getTEnd();
+                }
+            }
+            else if (type == ItemType::EventProduct) {
+                auto product = getEventProduct(index);
+                eventProductList << product;
+
+                if (isFirst) {
+                    isFirst = false;
+                    firstTimeRange.m_TStart = product->getTStart();
+                    firstTimeRange.m_TEnd = product->getTEnd();
+                }
+            }
+        }
+    }
+
+    auto eventsEncodedData
+        = QByteArray{}; // sqpApp->catalogueController().->mimeDataForEvents(eventList); //TODO
+    mimeData->setData(MIME_TYPE_EVENT_LIST, eventsEncodedData);
+
+    if (eventList.count() + eventProductList.count() == 1) {
+        // No time range MIME data if multiple events are dragged
+        auto timeEncodedData = TimeController::mimeDataForTimeRange(firstTimeRange);
+        mimeData->setData(MIME_TYPE_TIME_RANGE, timeEncodedData);
+    }
+
+    return mimeData;
+}
+
+CatalogueEventsModel::ItemType CatalogueEventsModel::itemTypeOf(const QModelIndex &index) const
+{
+    if (!index.isValid()) {
+        return ItemType::Root;
+    }
+    else if (index.internalPointer() == nullptr) {
+        return ItemType::Event;
+    }
+    else {
+        return ItemType::EventProduct;
+    }
+}
diff --git a/gui/src/Catalogue/CatalogueEventsWidget.cpp b/gui/src/Catalogue/CatalogueEventsWidget.cpp
index 3fe0065..410d933 100644
--- a/gui/src/Catalogue/CatalogueEventsWidget.cpp
+++ b/gui/src/Catalogue/CatalogueEventsWidget.cpp
@@ -1,15 +1,200 @@
 #include "Catalogue/CatalogueEventsWidget.h"
 #include "ui_CatalogueEventsWidget.h"
 
-#include <QtDebug>
+#include <Catalogue/CatalogueController.h>
+#include <Catalogue/CatalogueEventsModel.h>
+#include <CatalogueDao.h>
+#include <DBCatalogue.h>
+#include <SqpApplication.h>
+#include <Visualization/VisualizationTabWidget.h>
+#include <Visualization/VisualizationWidget.h>
+#include <Visualization/VisualizationZoneWidget.h>
+
+#include <QDialog>
+#include <QDialogButtonBox>
+#include <QListWidget>
+
+Q_LOGGING_CATEGORY(LOG_CatalogueEventsWidget, "CatalogueEventsWidget")
+
+/// Format of the dates appearing in the label of a cursor
+const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss");
 
 struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
-    void addEventItem(const QStringList &data, QTableWidget *tableWidget);
 
-    enum class Column { Event, TStart, TEnd, Tags, Product, NbColumn };
-    QStringList columnNames() { return QStringList{"Event", "TStart", "TEnd", "Tags", "Product"}; }
-};
+    CatalogueEventsModel *m_Model = nullptr;
+    QStringList m_ZonesForTimeMode;
+    QString m_ZoneForGraphMode;
+
+    VisualizationWidget *m_VisualizationWidget = nullptr;
+
+    void setEvents(const QVector<std::shared_ptr<DBEvent> > &events, QTreeView *treeView)
+    {
+        treeView->setSortingEnabled(false);
+        m_Model->setEvents(events);
+        treeView->setSortingEnabled(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";
+        }
+    }
 
+    void updateForGraphMode(QTreeView *treeView)
+    {
+        auto selectedRows = treeView->selectionModel()->selectedRows();
+
+        if (selectedRows.count() == 1) {
+            auto event = m_Model->getEvent(selectedRows.first());
+            if (m_VisualizationWidget) {
+                if (auto tab = m_VisualizationWidget->currentTabWidget()) {
+                    if (auto zone = tab->getZoneWithName(m_ZoneForGraphMode)) {
+                        // TODO
+                    }
+                }
+                else {
+                    qCWarning(LOG_CatalogueEventsWidget())
+                        << "updateGraphMode: no tab found in the visualization";
+                }
+            }
+            else {
+                qCWarning(LOG_CatalogueEventsWidget())
+                    << "updateGraphMode: visualization widget not found";
+            }
+        }
+        else {
+            qCWarning(LOG_CatalogueEventsWidget())
+                << "updateGraphMode: not compatible with multiple events selected";
+        }
+    }
+};
 
 CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
         : QWidget(parent),
@@ -18,45 +203,82 @@ CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
 {
     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(ui->treeView);
         }
     });
 
-    connect(ui->tableWidget, &QTableWidget::cellClicked, [this](auto row, auto column) {
-        auto event = ui->tableWidget->item(row, 0)->text();
-        emit this->eventSelected(event);
-    });
+    auto emitSelection = [this]() {
+        QVector<std::shared_ptr<DBEvent> > events;
+        QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
 
-    connect(ui->tableWidget, &QTableWidget::currentItemChanged,
-            [this](auto current, auto previous) {
-                if (current && current->row() >= 0) {
-                    auto event = ui->tableWidget->item(current->row(), 0)->text();
-                    emit this->eventSelected(event);
-                }
-            });
+        for (auto rowIndex : ui->treeView->selectionModel()->selectedRows()) {
+
+            auto itemType = impl->m_Model->itemTypeOf(rowIndex);
+            if (itemType == CatalogueEventsModel::ItemType::Event) {
+                events << impl->m_Model->getEvent(rowIndex);
+            }
+            else if (itemType == CatalogueEventsModel::ItemType::EventProduct) {
+                eventProducts << qMakePair(impl->m_Model->getParentEvent(rowIndex),
+                                           impl->m_Model->getEventProduct(rowIndex));
+            }
+        }
 
-    connect(ui->tableWidget, &QTableWidget::itemSelectionChanged, [this]() {
-        auto selection = ui->tableWidget->selectedRanges();
-        auto isNotMultiSelection
-            = selection.isEmpty() || (selection.count() == 1 && selection.first().rowCount() == 1);
+        if (!events.isEmpty() && eventProducts.isEmpty()) {
+            emit this->eventsSelected(events);
+        }
+        else if (events.isEmpty() && !eventProducts.isEmpty()) {
+            emit this->eventProductsSelected(eventProducts);
+        }
+        else {
+            emit this->selectionCleared();
+        }
+    };
+
+    connect(ui->treeView, &QTreeView::clicked, emitSelection);
+    connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, emitSelection);
+
+    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(ui->treeView);
+        }
     });
 
-    Q_ASSERT(impl->columnNames().count() == (int)CatalogueEventsWidgetPrivate::Column::NbColumn);
-    ui->tableWidget->setColumnCount((int)CatalogueEventsWidgetPrivate::Column::NbColumn);
-    ui->tableWidget->setHorizontalHeaderLabels(impl->columnNames());
-    ui->tableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
-    ui->tableWidget->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
-    ui->tableWidget->horizontalHeader()->setSortIndicatorShown(true);
+    ui->treeView->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
+    ui->treeView->header()->setSectionResizeMode(0, QHeaderView::Stretch);
+    ui->treeView->header()->setSortIndicatorShown(true);
 }
 
 CatalogueEventsWidget::~CatalogueEventsWidget()
@@ -64,37 +286,31 @@ CatalogueEventsWidget::~CatalogueEventsWidget()
     delete ui;
 }
 
-void CatalogueEventsWidget::populateWithCatalogue(const QString &catalogue)
+void CatalogueEventsWidget::setVisualizationWidget(VisualizationWidget *visualization)
+{
+    impl->m_VisualizationWidget = visualization;
+}
+
+void CatalogueEventsWidget::setEventChanges(const std::shared_ptr<DBEvent> &event, bool hasChanges)
 {
-    ui->tableWidget->clearContents();
-    ui->tableWidget->setRowCount(0);
-
-    // TODO
-    impl->addEventItem(
-        {catalogue + " - Event 1", "12/12/2012 12:12", "12/12/2042 12:52", "cloud", "mfi/b_gse42"},
-        ui->tableWidget);
-    impl->addEventItem(
-        {catalogue + " - Event 2", "12/12/2012 12:10", "12/12/2042 12:42", "Acloud", "mfi/b_gse1"},
-        ui->tableWidget);
-    impl->addEventItem(
-        {catalogue + " - Event 3", "12/12/2012 12:22", "12/12/2042 12:12", "Gcloud", "mfi/b_gse2"},
-        ui->tableWidget);
-    impl->addEventItem(
-        {catalogue + " - Event 4", "12/12/2012 12:00", "12/12/2042 12:62", "Bcloud", "mfi/b_gse3"},
-        ui->tableWidget);
+    impl->m_Model->refreshEvent(event);
 }
 
-void CatalogueEventsWidget::CatalogueEventsWidgetPrivate::addEventItem(const QStringList &data,
-                                                                       QTableWidget *tableWidget)
+void CatalogueEventsWidget::populateWithCatalogues(
+    const QVector<std::shared_ptr<DBCatalogue> > &catalogues)
 {
-    tableWidget->setSortingEnabled(false);
-    auto row = tableWidget->rowCount();
-    tableWidget->setRowCount(row + 1);
-
-    for (auto i = 0; i < (int)Column::NbColumn; ++i) {
-        auto item = new QTableWidgetItem(data.value(i));
-        item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
-        tableWidget->setItem(row, i, item);
+    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());
+            }
+        }
     }
-    tableWidget->setSortingEnabled(true);
+
+    impl->setEvents(events, ui->treeView);
 }
diff --git a/gui/src/Catalogue/CatalogueExplorer.cpp b/gui/src/Catalogue/CatalogueExplorer.cpp
index c286298..b0d99d7 100644
--- a/gui/src/Catalogue/CatalogueExplorer.cpp
+++ b/gui/src/Catalogue/CatalogueExplorer.cpp
@@ -1,22 +1,83 @@
 #include "Catalogue/CatalogueExplorer.h"
 #include "ui_CatalogueExplorer.h"
 
+#include <Visualization/VisualizationWidget.h>
+
+#include <DBCatalogue.h>
+#include <DBEvent.h>
+
+struct CatalogueExplorer::CatalogueExplorerPrivate {
+};
+
 CatalogueExplorer::CatalogueExplorer(QWidget *parent)
         : QDialog(parent, Qt::Dialog | Qt::WindowMinMaxButtonsHint | Qt::WindowCloseButtonHint),
-          ui(new Ui::CatalogueExplorer)
+          ui(new Ui::CatalogueExplorer),
+          impl{spimpl::make_unique_impl<CatalogueExplorerPrivate>()}
 {
     ui->setupUi(this);
 
-    connect(ui->catalogues, &CatalogueSideBarWidget::catalogueSelected, [this](auto name) {
-        ui->inspector->setCatalogue(name);
-        ui->events->populateWithCatalogue(name);
+    connect(ui->catalogues, &CatalogueSideBarWidget::catalogueSelected, [this](auto catalogues) {
+        if (catalogues.count() == 1) {
+            ui->inspector->setCatalogue(catalogues.first());
+        }
+        else {
+            ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
+        }
+
+        ui->events->populateWithCatalogues(catalogues);
+    });
+
+    connect(ui->catalogues, &CatalogueSideBarWidget::databaseSelected, [this](auto databases) {
+        ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
     });
 
-    connect(ui->events, &CatalogueEventsWidget::eventSelected,
-            [this](auto name) { ui->inspector->setEvent(name); });
+    connect(ui->catalogues, &CatalogueSideBarWidget::trashSelected,
+            [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
+
+    connect(ui->catalogues, &CatalogueSideBarWidget::allEventsSelected,
+            [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
+
+    connect(ui->catalogues, &CatalogueSideBarWidget::selectionCleared,
+            [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
+
+    connect(ui->events, &CatalogueEventsWidget::eventsSelected, [this](auto events) {
+        if (events.count() == 1) {
+            ui->inspector->setEvent(events.first());
+        }
+        else {
+            ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
+        }
+    });
+
+    connect(ui->events, &CatalogueEventsWidget::eventProductsSelected, [this](auto eventProducts) {
+        if (eventProducts.count() == 1) {
+            ui->inspector->setEventProduct(eventProducts.first().first,
+                                           eventProducts.first().second);
+        }
+        else {
+            ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
+        }
+    });
+
+    connect(ui->events, &CatalogueEventsWidget::selectionCleared,
+            [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
+
+    connect(ui->inspector, &CatalogueInspectorWidget::catalogueUpdated,
+            [this](auto catalogue) { ui->catalogues->setCatalogueChanges(catalogue, true); });
+
+    connect(ui->inspector, &CatalogueInspectorWidget::eventUpdated,
+            [this](auto event) { ui->events->setEventChanges(event, true); });
+
+    connect(ui->inspector, &CatalogueInspectorWidget::eventProductUpdated,
+            [this](auto event, auto eventProduct) { ui->events->setEventChanges(event, true); });
 }
 
 CatalogueExplorer::~CatalogueExplorer()
 {
     delete ui;
 }
+
+void CatalogueExplorer::setVisualizationWidget(VisualizationWidget *visualization)
+{
+    ui->events->setVisualizationWidget(visualization);
+}
diff --git a/gui/src/Catalogue/CatalogueInspectorWidget.cpp b/gui/src/Catalogue/CatalogueInspectorWidget.cpp
index 5cb782e..a51f4a7 100644
--- a/gui/src/Catalogue/CatalogueInspectorWidget.cpp
+++ b/gui/src/Catalogue/CatalogueInspectorWidget.cpp
@@ -1,11 +1,33 @@
 #include "Catalogue/CatalogueInspectorWidget.h"
 #include "ui_CatalogueInspectorWidget.h"
 
+#include <Common/DateUtils.h>
+#include <DBCatalogue.h>
+#include <DBEvent.h>
+#include <DBEventProduct.h>
+#include <DBTag.h>
+
+struct CatalogueInspectorWidget::CatalogueInspectorWidgetPrivate {
+    std::shared_ptr<DBCatalogue> m_DisplayedCatalogue = nullptr;
+    std::shared_ptr<DBEvent> m_DisplayedEvent = nullptr;
+    std::shared_ptr<DBEventProduct> m_DisplayedEventProduct = nullptr;
+
+    void connectCatalogueUpdateSignals(CatalogueInspectorWidget *inspector,
+                                       Ui::CatalogueInspectorWidget *ui);
+    void connectEventUpdateSignals(CatalogueInspectorWidget *inspector,
+                                   Ui::CatalogueInspectorWidget *ui);
+};
+
 CatalogueInspectorWidget::CatalogueInspectorWidget(QWidget *parent)
-        : QWidget(parent), ui(new Ui::CatalogueInspectorWidget)
+        : QWidget(parent),
+          ui(new Ui::CatalogueInspectorWidget),
+          impl{spimpl::make_unique_impl<CatalogueInspectorWidgetPrivate>()}
 {
     ui->setupUi(this);
     showPage(Page::Empty);
+
+    impl->connectCatalogueUpdateSignals(this, ui);
+    impl->connectEventUpdateSignals(this, ui);
 }
 
 CatalogueInspectorWidget::~CatalogueInspectorWidget()
@@ -13,6 +35,71 @@ CatalogueInspectorWidget::~CatalogueInspectorWidget()
     delete ui;
 }
 
+void CatalogueInspectorWidget::CatalogueInspectorWidgetPrivate::connectCatalogueUpdateSignals(
+    CatalogueInspectorWidget *inspector, Ui::CatalogueInspectorWidget *ui)
+{
+    connect(ui->leCatalogueName, &QLineEdit::editingFinished, [ui, inspector, this]() {
+        if (ui->leCatalogueName->text() != m_DisplayedCatalogue->getName()) {
+            m_DisplayedCatalogue->setName(ui->leCatalogueName->text());
+            emit inspector->catalogueUpdated(m_DisplayedCatalogue);
+        }
+    });
+
+    connect(ui->leCatalogueAuthor, &QLineEdit::editingFinished, [ui, inspector, this]() {
+        if (ui->leCatalogueAuthor->text() != m_DisplayedCatalogue->getAuthor()) {
+            m_DisplayedCatalogue->setAuthor(ui->leCatalogueAuthor->text());
+            emit inspector->catalogueUpdated(m_DisplayedCatalogue);
+        }
+    });
+}
+
+void CatalogueInspectorWidget::CatalogueInspectorWidgetPrivate::connectEventUpdateSignals(
+    CatalogueInspectorWidget *inspector, Ui::CatalogueInspectorWidget *ui)
+{
+    connect(ui->leEventName, &QLineEdit::editingFinished, [ui, inspector, this]() {
+        if (ui->leEventName->text() != m_DisplayedEvent->getName()) {
+            m_DisplayedEvent->setName(ui->leEventName->text());
+            emit inspector->eventUpdated(m_DisplayedEvent);
+        }
+    });
+
+    connect(ui->leEventTags, &QLineEdit::editingFinished, [ui, inspector, this]() {
+        auto tags = ui->leEventTags->text().split(QRegExp("\\s+"));
+        std::list<QString> tagNames;
+        for (auto tag : tags) {
+            tagNames.push_back(tag);
+        }
+
+        if (m_DisplayedEvent->getTagsNames() != tagNames) {
+            m_DisplayedEvent->setTagsNames(tagNames);
+            emit inspector->eventUpdated(m_DisplayedEvent);
+        }
+    });
+
+    connect(ui->leEventProduct, &QLineEdit::editingFinished, [ui, inspector, this]() {
+        if (ui->leEventProduct->text() != m_DisplayedEventProduct->getProductId()) {
+            m_DisplayedEventProduct->setProductId(ui->leEventProduct->text());
+            emit inspector->eventProductUpdated(m_DisplayedEvent, m_DisplayedEventProduct);
+        }
+    });
+
+    connect(ui->dateTimeEventTStart, &QDateTimeEdit::editingFinished, [ui, inspector, this]() {
+        auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTStart->dateTime());
+        if (time != m_DisplayedEventProduct->getTStart()) {
+            m_DisplayedEventProduct->setTStart(time);
+            emit inspector->eventProductUpdated(m_DisplayedEvent, m_DisplayedEventProduct);
+        }
+    });
+
+    connect(ui->dateTimeEventTEnd, &QDateTimeEdit::editingFinished, [ui, inspector, this]() {
+        auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTEnd->dateTime());
+        if (time != m_DisplayedEventProduct->getTEnd()) {
+            m_DisplayedEventProduct->setTEnd(time);
+            emit inspector->eventProductUpdated(m_DisplayedEvent, m_DisplayedEventProduct);
+        }
+    });
+}
+
 void CatalogueInspectorWidget::showPage(CatalogueInspectorWidget::Page page)
 {
     ui->stackedWidget->setCurrentIndex(static_cast<int>(page));
@@ -23,14 +110,72 @@ CatalogueInspectorWidget::Page CatalogueInspectorWidget::currentPage() const
     return static_cast<Page>(ui->stackedWidget->currentIndex());
 }
 
-void CatalogueInspectorWidget::setEvent(const QString &event)
+void CatalogueInspectorWidget::setEvent(const std::shared_ptr<DBEvent> &event)
+{
+    impl->m_DisplayedEvent = event;
+
+    blockSignals(true);
+
+    showPage(Page::EventProperties);
+    ui->leEventName->setEnabled(true);
+    ui->leEventName->setText(event->getName());
+    ui->leEventProduct->setEnabled(false);
+    ui->leEventProduct->setText(
+        QString::number(event->getEventProducts().size()).append(" product(s)"));
+
+    QString tagList;
+    auto tags = event->getTagsNames();
+    for (auto tag : tags) {
+        tagList += tag;
+        tagList += ' ';
+    }
+
+    ui->leEventTags->setEnabled(true);
+    ui->leEventTags->setText(tagList);
+
+    ui->dateTimeEventTStart->setEnabled(false);
+    ui->dateTimeEventTEnd->setEnabled(false);
+
+    ui->dateTimeEventTStart->setDateTime(DateUtils::dateTime(event->getTStart()));
+    ui->dateTimeEventTEnd->setDateTime(DateUtils::dateTime(event->getTEnd()));
+
+    blockSignals(false);
+}
+
+void CatalogueInspectorWidget::setEventProduct(const std::shared_ptr<DBEvent> &event,
+                                               const std::shared_ptr<DBEventProduct> &eventProduct)
 {
+    impl->m_DisplayedEventProduct = eventProduct;
+
+    blockSignals(true);
+
     showPage(Page::EventProperties);
-    ui->leEventName->setText(event);
+    ui->leEventName->setEnabled(false);
+    ui->leEventName->setText(event->getName());
+    ui->leEventProduct->setEnabled(true);
+    ui->leEventProduct->setText(eventProduct->getProductId());
+
+    ui->leEventTags->setEnabled(false);
+    ui->leEventTags->clear();
+
+    ui->dateTimeEventTStart->setEnabled(true);
+    ui->dateTimeEventTEnd->setEnabled(true);
+
+    ui->dateTimeEventTStart->setDateTime(DateUtils::dateTime(eventProduct->getTStart()));
+    ui->dateTimeEventTEnd->setDateTime(DateUtils::dateTime(eventProduct->getTEnd()));
+
+    blockSignals(false);
 }
 
-void CatalogueInspectorWidget::setCatalogue(const QString &catalogue)
+void CatalogueInspectorWidget::setCatalogue(const std::shared_ptr<DBCatalogue> &catalogue)
 {
+    impl->m_DisplayedCatalogue = catalogue;
+
+    blockSignals(true);
+
     showPage(Page::CatalogueProperties);
-    ui->leCatalogueName->setText(catalogue);
+    ui->leCatalogueName->setText(catalogue->getName());
+    ui->leCatalogueAuthor->setText(catalogue->getAuthor());
+
+    blockSignals(false);
 }
diff --git a/gui/src/Catalogue/CatalogueSideBarWidget.cpp b/gui/src/Catalogue/CatalogueSideBarWidget.cpp
index f5ade50..97850e5 100644
--- a/gui/src/Catalogue/CatalogueSideBarWidget.cpp
+++ b/gui/src/Catalogue/CatalogueSideBarWidget.cpp
@@ -1,5 +1,17 @@
 #include "Catalogue/CatalogueSideBarWidget.h"
 #include "ui_CatalogueSideBarWidget.h"
+#include <SqpApplication.h>
+
+#include <Catalogue/CatalogueController.h>
+#include <Catalogue/CatalogueTreeWidgetItem.h>
+#include <CatalogueDao.h>
+#include <ComparaisonPredicate.h>
+#include <DBCatalogue.h>
+
+#include <QMenu>
+
+Q_LOGGING_CATEGORY(LOG_CatalogueSideBarWidget, "CatalogueSideBarWidget")
+
 
 constexpr auto ALL_EVENT_ITEM_TYPE = QTreeWidgetItem::UserType;
 constexpr auto TRASH_ITEM_TYPE = QTreeWidgetItem::UserType + 1;
@@ -8,9 +20,15 @@ constexpr auto DATABASE_ITEM_TYPE = QTreeWidgetItem::UserType + 3;
 
 
 struct CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate {
+
     void configureTreeWidget(QTreeWidget *treeWidget);
     QTreeWidgetItem *addDatabaseItem(const QString &name, QTreeWidget *treeWidget);
-    void addCatalogueItem(const QString &name, QTreeWidgetItem *parentDatabaseItem);
+    QTreeWidgetItem *getDatabaseItem(const QString &name, QTreeWidget *treeWidget);
+    void addCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue,
+                          QTreeWidgetItem *parentDatabaseItem);
+
+    CatalogueTreeWidgetItem *getCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue,
+                                              QTreeWidget *treeWidget) const;
 };
 
 CatalogueSideBarWidget::CatalogueSideBarWidget(QWidget *parent)
@@ -21,25 +39,81 @@ CatalogueSideBarWidget::CatalogueSideBarWidget(QWidget *parent)
     ui->setupUi(this);
     impl->configureTreeWidget(ui->treeWidget);
 
-    auto emitSelection = [this](auto item) {
-        switch (item->type()) {
-            case CATALOGUE_ITEM_TYPE:
-                emit this->catalogueSelected(item->text(0));
-                break;
-            case ALL_EVENT_ITEM_TYPE:
-                emit this->allEventsSelected();
-                break;
-            case TRASH_ITEM_TYPE:
-                emit this->trashSelected();
-                break;
-            case DATABASE_ITEM_TYPE:
-            default:
-                break;
+    ui->treeWidget->setColumnCount(2);
+    ui->treeWidget->header()->setStretchLastSection(false);
+    ui->treeWidget->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
+    ui->treeWidget->header()->setSectionResizeMode(0, QHeaderView::Stretch);
+
+    auto emitSelection = [this]() {
+
+        auto selectedItems = ui->treeWidget->selectedItems();
+        if (selectedItems.isEmpty()) {
+            emit this->selectionCleared();
         }
+        else {
+            QVector<std::shared_ptr<DBCatalogue> > catalogues;
+            QStringList databases;
+            int selectionType = selectedItems.first()->type();
+
+            for (auto item : ui->treeWidget->selectedItems()) {
+                if (item->type() == selectionType) {
+                    switch (selectionType) {
+                        case CATALOGUE_ITEM_TYPE:
+                            catalogues.append(
+                                static_cast<CatalogueTreeWidgetItem *>(item)->catalogue());
+                            break;
+                        case DATABASE_ITEM_TYPE:
+                            selectionType = DATABASE_ITEM_TYPE;
+                            databases.append(item->text(0));
+                        case ALL_EVENT_ITEM_TYPE: // fallthrough
+                        case TRASH_ITEM_TYPE:     // fallthrough
+                        default:
+                            break;
+                    }
+                }
+                else {
+                    // Incoherent multi selection
+                    selectionType = -1;
+                    break;
+                }
+            }
+
+            switch (selectionType) {
+                case CATALOGUE_ITEM_TYPE:
+                    emit this->catalogueSelected(catalogues);
+                    break;
+                case DATABASE_ITEM_TYPE:
+                    emit this->databaseSelected(databases);
+                    break;
+                case ALL_EVENT_ITEM_TYPE:
+                    emit this->allEventsSelected();
+                    break;
+                case TRASH_ITEM_TYPE:
+                    emit this->trashSelected();
+                    break;
+                default:
+                    emit this->selectionCleared();
+                    break;
+            }
+        }
+
+
     };
 
     connect(ui->treeWidget, &QTreeWidget::itemClicked, emitSelection);
     connect(ui->treeWidget, &QTreeWidget::currentItemChanged, emitSelection);
+    connect(ui->treeWidget, &QTreeWidget::itemChanged,
+            [emitSelection, this](auto item, auto column) {
+                auto selectedItems = ui->treeWidget->selectedItems();
+                qDebug() << "ITEM CHANGED" << column;
+                if (selectedItems.contains(item) && column == 0) {
+                    emitSelection();
+                }
+            });
+
+    ui->treeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(ui->treeWidget, &QTreeWidget::customContextMenuRequested, this,
+            &CatalogueSideBarWidget::onContextMenuRequested);
 }
 
 CatalogueSideBarWidget::~CatalogueSideBarWidget()
@@ -47,36 +121,67 @@ CatalogueSideBarWidget::~CatalogueSideBarWidget()
     delete ui;
 }
 
+void CatalogueSideBarWidget::setCatalogueChanges(const std::shared_ptr<DBCatalogue> &catalogue,
+                                                 bool hasChanges)
+{
+    if (auto catalogueItem = impl->getCatalogueItem(catalogue, ui->treeWidget)) {
+        catalogueItem->setHasChanges(hasChanges);
+        catalogueItem->refresh();
+    }
+}
+
+void CatalogueSideBarWidget::onContextMenuRequested(const QPoint &pos)
+{
+    QMenu menu{this};
+
+    auto currentItem = ui->treeWidget->currentItem();
+    switch (currentItem->type()) {
+        case CATALOGUE_ITEM_TYPE:
+            menu.addAction("Rename",
+                           [this, currentItem]() { ui->treeWidget->editItem(currentItem); });
+            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->treeWidget->mapToGlobal(pos));
+    }
+}
+
 void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::configureTreeWidget(
     QTreeWidget *treeWidget)
 {
-    auto allEventsItem = new QTreeWidgetItem({"All Events"}, ALL_EVENT_ITEM_TYPE);
+    auto allEventsItem = new QTreeWidgetItem{{"All Events"}, ALL_EVENT_ITEM_TYPE};
     allEventsItem->setIcon(0, QIcon(":/icones/allEvents.png"));
     treeWidget->addTopLevelItem(allEventsItem);
 
-    auto trashItem = new QTreeWidgetItem({"Trash"}, TRASH_ITEM_TYPE);
+    auto trashItem = new QTreeWidgetItem{{"Trash"}, TRASH_ITEM_TYPE};
     trashItem->setIcon(0, QIcon(":/icones/trash.png"));
     treeWidget->addTopLevelItem(trashItem);
 
-    auto separator = new QFrame(treeWidget);
+    auto separator = new QFrame{treeWidget};
     separator->setFrameShape(QFrame::HLine);
-
-    auto separatorItem = new QTreeWidgetItem();
+    auto separatorItem = new QTreeWidgetItem{};
     separatorItem->setFlags(Qt::NoItemFlags);
     treeWidget->addTopLevelItem(separatorItem);
     treeWidget->setItemWidget(separatorItem, 0, separator);
 
-    // Test
-    auto db = addDatabaseItem("Database 1", treeWidget);
-    addCatalogueItem("Catalogue 1", db);
-    addCatalogueItem("Catalogue 2", db);
-    addCatalogueItem("Catalogue 3", db);
-    addCatalogueItem("Catalogue 4", db);
+    auto db = addDatabaseItem("Default", treeWidget);
 
-    auto db2 = addDatabaseItem("Database 2", treeWidget);
-    addCatalogueItem("Catalogue A", db2);
-    addCatalogueItem("Catalogue B", db2);
-    addCatalogueItem("Catalogue C", db2);
+    auto catalogues = sqpApp->catalogueController().getCatalogues("Default");
+    for (auto catalogue : catalogues) {
+        addCatalogueItem(catalogue, db);
+    }
 
     treeWidget->expandAll();
 }
@@ -85,17 +190,58 @@ QTreeWidgetItem *
 CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addDatabaseItem(const QString &name,
                                                                        QTreeWidget *treeWidget)
 {
-    auto databaseItem = new QTreeWidgetItem({name}, DATABASE_ITEM_TYPE);
-    databaseItem->setIcon(0, QIcon(":/icones/database.png"));
+    auto databaseItem = new QTreeWidgetItem{{name}, DATABASE_ITEM_TYPE};
+    databaseItem->setIcon(0, QIcon{":/icones/database.png"});
     treeWidget->addTopLevelItem(databaseItem);
 
     return databaseItem;
 }
 
+QTreeWidgetItem *
+CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getDatabaseItem(const QString &name,
+                                                                       QTreeWidget *treeWidget)
+{
+    for (auto i = 0; i < treeWidget->topLevelItemCount(); ++i) {
+        auto item = treeWidget->topLevelItem(i);
+        if (item->type() == DATABASE_ITEM_TYPE && item->text(0) == name) {
+            return item;
+        }
+    }
+
+    return nullptr;
+}
+
 void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addCatalogueItem(
-    const QString &name, QTreeWidgetItem *parentDatabaseItem)
+    const std::shared_ptr<DBCatalogue> &catalogue, QTreeWidgetItem *parentDatabaseItem)
 {
-    auto catalogueItem = new QTreeWidgetItem({name}, CATALOGUE_ITEM_TYPE);
-    catalogueItem->setIcon(0, QIcon(":/icones/catalogue.png"));
+    auto catalogueItem = new CatalogueTreeWidgetItem{catalogue, CATALOGUE_ITEM_TYPE};
+    catalogueItem->setIcon(0, QIcon{":/icones/catalogue.png"});
     parentDatabaseItem->addChild(catalogueItem);
 }
+
+CatalogueTreeWidgetItem *CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getCatalogueItem(
+    const std::shared_ptr<DBCatalogue> &catalogue, QTreeWidget *treeWidget) const
+{
+    for (auto i = 0; i < treeWidget->topLevelItemCount(); ++i) {
+        auto item = treeWidget->topLevelItem(i);
+        if (item->type() == DATABASE_ITEM_TYPE) {
+            for (auto j = 0; j < item->childCount(); ++j) {
+                auto childItem = item->child(j);
+                if (childItem->type() == CATALOGUE_ITEM_TYPE) {
+                    auto catalogueItem = static_cast<CatalogueTreeWidgetItem *>(childItem);
+                    if (catalogueItem->catalogue() == catalogue) {
+                        return catalogueItem;
+                    }
+                }
+                else {
+                    qCWarning(LOG_CatalogueSideBarWidget()) << "getCatalogueItem: Invalid tree "
+                                                               "structure. A database item should "
+                                                               "only contain catalogues.";
+                    Q_ASSERT(false);
+                }
+            }
+        }
+    }
+
+    return nullptr;
+}
diff --git a/gui/src/Catalogue/CatalogueTreeWidgetItem.cpp b/gui/src/Catalogue/CatalogueTreeWidgetItem.cpp
new file mode 100644
index 0000000..afa3cef
--- /dev/null
+++ b/gui/src/Catalogue/CatalogueTreeWidgetItem.cpp
@@ -0,0 +1,103 @@
+#include "Catalogue/CatalogueTreeWidgetItem.h"
+
+#include <memory>
+
+#include <DBCatalogue.h>
+#include <QBoxLayout>
+#include <QToolButton>
+
+const auto VALIDATION_BUTTON_ICON_SIZE = 12;
+
+/// Column in the tree widget where the apply and cancel buttons must appear
+const auto APPLY_CANCEL_BUTTONS_COLUMN = 1;
+
+struct CatalogueTreeWidgetItem::CatalogueTreeWidgetItemPrivate {
+
+    std::shared_ptr<DBCatalogue> m_Catalogue;
+
+    CatalogueTreeWidgetItemPrivate(std::shared_ptr<DBCatalogue> catalogue) : m_Catalogue(catalogue)
+    {
+    }
+};
+
+
+CatalogueTreeWidgetItem::CatalogueTreeWidgetItem(std::shared_ptr<DBCatalogue> catalogue, int type)
+        : QTreeWidgetItem(type),
+          impl{spimpl::make_unique_impl<CatalogueTreeWidgetItemPrivate>(catalogue)}
+{
+    setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable);
+}
+
+QVariant CatalogueTreeWidgetItem::data(int column, int role) const
+{
+    if (column == 0) {
+        switch (role) {
+            case Qt::EditRole: // fallthrough
+            case Qt::DisplayRole:
+                return impl->m_Catalogue->getName();
+            default:
+                break;
+        }
+    }
+
+    return QTreeWidgetItem::data(column, role);
+}
+
+void CatalogueTreeWidgetItem::setData(int column, int role, const QVariant &value)
+{
+    if (role == Qt::EditRole && column == 0) {
+        auto newName = value.toString();
+        if (newName != impl->m_Catalogue->getName()) {
+            setText(0, newName);
+            impl->m_Catalogue->setName(newName);
+            setHasChanges(true);
+        }
+    }
+    else {
+        QTreeWidgetItem::setData(column, role, value);
+    }
+}
+
+std::shared_ptr<DBCatalogue> CatalogueTreeWidgetItem::catalogue() const
+{
+    return impl->m_Catalogue;
+}
+
+void CatalogueTreeWidgetItem::setHasChanges(bool value)
+{
+    if (value) {
+        if (treeWidget()->itemWidget(this, APPLY_CANCEL_BUTTONS_COLUMN) == nullptr) {
+            auto widet = new QWidget{treeWidget()};
+
+            auto layout = new QHBoxLayout{widet};
+            layout->setContentsMargins(0, 0, 0, 0);
+            layout->setSpacing(0);
+
+            auto btnValid = new QToolButton{widet};
+            btnValid->setIcon(QIcon{":/icones/save"});
+            btnValid->setIconSize(QSize{VALIDATION_BUTTON_ICON_SIZE, VALIDATION_BUTTON_ICON_SIZE});
+            btnValid->setAutoRaise(true);
+            QObject::connect(btnValid, &QToolButton::clicked, [this]() { setHasChanges(false); });
+            layout->addWidget(btnValid);
+
+            auto btnDiscard = new QToolButton{widet};
+            btnDiscard->setIcon(QIcon{":/icones/discard"});
+            btnDiscard->setIconSize(
+                QSize{VALIDATION_BUTTON_ICON_SIZE, VALIDATION_BUTTON_ICON_SIZE});
+            btnDiscard->setAutoRaise(true);
+            QObject::connect(btnDiscard, &QToolButton::clicked, [this]() { setHasChanges(false); });
+            layout->addWidget(btnDiscard);
+
+            treeWidget()->setItemWidget(this, APPLY_CANCEL_BUTTONS_COLUMN, {widet});
+        }
+    }
+    else {
+        // Note: the widget is destroyed
+        treeWidget()->setItemWidget(this, APPLY_CANCEL_BUTTONS_COLUMN, nullptr);
+    }
+}
+
+void CatalogueTreeWidgetItem::refresh()
+{
+    emitDataChanged();
+}
diff --git a/gui/src/SqpApplication.cpp b/gui/src/SqpApplication.cpp
index c2c5337..d5dc264 100644
--- a/gui/src/SqpApplication.cpp
+++ b/gui/src/SqpApplication.cpp
@@ -181,6 +181,11 @@ VisualizationController &SqpApplication::visualizationController() noexcept
     return *impl->m_VisualizationController;
 }
 
+CatalogueController &SqpApplication::catalogueController() noexcept
+{
+    return *impl->m_CatalogueController;
+}
+
 DragDropGuiController &SqpApplication::dragDropGuiController() noexcept
 {
     return *impl->m_DragDropGuiController;
diff --git a/gui/src/Visualization/VisualizationTabWidget.cpp b/gui/src/Visualization/VisualizationTabWidget.cpp
index ff81937..957de0e 100644
--- a/gui/src/Visualization/VisualizationTabWidget.cpp
+++ b/gui/src/Visualization/VisualizationTabWidget.cpp
@@ -18,20 +18,6 @@ Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
 
 namespace {
 
-/// Generates a default name for a new zone, according to the number of zones already displayed in
-/// the tab
-QString defaultZoneName(const QLayout &layout)
-{
-    auto count = 0;
-    for (auto i = 0; i < layout.count(); ++i) {
-        if (dynamic_cast<VisualizationZoneWidget *>(layout.itemAt(i)->widget())) {
-            count++;
-        }
-    }
-
-    return QObject::tr("Zone %1").arg(count + 1);
-}
-
 /**
  * Applies a function to all zones of the tab represented by its layout
  * @param layout the layout that contains zones
@@ -43,13 +29,31 @@ void processZones(QLayout &layout, Fun fun)
     for (auto i = 0; i < layout.count(); ++i) {
         if (auto item = layout.itemAt(i)) {
             if (auto visualizationZoneWidget
-                = dynamic_cast<VisualizationZoneWidget *>(item->widget())) {
+                = qobject_cast<VisualizationZoneWidget *>(item->widget())) {
                 fun(*visualizationZoneWidget);
             }
         }
     }
 }
 
+/// Generates a default name for a new zone, according to the number of zones already displayed in
+/// the tab
+QString defaultZoneName(QLayout &layout)
+{
+    QSet<QString> existingNames;
+    processZones(layout,
+                 [&existingNames](auto &zoneWidget) { existingNames.insert(zoneWidget.name()); });
+
+    int zoneNum = 1;
+    QString name;
+    do {
+        name = QObject::tr("Zone ").append(QString::number(zoneNum));
+        ++zoneNum;
+    } while (existingNames.contains(name));
+
+    return name;
+}
+
 } // namespace
 
 struct VisualizationTabWidget::VisualizationTabWidgetPrivate {
@@ -118,6 +122,27 @@ void VisualizationTabWidget::insertZone(int index, VisualizationZoneWidget *zone
     ui->dragDropContainer->insertDragWidget(index, zoneWidget);
 }
 
+QStringList VisualizationTabWidget::availableZoneWidgets() const
+{
+    QStringList zones;
+    processZones(tabLayout(),
+                 [&zones](VisualizationZoneWidget &zoneWidget) { zones << zoneWidget.name(); });
+
+    return zones;
+}
+
+VisualizationZoneWidget *VisualizationTabWidget::getZoneWithName(const QString &zoneName)
+{
+    VisualizationZoneWidget *result = nullptr;
+    processZones(tabLayout(), [&zoneName, &result](VisualizationZoneWidget &zoneWidget) {
+        if (!result && zoneWidget.name() == zoneName) {
+            result = &zoneWidget;
+        }
+    });
+
+    return result;
+}
+
 VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
 {
     return createZone({variable}, -1);
diff --git a/gui/src/Visualization/VisualizationWidget.cpp b/gui/src/Visualization/VisualizationWidget.cpp
index f406a0e..0dfa151 100644
--- a/gui/src/Visualization/VisualizationWidget.cpp
+++ b/gui/src/Visualization/VisualizationWidget.cpp
@@ -119,6 +119,15 @@ VisualizationSelectionZoneManager &VisualizationWidget::selectionZoneManager() c
     return *impl->m_ZoneSelectionManager.get();
 }
 
+VisualizationTabWidget *VisualizationWidget::currentTabWidget() const
+{
+    if (auto tab = qobject_cast<VisualizationTabWidget *>(ui->tabWidget->currentWidget())) {
+        return tab;
+    }
+
+    return nullptr;
+}
+
 void VisualizationWidget::accept(IVisualizationWidgetVisitor *visitor)
 {
     if (visitor) {
diff --git a/gui/src/Visualization/VisualizationZoneWidget.cpp b/gui/src/Visualization/VisualizationZoneWidget.cpp
index 64f7413..5f967a9 100644
--- a/gui/src/Visualization/VisualizationZoneWidget.cpp
+++ b/gui/src/Visualization/VisualizationZoneWidget.cpp
@@ -27,21 +27,6 @@ Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
 
 namespace {
 
-
-/// Generates a default name for a new graph, according to the number of graphs already displayed in
-/// the zone
-QString defaultGraphName(const QLayout &layout)
-{
-    auto count = 0;
-    for (auto i = 0; i < layout.count(); ++i) {
-        if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
-            count++;
-        }
-    }
-
-    return QObject::tr("Graph %1").arg(count + 1);
-}
-
 /**
  * Applies a function to all graphs of the zone represented by its layout
  * @param layout the layout that contains graphs
@@ -60,6 +45,24 @@ void processGraphs(QLayout &layout, Fun fun)
     }
 }
 
+/// 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 {
@@ -145,6 +148,17 @@ 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
diff --git a/gui/ui/Catalogue/CatalogueEventsWidget.ui b/gui/ui/Catalogue/CatalogueEventsWidget.ui
index 171698e..af26468 100644
--- a/gui/ui/Catalogue/CatalogueEventsWidget.ui
+++ b/gui/ui/Catalogue/CatalogueEventsWidget.ui
@@ -34,7 +34,7 @@
         <string>+</string>
        </property>
        <property name="icon">
-        <iconset>
+        <iconset resource="../../resources/sqpguiresources.qrc">
          <normaloff>:/icones/add.png</normaloff>:/icones/add.png</iconset>
        </property>
        <property name="autoRaise">
@@ -48,7 +48,7 @@
         <string> - </string>
        </property>
        <property name="icon">
-        <iconset>
+        <iconset resource="../../resources/sqpguiresources.qrc">
          <normaloff>:/icones/remove.png</normaloff>:/icones/remove.png</iconset>
        </property>
        <property name="autoRaise">
@@ -69,7 +69,7 @@
         <string>T</string>
        </property>
        <property name="icon">
-        <iconset>
+        <iconset resource="../../resources/sqpguiresources.qrc">
          <normaloff>:/icones/time.png</normaloff>:/icones/time.png</iconset>
        </property>
        <property name="checkable">
@@ -86,7 +86,7 @@
         <string>G</string>
        </property>
        <property name="icon">
-        <iconset>
+        <iconset resource="../../resources/sqpguiresources.qrc">
          <normaloff>:/icones/chart.png</normaloff>:/icones/chart.png</iconset>
        </property>
        <property name="checkable">
@@ -114,26 +114,29 @@
     </layout>
    </item>
    <item>
-    <widget class="QTableWidget" name="tableWidget">
-     <property name="alternatingRowColors">
+    <widget class="QTreeView" name="treeView">
+     <property name="dragEnabled">
       <bool>true</bool>
      </property>
+     <property name="dragDropMode">
+      <enum>QAbstractItemView::DragDrop</enum>
+     </property>
+     <property name="selectionMode">
+      <enum>QAbstractItemView::ExtendedSelection</enum>
+     </property>
      <property name="selectionBehavior">
       <enum>QAbstractItemView::SelectRows</enum>
      </property>
-     <attribute name="horizontalHeaderHighlightSections">
+     <attribute name="headerStretchLastSection">
       <bool>false</bool>
      </attribute>
-     <attribute name="verticalHeaderVisible">
-      <bool>false</bool>
-     </attribute>
-     <attribute name="verticalHeaderDefaultSectionSize">
-      <number>25</number>
-     </attribute>
     </widget>
    </item>
   </layout>
  </widget>
- <resources/>
+ <resources>
+  <include location="../../resources/sqpguiresources.qrc"/>
+  <include location="../../resources/sqpguiresources.qrc"/>
+ </resources>
  <connections/>
 </ui>
diff --git a/gui/ui/Catalogue/CatalogueInspectorWidget.ui b/gui/ui/Catalogue/CatalogueInspectorWidget.ui
index 909c3e8..67c792d 100644
--- a/gui/ui/Catalogue/CatalogueInspectorWidget.ui
+++ b/gui/ui/Catalogue/CatalogueInspectorWidget.ui
@@ -53,7 +53,7 @@
       <item>
        <widget class="QStackedWidget" name="stackedWidget">
         <property name="currentIndex">
-         <number>1</number>
+         <number>2</number>
         </property>
         <widget class="QWidget" name="emptyPage"/>
         <widget class="QWidget" name="catalogueInspectorPage">
@@ -113,53 +113,20 @@
         </widget>
         <widget class="QWidget" name="eventInspectorPage">
          <layout class="QGridLayout" name="gridLayout">
-          <item row="5" column="1">
-           <widget class="QDateTimeEdit" name="dateTimeEventTEnd"/>
-          </item>
           <item row="4" column="0">
-           <widget class="QLabel" name="label_4">
-            <property name="text">
-             <string>TStart</string>
-            </property>
-           </widget>
-          </item>
-          <item row="6" column="0">
-           <widget class="QLabel" name="label_6">
-            <property name="text">
-             <string>Tags</string>
-            </property>
-           </widget>
-          </item>
-          <item row="3" column="0">
            <widget class="QLabel" name="label_3">
             <property name="text">
              <string>Product</string>
             </property>
            </widget>
           </item>
-          <item row="3" column="1">
-           <widget class="QLineEdit" name="leEventProduct"/>
-          </item>
           <item row="5" column="0">
-           <widget class="QLabel" name="label_5">
-            <property name="text">
-             <string>Tend</string>
-            </property>
-           </widget>
-          </item>
-          <item row="4" column="1">
-           <widget class="QDateTimeEdit" name="dateTimeEventTStart"/>
-          </item>
-          <item row="2" column="0">
-           <widget class="QLabel" name="label_2">
+           <widget class="QLabel" name="label_4">
             <property name="text">
-             <string>Mission</string>
+             <string>TStart</string>
             </property>
            </widget>
           </item>
-          <item row="1" column="1">
-           <widget class="QLineEdit" name="leEventName"/>
-          </item>
           <item row="1" column="0">
            <widget class="QLabel" name="label">
             <property name="text">
@@ -167,13 +134,21 @@
             </property>
            </widget>
           </item>
-          <item row="2" column="1">
-           <widget class="QLineEdit" name="leEventMission"/>
-          </item>
-          <item row="6" column="1">
-           <widget class="QLineEdit" name="leEventTags"/>
+          <item row="0" column="0" colspan="2">
+           <widget class="QLabel" name="label_10">
+            <property name="font">
+             <font>
+              <pointsize>10</pointsize>
+              <weight>75</weight>
+              <bold>true</bold>
+             </font>
+            </property>
+            <property name="text">
+             <string>Event Properties</string>
+            </property>
+           </widget>
           </item>
-          <item row="7" column="1">
+          <item row="8" column="1">
            <spacer name="verticalSpacer">
             <property name="orientation">
              <enum>Qt::Vertical</enum>
@@ -186,17 +161,47 @@
             </property>
            </spacer>
           </item>
-          <item row="0" column="0" colspan="2">
-           <widget class="QLabel" name="label_10">
-            <property name="font">
-             <font>
-              <pointsize>10</pointsize>
-              <weight>75</weight>
-              <bold>true</bold>
-             </font>
+          <item row="1" column="1">
+           <widget class="QLineEdit" name="leEventName"/>
+          </item>
+          <item row="5" column="1">
+           <widget class="QDateTimeEdit" name="dateTimeEventTStart">
+            <property name="timeSpec">
+             <enum>Qt::UTC</enum>
+            </property>
+           </widget>
+          </item>
+          <item row="4" column="1">
+           <widget class="QLineEdit" name="leEventProduct"/>
+          </item>
+          <item row="6" column="0">
+           <widget class="QLabel" name="label_5">
+            <property name="text">
+             <string>Tend</string>
             </property>
+           </widget>
+          </item>
+          <item row="6" column="1">
+           <widget class="QDateTimeEdit" name="dateTimeEventTEnd">
+            <property name="timeSpec">
+             <enum>Qt::UTC</enum>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="1">
+           <widget class="QLineEdit" name="leEventTags"/>
+          </item>
+          <item row="2" column="0">
+           <widget class="QLabel" name="label_6">
             <property name="text">
-             <string>Event Properties</string>
+             <string>Tags</string>
+            </property>
+           </widget>
+          </item>
+          <item row="3" column="0" colspan="2">
+           <widget class="Line" name="line">
+            <property name="orientation">
+             <enum>Qt::Horizontal</enum>
             </property>
            </widget>
           </item>
diff --git a/gui/ui/Catalogue/CatalogueSideBarWidget.ui b/gui/ui/Catalogue/CatalogueSideBarWidget.ui
index ca3e22d..34e03a1 100644
--- a/gui/ui/Catalogue/CatalogueSideBarWidget.ui
+++ b/gui/ui/Catalogue/CatalogueSideBarWidget.ui
@@ -34,7 +34,7 @@
         <string>+</string>
        </property>
        <property name="icon">
-        <iconset>
+        <iconset resource="../../resources/sqpguiresources.qrc">
          <normaloff>:/icones/add.png</normaloff>:/icones/add.png</iconset>
        </property>
        <property name="autoRaise">
@@ -48,7 +48,7 @@
         <string> - </string>
        </property>
        <property name="icon">
-        <iconset>
+        <iconset resource="../../resources/sqpguiresources.qrc">
          <normaloff>:/icones/remove.png</normaloff>:/icones/remove.png</iconset>
        </property>
        <property name="autoRaise">
@@ -73,6 +73,9 @@
    </item>
    <item>
     <widget class="QTreeWidget" name="treeWidget">
+     <property name="selectionMode">
+      <enum>QAbstractItemView::ExtendedSelection</enum>
+     </property>
      <attribute name="headerVisible">
       <bool>false</bool>
      </attribute>
@@ -85,6 +88,9 @@
    </item>
   </layout>
  </widget>
- <resources/>
+ <resources>
+  <include location="../../resources/sqpguiresources.qrc"/>
+  <include location="../../resources/sqpguiresources.qrc"/>
+ </resources>
  <connections/>
 </ui>