From c352dc0e2afa14eb5a6284c23d6d12c97a3befa4 2017-12-14 16:34:35
From: Thibaud Rabillard <trabillard@itlink.fr>
Date: 2017-12-14 16:34:35
Subject: [PATCH] Change the event model to a treeview model + update the last version of CatalogueAPI

---

diff --git a/gui/include/Catalogue/CatalogueEventsTableModel.h b/gui/include/Catalogue/CatalogueEventsModel.h
similarity index 76%
rename from gui/include/Catalogue/CatalogueEventsTableModel.h
rename to gui/include/Catalogue/CatalogueEventsModel.h
index 31ce383..1b44d79 100644
--- a/gui/include/Catalogue/CatalogueEventsTableModel.h
+++ b/gui/include/Catalogue/CatalogueEventsModel.h
@@ -1,24 +1,27 @@
-#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 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 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;
@@ -31,10 +34,9 @@ public:
     QStringList mimeTypes() const override;
     QMimeData *mimeData(const QModelIndexList &indexes) const override;
 
-
 private:
     class CatalogueEventsTableModelPrivate;
     spimpl::unique_impl_ptr<CatalogueEventsTableModelPrivate> impl;
 };
 
-#endif // SCIQLOP_CATALOGUEEVENTSTABLEMODEL_H
+#endif // SCIQLOP_CATALOGUEEVENTSMODEL_H
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/CatalogueEventsTableModel.cpp b/gui/src/Catalogue/CatalogueEventsModel.cpp
similarity index 50%
rename from gui/src/Catalogue/CatalogueEventsTableModel.cpp
rename to gui/src/Catalogue/CatalogueEventsModel.cpp
index c7c1b11..173f4e8 100644
--- a/gui/src/Catalogue/CatalogueEventsTableModel.cpp
+++ b/gui/src/Catalogue/CatalogueEventsModel.cpp
@@ -1,18 +1,28 @@
-#include "Catalogue/CatalogueEventsTableModel.h"
+#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 <QMimeData>
 #include <SqpApplication.h>
 #include <Time/TimeController.h>
 
