From d65e500c483d6277ec560cf5ec053a4f2511df7d 2017-12-13 13:31:55
From: Thibaud Rabillard <trabillard@itlink.fr>
Date: 2017-12-13 13:31:55
Subject: [PATCH] Merge branch 'feature/CatalogueGui' into develop

---

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 b503555..9d839af 100644
--- a/core/include/Catalogue/CatalogueController.h
+++ b/core/include/Catalogue/CatalogueController.h
@@ -41,8 +41,7 @@ public:
     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(const QString &repository,
-                                std::shared_ptr<DBCatalogue> catalogue) const;
+    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);
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/src/Catalogue/CatalogueController.cpp b/core/src/Catalogue/CatalogueController.cpp
index 3c995db..9e2ad7c 100644
--- a/core/src/Catalogue/CatalogueController.cpp
+++ b/core/src/Catalogue/CatalogueController.cpp
@@ -103,8 +103,7 @@ std::list<std::shared_ptr<DBEvent> > CatalogueController::retrieveAllEvents() co
 }
 
 std::list<std::shared_ptr<DBEvent> >
-CatalogueController::retrieveEventsFromCatalogue(const QString &repository,
-                                                 std::shared_ptr<DBCatalogue> catalogue) const
+CatalogueController::retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const
 {
     auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
     auto events = impl->m_CatalogueDao.getCatalogueEvents(*catalogue);
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/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/CatalogueEventsTableModel.h b/gui/include/Catalogue/CatalogueEventsTableModel.h
new file mode 100644
index 0000000..9bab0a7
--- /dev/null
+++ b/gui/include/Catalogue/CatalogueEventsTableModel.h
@@ -0,0 +1,38 @@
+#ifndef SCIQLOP_CATALOGUEEVENTSTABLEMODEL_H
+#define SCIQLOP_CATALOGUEEVENTSTABLEMODEL_H
+
+#include <Common/spimpl.h>
+#include <QAbstractTableModel>
+
+class DBEvent;
+
+class CatalogueEventsTableModel : public QAbstractTableModel {
+public:
+    CatalogueEventsTableModel(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> &events);
+    void removeEvent(const std::shared_ptr<DBEvent> &events);
+
+    // Model
+    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 CatalogueEventsTableModelPrivate;
+    spimpl::unique_impl_ptr<CatalogueEventsTableModelPrivate> impl;
+};
+
+#endif // SCIQLOP_CATALOGUEEVENTSTABLEMODEL_H
diff --git a/gui/include/Catalogue/CatalogueEventsWidget.h b/gui/include/Catalogue/CatalogueEventsWidget.h
index deae927..04fa2af 100644
--- a/gui/include/Catalogue/CatalogueEventsWidget.h
+++ b/gui/include/Catalogue/CatalogueEventsWidget.h
@@ -2,24 +2,33 @@
 #define SCIQLOP_CATALOGUEEVENTSWIDGET_H
 
 #include <Common/spimpl.h>
+#include <QLoggingCategory>
 #include <QWidget>
 
+class DBCatalogue;
+class DBEvent;
+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);
 
 public:
     explicit CatalogueEventsWidget(QWidget *parent = 0);
     virtual ~CatalogueEventsWidget();
 
+    void setVisualizationWidget(VisualizationWidget *visualization);
+
 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..c049a81 100644
--- a/gui/include/Catalogue/CatalogueInspectorWidget.h
+++ b/gui/include/Catalogue/CatalogueInspectorWidget.h
@@ -2,11 +2,15 @@
 #define SCIQLOP_CATALOGUEINSPECTORWIDGET_H
 
 #include <QWidget>
+#include <memory>
 
 namespace Ui {
 class CatalogueInspectorWidget;
 }
 
+class DBCatalogue;
+class DBEvent;
+
 class CatalogueInspectorWidget : public QWidget {
     Q_OBJECT
 
@@ -19,8 +23,8 @@ public:
 
     Page currentPage() const;
 
-    void setEvent(const QString &event);
-    void setCatalogue(const QString &catalogue);
+    void setEvent(const std::shared_ptr<DBEvent> &event);
+    void setCatalogue(const std::shared_ptr<DBCatalogue> &catalogue);
 
 public slots:
     void showPage(Page page);
diff --git a/gui/include/Catalogue/CatalogueSideBarWidget.h b/gui/include/Catalogue/CatalogueSideBarWidget.h
index b9855dd..f762c3b 100644
--- a/gui/include/Catalogue/CatalogueSideBarWidget.h
+++ b/gui/include/Catalogue/CatalogueSideBarWidget.h
@@ -5,6 +5,8 @@
 #include <QTreeWidgetItem>
 #include <QWidget>
 
+class DBCatalogue;
+
 namespace Ui {
 class CatalogueSideBarWidget;
 }
@@ -13,9 +15,11 @@ 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);
@@ -26,6 +30,9 @@ private:
 
     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..60ea055
