diff --git a/gui/include/Catalogue/CatalogueEventsTableModel.h b/gui/include/Catalogue/CatalogueEventsModel.h
similarity index 53%
rename from gui/include/Catalogue/CatalogueEventsTableModel.h
rename to gui/include/Catalogue/CatalogueEventsModel.h
index 9bab0a7..bc0bd70 100644
--- a/gui/include/Catalogue/CatalogueEventsTableModel.h
+++ b/gui/include/Catalogue/CatalogueEventsModel.h
@@ -1,22 +1,31 @@
-#ifndef SCIQLOP_CATALOGUEEVENTSTABLEMODEL_H
-#define SCIQLOP_CATALOGUEEVENTSTABLEMODEL_H
+#ifndef SCIQLOP_CATALOGUEEVENTSMODEL_H
+#define SCIQLOP_CATALOGUEEVENTSMODEL_H
 
 #include <Common/spimpl.h>
-#include <QAbstractTableModel>
+#include <QAbstractItemModel>
 
 class DBEvent;
+class DBEventProduct;
 
-class CatalogueEventsTableModel : public QAbstractTableModel {
+class CatalogueEventsModel : public QAbstractItemModel {
 public:
-    CatalogueEventsTableModel(QObject *parent = nullptr);
+    CatalogueEventsModel(QObject *parent = nullptr);
 
     void setEvents(const QVector<std::shared_ptr<DBEvent> > &events);
-    std::shared_ptr<DBEvent> getEvent(int row) const;
+    void addEvent(const std::shared_ptr<DBEvent> &event);
+    void removeEvent(const std::shared_ptr<DBEvent> &event);
 
-    void addEvent(const std::shared_ptr<DBEvent> &events);
-    void removeEvent(const std::shared_ptr<DBEvent> &events);
+    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;
@@ -29,10 +38,9 @@ public:
     QStringList mimeTypes() const override;
     QMimeData *mimeData(const QModelIndexList &indexes) const override;
 
-
 private:
-    class CatalogueEventsTableModelPrivate;
-    spimpl::unique_impl_ptr<CatalogueEventsTableModelPrivate> impl;
+    class CatalogueEventsModelPrivate;
+    spimpl::unique_impl_ptr<CatalogueEventsModelPrivate> impl;
 };
 
-#endif // SCIQLOP_CATALOGUEEVENTSTABLEMODEL_H
+#endif // SCIQLOP_CATALOGUEEVENTSMODEL_H
diff --git a/gui/include/Catalogue/CatalogueEventsWidget.h b/gui/include/Catalogue/CatalogueEventsWidget.h
index 04fa2af..e7ce270 100644
--- a/gui/include/Catalogue/CatalogueEventsWidget.h
+++ b/gui/include/Catalogue/CatalogueEventsWidget.h
@@ -7,6 +7,7 @@
 
 class DBCatalogue;
 class DBEvent;
+class DBEventProduct;
 class VisualizationWidget;
 
 namespace Ui {
@@ -20,6 +21,10 @@ class CatalogueEventsWidget : public QWidget {
 
 signals:
     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);
@@ -27,6 +32,8 @@ public:
 
     void setVisualizationWidget(VisualizationWidget *visualization);
 
+    void setEventChanges(const std::shared_ptr<DBEvent> &event, bool hasChanges);
+
 public slots:
     void populateWithCatalogues(const QVector<std::shared_ptr<DBCatalogue> > &catalogues);
 
diff --git a/gui/include/Catalogue/CatalogueInspectorWidget.h b/gui/include/Catalogue/CatalogueInspectorWidget.h
index c049a81..51c42b9 100644
--- a/gui/include/Catalogue/CatalogueInspectorWidget.h
+++ b/gui/include/Catalogue/CatalogueInspectorWidget.h
@@ -1,6 +1,7 @@
 #ifndef SCIQLOP_CATALOGUEINSPECTORWIDGET_H
 #define SCIQLOP_CATALOGUEINSPECTORWIDGET_H
 
+#include <Common/spimpl.h>
 #include <QWidget>
 #include <memory>
 
@@ -10,10 +11,17 @@ 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();
@@ -24,6 +32,8 @@ public:
     Page currentPage() const;
 
     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:
@@ -31,6 +41,9 @@ public slots:
 
 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 f762c3b..0af2b26 100644
--- a/gui/include/Catalogue/CatalogueSideBarWidget.h
+++ b/gui/include/Catalogue/CatalogueSideBarWidget.h
@@ -2,6 +2,7 @@
 #define SCIQLOP_CATALOGUESIDEBARWIDGET_H
 
 #include <Common/spimpl.h>
+#include <QLoggingCategory>
 #include <QTreeWidgetItem>
 #include <QWidget>
 
@@ -11,6 +12,8 @@ namespace Ui {
 class CatalogueSideBarWidget;
 }
 
+Q_DECLARE_LOGGING_CATEGORY(LOG_CatalogueSideBarWidget)
+
 class CatalogueSideBarWidget : public QWidget {
     Q_OBJECT
 
@@ -25,6 +28,8 @@ public:
     explicit CatalogueSideBarWidget(QWidget *parent = 0);
     virtual ~CatalogueSideBarWidget();
 
+    void setCatalogueChanges(const std::shared_ptr<DBCatalogue> &catalogue, bool hasChanges);
+
 private:
     Ui::CatalogueSideBarWidget *ui;
 
diff --git a/gui/include/Catalogue/CatalogueTreeWidgetItem.h b/gui/include/Catalogue/CatalogueTreeWidgetItem.h
index 60ea055..a8b4f14 100644
--- a/gui/include/Catalogue/CatalogueTreeWidgetItem.h
+++ b/gui/include/Catalogue/CatalogueTreeWidgetItem.h
@@ -18,8 +18,13 @@ public:
     /// 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;
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/meson.build b/gui/meson.build
index f7bf8af..727fa0d 100644
--- a/gui/meson.build
+++ b/gui/meson.build
@@ -108,7 +108,7 @@ gui_sources = [
   'src/Catalogue/CatalogueSideBarWidget.cpp',
   'src/Catalogue/CatalogueInspectorWidget.cpp',
   'src/Catalogue/CatalogueTreeWidgetItem.cpp',
-  'src/Catalogue/CatalogueEventsTableModel.cpp'
+  'src/Catalogue/CatalogueEventsModel.cpp'
 ]
 
 gui_inc = include_directories(['include'])
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/CatalogueEventsTableModel.cpp b/gui/src/Catalogue/CatalogueEventsTableModel.cpp
deleted file mode 100644
index 54994b7..0000000
--- a/gui/src/Catalogue/CatalogueEventsTableModel.cpp
+++ /dev/null
@@ -1,185 +0,0 @@
-#include "Catalogue/CatalogueEventsTableModel.h"
-
-#include <Common/DateUtils.h>
-#include <Common/MimeTypesDef.h>
-#include <DBEvent.h>
-#include <DBTag.h>
-#include <Data/SqpRange.h>
-#include <QMimeData>
-#include <SqpApplication.h>
-#include <Time/TimeController.h>
-
-struct CatalogueEventsTableModel::CatalogueEventsTableModelPrivate {
-    QVector<std::shared_ptr<DBEvent> > m_Events;
-
-    enum class Column { Event, 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::Event:
-                return event->getName();
-            case Column::TStart:
-                return DateUtils::dateTime(event->getTStart());
-            case Column::TEnd:
-                return DateUtils::dateTime(event->getTEnd());
-            case Column::Product:
-                return event->getProduct();
-            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");
-    }
-};
-
-CatalogueEventsTableModel::CatalogueEventsTableModel(QObject *parent)
-        : QAbstractTableModel(parent),
-          impl{spimpl::make_unique_impl<CatalogueEventsTableModelPrivate>()}
-{
-}
-
-void CatalogueEventsTableModel::setEvents(const QVector<std::shared_ptr<DBEvent> > &events)
-{
-    beginResetModel();
-    impl->m_Events = events;
-    endResetModel();
-}
-
-std::shared_ptr<DBEvent> CatalogueEventsTableModel::getEvent(int row) const
-{
-    return impl->m_Events.value(row);
-}
-
-void CatalogueEventsTableModel::addEvent(const std::shared_ptr<DBEvent> &events)
-{
-    beginInsertRows(QModelIndex(), impl->m_Events.count() - 1, impl->m_Events.count() - 1);
-    // impl->m_Events.append(event); TODO
-    endInsertRows();
-}
-
-void CatalogueEventsTableModel::removeEvent(const std::shared_ptr<DBEvent> &events)
-{
-    // TODO
-    auto index = -1; // impl->m_Events.indexOf(event);
-    if (index >= 0) {
-        beginRemoveRows(QModelIndex(), index, index);
-        impl->m_Events.removeAt(index);
-        endRemoveRows();
-    }
-}
-
-int CatalogueEventsTableModel::rowCount(const QModelIndex &parent) const
-{
-    int r = impl->m_Events.count();
-    return r;
-}
-
-int CatalogueEventsTableModel::columnCount(const QModelIndex &parent) const
-{
-    int c = static_cast<int>(CatalogueEventsTableModelPrivate::Column::NbColumn);
-    return c;
-}
-
-Qt::ItemFlags CatalogueEventsTableModel::flags(const QModelIndex &index) const
-{
-    return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
-}
-
-QVariant CatalogueEventsTableModel::data(const QModelIndex &index, int role) const
-{
-    if (index.isValid()) {
-        auto event = getEvent(index.row());
-
-        switch (role) {
-            case Qt::DisplayRole:
-                return impl->eventData(index.column(), event);
-                break;
-        }
-    }
-
-    return QVariant{};
-}
-
-QVariant CatalogueEventsTableModel::headerData(int section, Qt::Orientation orientation,
-                                               int role) const
-{
-    if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
-        return impl->columnNames().value(section);
-    }
-
-    return QVariant();
-}
-
-void CatalogueEventsTableModel::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 CatalogueEventsTableModel::supportedDragActions() const
-{
-    return Qt::CopyAction | Qt::MoveAction;
-}
-
-QStringList CatalogueEventsTableModel::mimeTypes() const
-{
-    return {MIME_TYPE_EVENT_LIST, MIME_TYPE_TIME_RANGE};
-}
-
-QMimeData *CatalogueEventsTableModel::mimeData(const QModelIndexList &indexes) const
-{
-    auto mimeData = new QMimeData;
-
-    QVector<std::shared_ptr<DBEvent> > eventList;
-
-    SqpRange firstTimeRange;
-    for (const auto &index : indexes) {
-        if (index.column() == 0) { // only the first column
-            auto event = getEvent(index.row());
-            if (eventList.isEmpty()) {
-                // Gets the range of the first variable
-                firstTimeRange.m_TStart = event->getTStart();
-                firstTimeRange.m_TEnd = event->getTEnd();
-            }
-
-            eventList << event;
-        }
-    }
-
-    auto eventsEncodedData
-        = QByteArray{}; // sqpApp->catalogueController().->mimeDataForEvents(eventList); //TODO
-    mimeData->setData(MIME_TYPE_EVENT_LIST, eventsEncodedData);
-
-    if (eventList.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;
-}
diff --git a/gui/src/Catalogue/CatalogueEventsWidget.cpp b/gui/src/Catalogue/CatalogueEventsWidget.cpp
index 82cf681..410d933 100644
--- a/gui/src/Catalogue/CatalogueEventsWidget.cpp
+++ b/gui/src/Catalogue/CatalogueEventsWidget.cpp
@@ -2,7 +2,7 @@
 #include "ui_CatalogueEventsWidget.h"
 
 #include <Catalogue/CatalogueController.h>
-#include <Catalogue/CatalogueEventsTableModel.h>
+#include <Catalogue/CatalogueEventsModel.h>
 #include <CatalogueDao.h>
 #include <DBCatalogue.h>
 #include <SqpApplication.h>
@@ -21,31 +21,31 @@ const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss");
 
 struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
 
-    CatalogueEventsTableModel *m_Model = nullptr;
+    CatalogueEventsModel *m_Model = nullptr;
     QStringList m_ZonesForTimeMode;
     QString m_ZoneForGraphMode;
 
     VisualizationWidget *m_VisualizationWidget = nullptr;
 
-    void setEvents(const QVector<std::shared_ptr<DBEvent> > &events, QTableView *tableView)
+    void setEvents(const QVector<std::shared_ptr<DBEvent> > &events, QTreeView *treeView)
     {
-        tableView->setSortingEnabled(false);
+        treeView->setSortingEnabled(false);
         m_Model->setEvents(events);
-        tableView->setSortingEnabled(true);
+        treeView->setSortingEnabled(true);
     }
 
-    void addEvent(const std::shared_ptr<DBEvent> &event, QTableView *tableView)
+    void addEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
     {
-        tableView->setSortingEnabled(false);
+        treeView->setSortingEnabled(false);
         m_Model->addEvent(event);
-        tableView->setSortingEnabled(true);
+        treeView->setSortingEnabled(true);
     }
 
-    void removeEvent(const std::shared_ptr<DBEvent> &event, QTableView *tableView)
+    void removeEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
     {
-        tableView->setSortingEnabled(false);
+        treeView->setSortingEnabled(false);
         m_Model->removeEvent(event);
-        tableView->setSortingEnabled(true);
+        treeView->setSortingEnabled(true);
     }
 
     QStringList getAvailableVisualizationZoneList() const
@@ -131,33 +131,35 @@ struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
         return result;
     }
 
-    void updateForTimeMode(QTableView *tableView)
+    void updateForTimeMode(QTreeView *treeView)
     {
-        auto selectedRows = tableView->selectionModel()->selectedRows();
+        auto selectedRows = treeView->selectionModel()->selectedRows();
 
         if (selectedRows.count() == 1) {
-            auto event = m_Model->getEvent(selectedRows.first().row());
-            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);
+            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: no tab found in the visualization";
+                        << "updateTimeZone: visualization widget not found";
                 }
             }
-            else {
-                qCWarning(LOG_CatalogueEventsWidget())
-                    << "updateTimeZone: visualization widget not found";
-            }
         }
         else {
             qCWarning(LOG_CatalogueEventsWidget())
@@ -165,12 +167,12 @@ struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
         }
     }
 