-struct CatalogueEventsTableModel::CatalogueEventsTableModelPrivate {
+#include <list>
+#include <unordered_map>
+
+#include <QHash>
+#include <QMimeData>
+
+const auto EVENT_ITEM_TYPE = 1;
+const auto EVENT_PRODUCT_ITEM_TYPE = 2;
+
+struct CatalogueEventsModel::CatalogueEventsTableModelPrivate {
     QVector<std::shared_ptr<DBEvent> > m_Events;
+    std::unordered_map<DBEvent *, QVector<std::shared_ptr<DBEventProduct> > > m_EventProducts;
 
-    enum class Column { Event, TStart, TEnd, Tags, Product, NbColumn };
+    enum class Column { Name, TStart, TEnd, Tags, Product, NbColumn };
     QStringList columnNames()
     {
         return QStringList{tr("Event"), tr("TStart"), tr("TEnd"), tr("Tags"), tr("Product")};
@@ -21,14 +31,21 @@ struct CatalogueEventsTableModel::CatalogueEventsTableModelPrivate {
     QVariant eventData(int col, const std::shared_ptr<DBEvent> &event) const
     {
         switch (static_cast<Column>(col)) {
-            case Column::Event:
+            case Column::Name:
                 return event->getName();
             case Column::TStart:
-                return DateUtils::dateTime(event->getTStart());
+                return "Oo"; // DateUtils::dateTime(event->getTStart());
             case Column::TEnd:
-                return DateUtils::dateTime(event->getTEnd());
-            case Column::Product:
-                return event->getProduct();
+                return "oO"; // 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();
@@ -46,44 +63,101 @@ struct CatalogueEventsTableModel::CatalogueEventsTableModelPrivate {
         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");
+    }
+
+    enum class ItemType { Root, Event, EventProduct };
+    ItemType indexItemType(const QModelIndex &index) const
+    {
+
+        if (!index.isValid()) {
+            return ItemType::Root;
+        }
+        else if (index.internalPointer() == nullptr) {
+            return ItemType::Event;
+        }
+        else {
+            return ItemType::EventProduct;
+        }
+    }
+
+    std::shared_ptr<DBEventProduct> getEventProduct(const QModelIndex &index)
+    {
+        auto event = static_cast<DBEvent *>(index.internalPointer());
+        return m_EventProducts.at(event).value(index.row());
+    }
 };
 
-CatalogueEventsTableModel::CatalogueEventsTableModel(QObject *parent)
-        : QAbstractTableModel(parent),
+CatalogueEventsModel::CatalogueEventsModel(QObject *parent)
+        : QAbstractItemModel(parent),
           impl{spimpl::make_unique_impl<CatalogueEventsTableModelPrivate>()}
 {
 }
 
-void CatalogueEventsTableModel::setEvents(const QVector<std::shared_ptr<DBEvent> > &events)
+void CatalogueEventsModel::setEvents(const QVector<std::shared_ptr<DBEvent> > &events)
 {
     beginResetModel();
+
     impl->m_Events = events;
+    for (auto event : events) {
+        impl->parseEventProduct(event);
+    }
+
     endResetModel();
 }
 
-std::shared_ptr<DBEvent> CatalogueEventsTableModel::getEvent(int row) const
+std::shared_ptr<DBEvent> CatalogueEventsModel::getEvent(int row) const
 {
     return impl->m_Events.value(row);
 }
 
-void CatalogueEventsTableModel::addEvent(const std::shared_ptr<DBEvent> &event)
+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 CatalogueEventsTableModel::removeEvent(const std::shared_ptr<DBEvent> &event)
+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 CatalogueEventsTableModel::refreshEvent(const std::shared_ptr<DBEvent> &event)
+void CatalogueEventsModel::refreshEvent(const std::shared_ptr<DBEvent> &event)
 {
     auto eventIndex = impl->m_Events.indexOf(event);
     if (eventIndex >= 0) {
@@ -91,39 +165,114 @@ void CatalogueEventsTableModel::refreshEvent(const std::shared_ptr<DBEvent> &eve
     }
 }
 
-int CatalogueEventsTableModel::rowCount(const QModelIndex &parent) const
+QModelIndex CatalogueEventsModel::index(int row, int column, const QModelIndex &parent) const
 {
-    int r = impl->m_Events.count();
-    return r;
+    if (!hasIndex(row, column, parent)) {
+        return QModelIndex();
+    }
+
+    switch (impl->indexItemType(parent)) {
+        case CatalogueEventsTableModelPrivate::ItemType::Root:
+            return createIndex(row, column);
+        case CatalogueEventsTableModelPrivate::ItemType::Event: {
+            auto event = getEvent(parent.row());
+            return createIndex(row, column, event.get());
+        }
+        case CatalogueEventsTableModelPrivate::ItemType::EventProduct:
+            break;
+        default:
+            break;
+    }
+
+    return QModelIndex();
 }
 
-int CatalogueEventsTableModel::columnCount(const QModelIndex &parent) const
+QModelIndex CatalogueEventsModel::parent(const QModelIndex &index) const
+{
+    switch (impl->indexItemType(index)) {
+        case CatalogueEventsTableModelPrivate::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 CatalogueEventsTableModelPrivate::ItemType::Root:
+            break;
+        case CatalogueEventsTableModelPrivate::ItemType::Event:
+            break;
+        default:
+            break;
+    }
+
+    return QModelIndex();
+}
+
+int CatalogueEventsModel::rowCount(const QModelIndex &parent) const
+{
+    if (parent.column() > 0) {
+        return 0;
+    }
+
+    switch (impl->indexItemType(parent)) {
+        case CatalogueEventsTableModelPrivate::ItemType::Root:
+            return impl->m_Events.count();
+        case CatalogueEventsTableModelPrivate::ItemType::Event: {
+            auto event = getEvent(parent.row());
+            return impl->m_EventProducts[event.get()].count();
+        }
+        case CatalogueEventsTableModelPrivate::ItemType::EventProduct:
+            break;
+        default:
+            break;
+    }
+
+    return 0;
+}
+
+int CatalogueEventsModel::columnCount(const QModelIndex &parent) const
 {
     return static_cast<int>(CatalogueEventsTableModelPrivate::Column::NbColumn);
 }
 
-Qt::ItemFlags CatalogueEventsTableModel::flags(const QModelIndex &index) const
+Qt::ItemFlags CatalogueEventsModel::flags(const QModelIndex &index) const
 {
     return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
 }
 
-QVariant CatalogueEventsTableModel::data(const QModelIndex &index, int role) const
+QVariant CatalogueEventsModel::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;
+        auto type = impl->indexItemType(index);
+        if (type == CatalogueEventsTableModelPrivate::ItemType::Event) {
+            auto event = getEvent(index.row());
+            switch (role) {
+                case Qt::DisplayRole:
+                    return impl->eventData(index.column(), event);
+                    break;
+            }
+        }
+        else if (type == CatalogueEventsTableModelPrivate::ItemType::EventProduct) {
+            auto product = impl->getEventProduct(index);
+            switch (role) {
+                case Qt::DisplayRole:
+                    return impl->eventProductData(index.column(), product);
+                    break;
+            }
         }
     }
 
     return QVariant{};
 }
 
-QVariant CatalogueEventsTableModel::headerData(int section, Qt::Orientation orientation,
-                                               int role) const
+QVariant CatalogueEventsModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
         return impl->columnNames().value(section);
@@ -132,7 +281,7 @@ QVariant CatalogueEventsTableModel::headerData(int section, Qt::Orientation orie
     return QVariant();
 }
 
-void CatalogueEventsTableModel::sort(int column, Qt::SortOrder order)
+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) {
@@ -147,17 +296,17 @@ void CatalogueEventsTableModel::sort(int column, Qt::SortOrder order)
     emit dataChanged(QModelIndex(), QModelIndex());
 }
 
-Qt::DropActions CatalogueEventsTableModel::supportedDragActions() const
+Qt::DropActions CatalogueEventsModel::supportedDragActions() const
 {
     return Qt::CopyAction | Qt::MoveAction;
 }
 
-QStringList CatalogueEventsTableModel::mimeTypes() const
+QStringList CatalogueEventsModel::mimeTypes() const
 {
     return {MIME_TYPE_EVENT_LIST, MIME_TYPE_TIME_RANGE};
 }
 
-QMimeData *CatalogueEventsTableModel::mimeData(const QModelIndexList &indexes) const
+QMimeData *CatalogueEventsModel::mimeData(const QModelIndexList &indexes) const
 {
     auto mimeData = new QMimeData;
 
@@ -169,8 +318,8 @@ QMimeData *CatalogueEventsTableModel::mimeData(const QModelIndexList &indexes) c
             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();
+                // firstTimeRange.m_TStart = event->getTStart();
+                // firstTimeRange.m_TEnd = event->getTEnd();
             }
 
             eventList << event;
diff --git a/gui/src/Catalogue/CatalogueEventsWidget.cpp b/gui/src/Catalogue/CatalogueEventsWidget.cpp
index b9c1252..d0165b8 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,9 +131,9 @@ 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());
@@ -143,8 +143,8 @@ struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
                     for (auto zoneName : m_ZonesForTimeMode) {
                         if (auto zone = tab->getZoneWithName(zoneName)) {
                             SqpRange eventRange;
-                            eventRange.m_TStart = event->getTStart();
-                            eventRange.m_TEnd = event->getTEnd();
+                            // eventRange.m_TStart = event->getTStart();
+                            // eventRange.m_TEnd = event->getTEnd();
                             zone->setZoneRange(eventRange);
                         }
                     }
@@ -165,9 +165,9 @@ 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());
@@ -201,12 +201,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 +215,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 +227,38 @@ 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()) {
+        for (auto rowIndex : ui->treeView->selectionModel()->selectedRows()) {
             events << impl->m_Model->getEvent(rowIndex.row());
         }
 
         emit this->eventsSelected(events);
     };
 