--- /dev/null
+++ b/gui/include/Catalogue/CatalogueTreeWidgetItem.h
@@ -0,0 +1,28 @@
+#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;
+
+    void setHasChanges(bool value);
+
+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/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..f7bf8af 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/CatalogueEventsTableModel.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/CatalogueEventsTableModel.cpp b/gui/src/Catalogue/CatalogueEventsTableModel.cpp
new file mode 100644
index 0000000..54994b7
--- /dev/null
+++ b/gui/src/Catalogue/CatalogueEventsTableModel.cpp
@@ -0,0 +1,185 @@
+#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 3fe0065..82cf681 100644
--- a/gui/src/Catalogue/CatalogueEventsWidget.cpp
+++ b/gui/src/Catalogue/CatalogueEventsWidget.cpp
@@ -1,15 +1,198 @@
 #include "Catalogue/CatalogueEventsWidget.h"
 #include "ui_CatalogueEventsWidget.h"
 
-#include <QtDebug>
+#include <Catalogue/CatalogueController.h>
+#include <Catalogue/CatalogueEventsTableModel.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"}; }
-};
+    CatalogueEventsTableModel *m_Model = nullptr;
+    QStringList m_ZonesForTimeMode;
+    QString m_ZoneForGraphMode;
+
+    VisualizationWidget *m_VisualizationWidget = nullptr;
+
+    void setEvents(const QVector<std::shared_ptr<DBEvent> > &events, QTableView *tableView)
+    {
+        tableView->setSortingEnabled(false);
+        m_Model->setEvents(events);
+        tableView->setSortingEnabled(true);
+    }
+
+    void addEvent(const std::shared_ptr<DBEvent> &event, QTableView *tableView)
+    {
+        tableView->setSortingEnabled(false);
+        m_Model->addEvent(event);
+        tableView->setSortingEnabled(true);
+    }
+
+    void removeEvent(const std::shared_ptr<DBEvent> &event, QTableView *tableView)
+    {
+        tableView->setSortingEnabled(false);
+        m_Model->removeEvent(event);
+        tableView->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(QTableView *tableView)
+    {
+        auto selectedRows = tableView->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);
+                        }
+                    }
+                }
+                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(QTableView *tableView)
+    {
+        auto selectedRows = tableView->selectionModel()->selectedRows();
+
+        if (selectedRows.count() == 1) {
+            auto event = m_Model->getEvent(selectedRows.first().row());
+            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 +201,64 @@ CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
 {
     ui->setupUi(this);
 
+    impl->m_Model = new CatalogueEventsTableModel{this};
+    ui->tableView->setModel(impl->m_Model);
+
+    ui->tableView->setSortingEnabled(true);
+    ui->tableView->setDragDropMode(QAbstractItemView::DragDrop);
+    ui->tableView->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->tableView);
         }
     });
 
     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->tableView);
         }
     });
 
-    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;
+        for (auto rowIndex : ui->tableView->selectionModel()->selectedRows()) {
+            events << impl->m_Model->getEvent(rowIndex.row());
+        }
 
-    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);
-                }
-            });
+        emit this->eventsSelected(events);
+    };
 
-    connect(ui->tableWidget, &QTableWidget::itemSelectionChanged, [this]() {
-        auto selection = ui->tableWidget->selectedRanges();
-        auto isNotMultiSelection
-            = selection.isEmpty() || (selection.count() == 1 && selection.first().rowCount() == 1);
+    connect(ui->tableView, &QTableView::clicked, emitSelection);
+    connect(ui->tableView->selectionModel(), &QItemSelectionModel::selectionChanged, emitSelection);
+
+    connect(ui->tableView->selectionModel(), &QItemSelectionModel::selectionChanged, [this]() {
+        auto isNotMultiSelection = ui->tableView->selectionModel()->selectedRows().count() <= 1;
         ui->btnChart->setEnabled(isNotMultiSelection);
         ui->btnTime->setEnabled(isNotMultiSelection);
+
+        if (isNotMultiSelection && ui->btnTime->isChecked()) {
+            impl->updateForTimeMode(ui->tableView);
+        }
+        else if (isNotMultiSelection && ui->btnChart->isChecked()) {
+            impl->updateForGraphMode(ui->tableView);
+        }
     });
 
-    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->tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
+    ui->tableView->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
+    ui->tableView->horizontalHeader()->setSortIndicatorShown(true);
 }
 
 CatalogueEventsWidget::~CatalogueEventsWidget()
@@ -64,37 +266,26 @@ CatalogueEventsWidget::~CatalogueEventsWidget()
     delete ui;
 }
 
-void CatalogueEventsWidget::populateWithCatalogue(const QString &catalogue)
+void CatalogueEventsWidget::setVisualizationWidget(VisualizationWidget *visualization)
 {
-    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_VisualizationWidget = visualization;
 }
 
-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->tableView);
 }