-    void updateForGraphMode(QTableView *tableView)
+    void updateForGraphMode(QTreeView *treeView)
     {
-        auto selectedRows = tableView->selectionModel()->selectedRows();
+        auto selectedRows = treeView->selectionModel()->selectedRows();
 
         if (selectedRows.count() == 1) {
-            auto event = m_Model->getEvent(selectedRows.first().row());
+            auto event = m_Model->getEvent(selectedRows.first());
             if (m_VisualizationWidget) {
                 if (auto tab = m_VisualizationWidget->currentTabWidget()) {
                     if (auto zone = tab->getZoneWithName(m_ZoneForGraphMode)) {
@@ -201,12 +203,12 @@ CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
 {
     ui->setupUi(this);
 
-    impl->m_Model = new CatalogueEventsTableModel{this};
-    ui->tableView->setModel(impl->m_Model);
+    impl->m_Model = new CatalogueEventsModel{this};
+    ui->treeView->setModel(impl->m_Model);
 
-    ui->tableView->setSortingEnabled(true);
-    ui->tableView->setDragDropMode(QAbstractItemView::DragDrop);
-    ui->tableView->setDragEnabled(true);
+    ui->treeView->setSortingEnabled(true);
+    ui->treeView->setDragDropMode(QAbstractItemView::DragDrop);
+    ui->treeView->setDragEnabled(true);
 
     connect(ui->btnTime, &QToolButton::clicked, [this](auto checked) {
         if (checked) {
@@ -215,7 +217,7 @@ CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
                 = impl->selectZone(this, impl->m_ZonesForTimeMode, true,
                                    this->mapToGlobal(ui->btnTime->frameGeometry().center()));
 
-            impl->updateForTimeMode(ui->tableView);
+            impl->updateForTimeMode(ui->treeView);
         }
     });
 
@@ -227,38 +229,56 @@ CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
                                    this->mapToGlobal(ui->btnChart->frameGeometry().center()))
                       .value(0);
 
-            impl->updateForGraphMode(ui->tableView);
+            impl->updateForGraphMode(ui->treeView);
         }
     });
 
     auto emitSelection = [this]() {
         QVector<std::shared_ptr<DBEvent> > events;
-        for (auto rowIndex : ui->tableView->selectionModel()->selectedRows()) {
-            events << impl->m_Model->getEvent(rowIndex.row());
+        QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
+
+        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));
+            }
         }
 