-    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()
@@ -292,5 +292,5 @@ void CatalogueEventsWidget::populateWithCatalogues(
         }
     }
 
-    impl->setEvents(events, ui->tableView);
+    impl->setEvents(events, ui->treeView);
 }
diff --git a/gui/src/Catalogue/CatalogueInspectorWidget.cpp b/gui/src/Catalogue/CatalogueInspectorWidget.cpp
index 87d09dd..acf229a 100644
--- a/gui/src/Catalogue/CatalogueInspectorWidget.cpp
+++ b/gui/src/Catalogue/CatalogueInspectorWidget.cpp
@@ -62,17 +62,17 @@ void CatalogueInspectorWidget::CatalogueInspectorWidgetPrivate::connectEventUpda
     });
 
     connect(ui->leEventMission, &QLineEdit::editingFinished, [ui, inspector, this]() {
-        if (ui->leEventMission->text() != m_DisplayedEvent->getMission()) {
-            m_DisplayedEvent->setMission(ui->leEventMission->text());
-            emit inspector->eventUpdated(m_DisplayedEvent);
-        }
+        //        if (ui->leEventMission->text() != m_DisplayedEvent->getMission()) {
+        //            m_DisplayedEvent->setMission(ui->leEventMission->text());
+        //            emit inspector->eventUpdated(m_DisplayedEvent);
+        //        }
     });
 
     connect(ui->leEventProduct, &QLineEdit::editingFinished, [ui, inspector, this]() {
-        if (ui->leEventProduct->text() != m_DisplayedEvent->getProduct()) {
-            m_DisplayedEvent->setProduct(ui->leEventProduct->text());
-            emit inspector->eventUpdated(m_DisplayedEvent);
-        }
+        //        if (ui->leEventProduct->text() != m_DisplayedEvent->getProduct()) {
+        //            m_DisplayedEvent->setProduct(ui->leEventProduct->text());
+        //            emit inspector->eventUpdated(m_DisplayedEvent);
+        //        }
     });
 
     connect(ui->leEventTags, &QLineEdit::editingFinished, [ui, inspector, this]() {
@@ -80,19 +80,19 @@ void CatalogueInspectorWidget::CatalogueInspectorWidgetPrivate::connectEventUpda
     });
 
     connect(ui->dateTimeEventTStart, &QDateTimeEdit::editingFinished, [ui, inspector, this]() {
-        auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTStart->dateTime());
-        if (time != m_DisplayedEvent->getTStart()) {
-            m_DisplayedEvent->setTStart(time);
-            emit inspector->eventUpdated(m_DisplayedEvent);
-        }
+        //        auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTStart->dateTime());
+        //        if (time != m_DisplayedEvent->getTStart()) {
+        //            m_DisplayedEvent->setTStart(time);
+        //            emit inspector->eventUpdated(m_DisplayedEvent);
+        //        }
     });
 
     connect(ui->dateTimeEventTEnd, &QDateTimeEdit::editingFinished, [ui, inspector, this]() {
-        auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTEnd->dateTime());
-        if (time != m_DisplayedEvent->getTEnd()) {
-            m_DisplayedEvent->setTEnd(time);
-            emit inspector->eventUpdated(m_DisplayedEvent);
-        }
+        //        auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTEnd->dateTime());
+        //        if (time != m_DisplayedEvent->getTEnd()) {
+        //            m_DisplayedEvent->setTEnd(time);
+        //            emit inspector->eventUpdated(m_DisplayedEvent);
+        //        }
     });
 }
 