diff --git a/gui/src/Catalogue/CatalogueExplorer.cpp b/gui/src/Catalogue/CatalogueExplorer.cpp
index c286298..43c1b1c 100644
--- a/gui/src/Catalogue/CatalogueExplorer.cpp
+++ b/gui/src/Catalogue/CatalogueExplorer.cpp
@@ -1,22 +1,61 @@
 #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->events, &CatalogueEventsWidget::eventSelected,
-            [this](auto name) { ui->inspector->setEvent(name); });
+    connect(ui->catalogues, &CatalogueSideBarWidget::databaseSelected, [this](auto databases) {
+        ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
+    });
+
+    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);
+        }
+    });
 }
 
 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..e605cc8 100644
--- a/gui/src/Catalogue/CatalogueInspectorWidget.cpp
+++ b/gui/src/Catalogue/CatalogueInspectorWidget.cpp
@@ -1,6 +1,11 @@
 #include "Catalogue/CatalogueInspectorWidget.h"
 #include "ui_CatalogueInspectorWidget.h"
 
+#include <Common/DateUtils.h>
+#include <DBCatalogue.h>
+#include <DBEvent.h>
+#include <DBTag.h>
+
 CatalogueInspectorWidget::CatalogueInspectorWidget(QWidget *parent)
         : QWidget(parent), ui(new Ui::CatalogueInspectorWidget)
 {
@@ -23,14 +28,29 @@ 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)
 {
     showPage(Page::EventProperties);
-    ui->leEventName->setText(event);
+    ui->leEventName->setText(event->getName());
+    ui->leEventMission->setText(event->getMission());
+    ui->leEventProduct->setText(event->getProduct());
+
+    QString tagList;
+    auto tags = event->getTags();
+    for (auto tag : tags) {
+        tagList += tag.getName();
+        tagList += ' ';
+    }
+
+    ui->leEventTags->setText(tagList);
+
+    ui->dateTimeEventTStart->setDateTime(DateUtils::dateTime(event->getTStart()));
+    ui->dateTimeEventTEnd->setDateTime(DateUtils::dateTime(event->getTEnd()));
 }
 
-void CatalogueInspectorWidget::setCatalogue(const QString &catalogue)
+void CatalogueInspectorWidget::setCatalogue(const std::shared_ptr<DBCatalogue> &catalogue)
 {
     showPage(Page::CatalogueProperties);
-    ui->leCatalogueName->setText(catalogue);
+    ui->leCatalogueName->setText(catalogue->getName());
+    ui->leCatalogueAuthor->setText(catalogue->getAuthor());
 }
diff --git a/gui/src/Catalogue/CatalogueSideBarWidget.cpp b/gui/src/Catalogue/CatalogueSideBarWidget.cpp
index f5ade50..4951da3 100644
--- a/gui/src/Catalogue/CatalogueSideBarWidget.cpp
+++ b/gui/src/Catalogue/CatalogueSideBarWidget.cpp
@@ -1,5 +1,15 @@
 #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>
+
 
 constexpr auto ALL_EVENT_ITEM_TYPE = QTreeWidgetItem::UserType;
 constexpr auto TRASH_ITEM_TYPE = QTreeWidgetItem::UserType + 1;
@@ -8,9 +18,12 @@ 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);
 };
 
 CatalogueSideBarWidget::CatalogueSideBarWidget(QWidget *parent)
@@ -21,25 +34,73 @@ 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);
+
+    ui->treeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(ui->treeWidget, &QTreeWidget::customContextMenuRequested, this,
+            &CatalogueSideBarWidget::onContextMenuRequested);
 }
 
 CatalogueSideBarWidget::~CatalogueSideBarWidget()
@@ -47,36 +108,58 @@ CatalogueSideBarWidget::~CatalogueSideBarWidget()
     delete ui;
 }
 
+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 +168,31 @@ 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);
 }
diff --git a/gui/src/Catalogue/CatalogueTreeWidgetItem.cpp b/gui/src/Catalogue/CatalogueTreeWidgetItem.cpp
new file mode 100644
index 0000000..ac2a607
--- /dev/null
+++ b/gui/src/Catalogue/CatalogueTreeWidgetItem.cpp
@@ -0,0 +1,93 @@
+#include "Catalogue/CatalogueTreeWidgetItem.h"
+
+#include <memory>
+
+#include <DBCatalogue.h>
+#include <QBoxLayout>
+#include <QToolButton>
+
+const auto VALIDATION_BUTTON_ICON_SIZE = 12;
+
+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) {
+        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);
+    }
+    else {
+        // Note: the widget is destroyed
+        treeWidget()->setItemWidget(this, 1, nullptr);
+    }
+}
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..8802263 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,41 @@
     </layout>
    </item>
    <item>
-    <widget class="QTableWidget" name="tableWidget">
-     <property name="alternatingRowColors">
+    <widget class="QTableView" name="tableView">
+     <property name="dragEnabled">
       <bool>true</bool>
      </property>
+     <property name="dragDropMode">
+      <enum>QAbstractItemView::DragDrop</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">
+      <bool>false</bool>
+     </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/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>