-        emit this->eventsSelected(events);
+        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->tableView, &QTableView::clicked, emitSelection);
-    connect(ui->tableView->selectionModel(), &QItemSelectionModel::selectionChanged, emitSelection);
+    connect(ui->treeView, &QTreeView::clicked, emitSelection);
+    connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, emitSelection);
 
-    connect(ui->tableView->selectionModel(), &QItemSelectionModel::selectionChanged, [this]() {
-        auto isNotMultiSelection = ui->tableView->selectionModel()->selectedRows().count() <= 1;
+    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->tableView);
+            impl->updateForTimeMode(ui->treeView);
         }
         else if (isNotMultiSelection && ui->btnChart->isChecked()) {
-            impl->updateForGraphMode(ui->tableView);
+            impl->updateForGraphMode(ui->treeView);
         }
     });
 
-    ui->tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
-    ui->tableView->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
-    ui->tableView->horizontalHeader()->setSortIndicatorShown(true);
+    ui->treeView->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
+    ui->treeView->header()->setSectionResizeMode(0, QHeaderView::Stretch);
+    ui->treeView->header()->setSortIndicatorShown(true);
 }
 
 CatalogueEventsWidget::~CatalogueEventsWidget()
@@ -271,6 +291,11 @@ void CatalogueEventsWidget::setVisualizationWidget(VisualizationWidget *visualiz
     impl->m_VisualizationWidget = visualization;
 }
 