@@ -114,8 +114,8 @@ void CatalogueInspectorWidget::setEvent(const std::shared_ptr<DBEvent> &event)
 
     showPage(Page::EventProperties);
     ui->leEventName->setText(event->getName());
-    ui->leEventMission->setText(event->getMission());
-    ui->leEventProduct->setText(event->getProduct());
+    //    ui->leEventMission->setText(event->getMission());
+    //    ui->leEventProduct->setText(event->getProduct());
 
     QString tagList;
     auto tags = event->getTags();
@@ -126,8 +126,8 @@ void CatalogueInspectorWidget::setEvent(const std::shared_ptr<DBEvent> &event)
 
     ui->leEventTags->setText(tagList);
 
-    ui->dateTimeEventTStart->setDateTime(DateUtils::dateTime(event->getTStart()));
-    ui->dateTimeEventTEnd->setDateTime(DateUtils::dateTime(event->getTEnd()));
+    //    ui->dateTimeEventTStart->setDateTime(DateUtils::dateTime(event->getTStart()));
+    //    ui->dateTimeEventTEnd->setDateTime(DateUtils::dateTime(event->getTEnd()));
 
     blockSignals(false);
 }
diff --git a/gui/ui/Catalogue/CatalogueEventsWidget.ui b/gui/ui/Catalogue/CatalogueEventsWidget.ui
index 8802263..5fa3a9b 100644
--- a/gui/ui/Catalogue/CatalogueEventsWidget.ui
+++ b/gui/ui/Catalogue/CatalogueEventsWidget.ui
@@ -114,7 +114,7 @@
     </layout>
    </item>
    <item>
-    <widget class="QTableView" name="tableView">
+    <widget class="QTreeView" name="treeView">
      <property name="dragEnabled">
       <bool>true</bool>
      </property>
@@ -124,22 +124,7 @@
      <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>