+void CatalogueEventsWidget::setEventChanges(const std::shared_ptr<DBEvent> &event, bool hasChanges)
+{
+    impl->m_Model->refreshEvent(event);
+}
+
 void CatalogueEventsWidget::populateWithCatalogues(
     const QVector<std::shared_ptr<DBCatalogue> > &catalogues)
 {
@@ -287,5 +312,5 @@ void CatalogueEventsWidget::populateWithCatalogues(
         }
     }
 
-    impl->setEvents(events, ui->tableView);
+    impl->setEvents(events, ui->treeView);
 }
diff --git a/gui/src/Catalogue/CatalogueExplorer.cpp b/gui/src/Catalogue/CatalogueExplorer.cpp
index 43c1b1c..b0d99d7 100644
--- a/gui/src/Catalogue/CatalogueExplorer.cpp
+++ b/gui/src/Catalogue/CatalogueExplorer.cpp
@@ -48,6 +48,28 @@ CatalogueExplorer::CatalogueExplorer(QWidget *parent)
             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()
diff --git a/gui/src/Catalogue/CatalogueInspectorWidget.cpp b/gui/src/Catalogue/CatalogueInspectorWidget.cpp
index e605cc8..a51f4a7 100644
--- a/gui/src/Catalogue/CatalogueInspectorWidget.cpp
+++ b/gui/src/Catalogue/CatalogueInspectorWidget.cpp
@@ -4,13 +4,30 @@
 #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()
@@ -18,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));
@@ -30,27 +112,70 @@ CatalogueInspectorWidget::Page CatalogueInspectorWidget::currentPage() const
 
 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->leEventMission->setText(event->getMission());
-    ui->leEventProduct->setText(event->getProduct());
+    ui->leEventProduct->setEnabled(false);
+    ui->leEventProduct->setText(
+        QString::number(event->getEventProducts().size()).append(" product(s)"));
 
     QString tagList;
-    auto tags = event->getTags();
+    auto tags = event->getTagsNames();
     for (auto tag : tags) {
-        tagList += tag.getName();
+        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->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 std::shared_ptr<DBCatalogue> &catalogue)
 {
+    impl->m_DisplayedCatalogue = catalogue;
+
+    blockSignals(true);
+
     showPage(Page::CatalogueProperties);
     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 4951da3..97850e5 100644
--- a/gui/src/Catalogue/CatalogueSideBarWidget.cpp
+++ b/gui/src/Catalogue/CatalogueSideBarWidget.cpp
@@ -10,6 +10,8 @@
 
 #include <QMenu>
 
+Q_LOGGING_CATEGORY(LOG_CatalogueSideBarWidget, "CatalogueSideBarWidget")
+
 
 constexpr auto ALL_EVENT_ITEM_TYPE = QTreeWidgetItem::UserType;
 constexpr auto TRASH_ITEM_TYPE = QTreeWidgetItem::UserType + 1;
@@ -24,6 +26,9 @@ struct CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate {
     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)
@@ -97,6 +102,14 @@ CatalogueSideBarWidget::CatalogueSideBarWidget(QWidget *parent)
 
     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,
@@ -108,6 +121,15 @@ 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};
@@ -196,3 +218,30 @@ void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addCatalogueItem(
     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
index ac2a607..afa3cef 100644
--- a/gui/src/Catalogue/CatalogueTreeWidgetItem.cpp
+++ b/gui/src/Catalogue/CatalogueTreeWidgetItem.cpp
@@ -8,6 +8,9 @@
 
 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;
@@ -63,31 +66,38 @@ std::shared_ptr<DBCatalogue> CatalogueTreeWidgetItem::catalogue() const
 void CatalogueTreeWidgetItem::setHasChanges(bool value)
 {
     if (value) {
-        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, 1, {widet});
-        treeWidget()->resizeColumnToContents(1);
+        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, 1, nullptr);
+        treeWidget()->setItemWidget(this, APPLY_CANCEL_BUTTONS_COLUMN, nullptr);
     }
 }
+
+void CatalogueTreeWidgetItem::refresh()
+{
+    emitDataChanged();
+}
diff --git a/gui/ui/Catalogue/CatalogueEventsWidget.ui b/gui/ui/Catalogue/CatalogueEventsWidget.ui
index 8802263..af26468 100644
--- a/gui/ui/Catalogue/CatalogueEventsWidget.ui
+++ b/gui/ui/Catalogue/CatalogueEventsWidget.ui
@@ -114,32 +114,20 @@
     </layout>
    </item>
    <item>
-    <widget class="QTableView" name="tableView">
+    <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="horizontalHeaderVisible">
-      <bool>true</bool>
-     </attribute>
-     <attribute name="horizontalHeaderHighlightSections">
-      <bool>false</bool>
-     </attribute>
-     <attribute name="horizontalHeaderShowSortIndicator" stdset="0">
-      <bool>true</bool>
-     </attribute>
-     <attribute name="verticalHeaderVisible">
-      <bool>false</bool>
-     </attribute>
-     <attribute name="verticalHeaderDefaultSectionSize">
-      <number>25</number>
-     </attribute>
-     <attribute name="verticalHeaderHighlightSections">
+     <attribute name="headerStretchLastSection">
       <bool>false</bool>
      </attribute>
     </widget>
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>