GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1301:73a314ea66d5

Merge branch 'feature/CatalogueDevelop' into develop

perrinel -

r1301:73a314ea66d5

parent child

Context file:

r1301:73a314ea66d5

gui/include/Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h created 644 +35 0

@@ -0,0 +1,35
	1	#ifndef SCIQLOP_CATALOGUEABSTRACTTREEITEM_H
	2	#define SCIQLOP_CATALOGUEABSTRACTTREEITEM_H
	3
	4	#include <Common/spimpl.h>
	5	#include <QVariant>
	6	#include <QVector>
	7
	8	class QMimeData;
	9
	10	class CatalogueAbstractTreeItem {
	11	public:
	12	constexpr static const int DEFAULT_TYPE = -1;
	13
	14	CatalogueAbstractTreeItem(int type = DEFAULT_TYPE);
	15	virtual ~CatalogueAbstractTreeItem();
	16
	17	void addChild(CatalogueAbstractTreeItem *child);
	18	QVector<CatalogueAbstractTreeItem *> children() const;
	19	CatalogueAbstractTreeItem *parent() const;
	20
	21	int type() const;
	22	QString text(int column = 0) const;
	23
	24	virtual QVariant data(int column, int role) const;
	25	virtual Qt::ItemFlags flags(int column) const;
	26	virtual bool setData(int column, int role, const QVariant &value);
	27	virtual bool canDropMimeData(const QMimeData *data, Qt::DropAction action);
	28	virtual bool dropMimeData(const QMimeData *data, Qt::DropAction action);
	29
	30	private:
	31	class CatalogueAbstractTreeItemPrivate;
	32	spimpl::unique_impl_ptr<CatalogueAbstractTreeItemPrivate> impl;
	33	};
	34
	35	#endif // SCIQLOP_CATALOGUEABSTRACTTREEITEM_H

gui/include/Catalogue/CatalogueTreeItems/CatalogueTextTreeItem.h created 644 +23 0

@@ -0,0 +1,23
	1	#ifndef SCIQLOP_CATALOGUETEXTTREEITEM_H
	2	#define SCIQLOP_CATALOGUETEXTTREEITEM_H
	3
	4	#include <Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h>
	5	#include <Common/spimpl.h>
	6
	7	class CatalogueTextTreeItem : public CatalogueAbstractTreeItem {
	8	public:
	9	CatalogueTextTreeItem(const QIcon &icon, const QString &text, int type);
	10
	11	QVariant data(int column, int role) const override;
	12	Qt::ItemFlags flags(int column) const override;
	13
	14	QString text() const;
	15
	16	void setEnabled(bool value);
	17
	18	private:
	19	class CatalogueTextTreeItemPrivate;
	20	spimpl::unique_impl_ptr<CatalogueTextTreeItemPrivate> impl;
	21	};
	22
	23	#endif // SCIQLOP_CATALOGUETEXTTREEITEM_H

gui/include/Catalogue/CatalogueTreeItems/CatalogueTreeItem.h created 644 +28 0

@@ -0,0 +1,28
	1	#ifndef SCIQLOP_CATALOGUETREEITEM_H
	2	#define SCIQLOP_CATALOGUETREEITEM_H
	3
	4	#include <Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h>
	5	#include <Common/spimpl.h>
	6
	7	class DBCatalogue;
	8
	9
	10	class CatalogueTreeItem : public CatalogueAbstractTreeItem {
	11	public:
	12	CatalogueTreeItem(std::shared_ptr<DBCatalogue> catalogue, const QIcon &icon, int type);
	13
	14	QVariant data(int column, int role) const override;
	15	bool setData(int column, int role, const QVariant &value) override;
	16	Qt::ItemFlags flags(int column) const override;
	17	bool canDropMimeData(const QMimeData *data, Qt::DropAction action) override;
	18	bool dropMimeData(const QMimeData *data, Qt::DropAction action) override;
	19
	20	/// Returns the catalogue represented by the item
	21	std::shared_ptr<DBCatalogue> catalogue() const;
	22
	23	private:
	24	class CatalogueTreeItemPrivate;
	25	spimpl::unique_impl_ptr<CatalogueTreeItemPrivate> impl;
	26	};
	27
	28	#endif // SCIQLOP_CATALOGUETREEITEM_H

gui/include/Catalogue/CatalogueTreeModel.h created 644 +56 0

@@ -0,0 +1,56
	1	#ifndef SCIQLOP_CATALOGUETREEMODEL_H
	2	#define SCIQLOP_CATALOGUETREEMODEL_H
	3
	4	#include <Common/spimpl.h>
	5	#include <QAbstractItemModel>
	6
	7	class CatalogueAbstractTreeItem;
	8
	9	/**
	10	* @brief Model to display catalogue items based on QTreeWidgetItem
	11	* @warning Do not use the method QTreeWidgetItem::treeWidget for an item added to this model or the
	12	* application will crash
	13	*/
	14	class CatalogueTreeModel : public QAbstractItemModel {
	15	Q_OBJECT
	16
	17	signals:
	18	void itemRenamed(const QModelIndex &index);
	19	void itemDropped(const QModelIndex &parentIndex);
	20
	21	public:
	22	CatalogueTreeModel(QObject *parent = nullptr);
	23
	24	enum class Column { Name, Validation, Count };
	25
	26	QModelIndex addTopLevelItem(CatalogueAbstractTreeItem *item);
	27	QVector<CatalogueAbstractTreeItem *> topLevelItems() const;
	28
	29	void addChildItem(CatalogueAbstractTreeItem *child, const QModelIndex &parentIndex);
	30
	31	CatalogueAbstractTreeItem *item(const QModelIndex &index) const;
	32	QModelIndex indexOf(CatalogueAbstractTreeItem *item, int column = 0) const;
	33
	34	// model
	35	QModelIndex index(int row, int column,
	36	const QModelIndex &parent = QModelIndex()) const override;
	37	QModelIndex parent(const QModelIndex &index) const override;
	38	int rowCount(const QModelIndex &parent) const override;
	39	int columnCount(const QModelIndex &parent) const override;
	40	Qt::ItemFlags flags(const QModelIndex &index) const override;
	41	QVariant data(const QModelIndex &index, int role) const override;
	42	bool setData(const QModelIndex &index, const QVariant &value, int role) override;
	43
	44	bool canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
	45	const QModelIndex &parent) const override;
	46	bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
	47	const QModelIndex &parent) override;
	48	Qt::DropActions supportedDropActions() const;
	49	QStringList mimeTypes() const;
	50
	51	private:
	52	class CatalogueTreeModelPrivate;
	53	spimpl::unique_impl_ptr<CatalogueTreeModelPrivate> impl;
	54	};
	55
	56	#endif // CATALOGUETREEMODEL_H

gui/src/Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.cpp created 644 +81 0

@@ -0,0 +1,81
	1	#include "Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h"
	2
	3	struct CatalogueAbstractTreeItem::CatalogueAbstractTreeItemPrivate {
	4	int m_Type;
	5	QVector<CatalogueAbstractTreeItem *> m_Children;
	6	CatalogueAbstractTreeItem *m_Parent = nullptr;
	7
	8	CatalogueAbstractTreeItemPrivate(int type) : m_Type(type) {}
	9	};
	10
	11	CatalogueAbstractTreeItem::CatalogueAbstractTreeItem(int type)
	12	: impl{spimpl::make_unique_impl<CatalogueAbstractTreeItemPrivate>(type)}
	13	{
	14	}
	15
	16	CatalogueAbstractTreeItem::~CatalogueAbstractTreeItem()
	17	{
	18	qDeleteAll(impl->m_Children);
	19	}
	20
	21	void CatalogueAbstractTreeItem::addChild(CatalogueAbstractTreeItem *child)
	22	{
	23	impl->m_Children << child;
	24	child->impl->m_Parent = this;
	25	}
	26
	27	QVector<CatalogueAbstractTreeItem *> CatalogueAbstractTreeItem::children() const
	28	{
	29	return impl->m_Children;
	30	}
	31
	32	CatalogueAbstractTreeItem *CatalogueAbstractTreeItem::parent() const
	33	{
	34	return impl->m_Parent;
	35	}
	36
	37	int CatalogueAbstractTreeItem::type() const
	38	{
	39	return impl->m_Type;
	40	}
	41
	42	QString CatalogueAbstractTreeItem::text(int column) const
	43	{
	44	return data(0, Qt::DisplayRole).toString();
	45	}
	46
	47	QVariant CatalogueAbstractTreeItem::data(int column, int role) const
	48	{
	49	Q_UNUSED(column);
	50	Q_UNUSED(role);
	51	return QVariant();
	52	}
	53
	54	Qt::ItemFlags CatalogueAbstractTreeItem::flags(int column) const
	55	{
	56	Q_UNUSED(column);
	57	return Qt::NoItemFlags;
	58	}
	59
	60	bool CatalogueAbstractTreeItem::setData(int column, int role, const QVariant &value)
	61	{
	62	Q_UNUSED(column);
	63	Q_UNUSED(role);
	64	Q_UNUSED(value);
	65
	66	return false;
	67	}
	68
	69	bool CatalogueAbstractTreeItem::canDropMimeData(const QMimeData *data, Qt::DropAction action)
	70	{
	71	Q_UNUSED(data);
	72	Q_UNUSED(action);
	73	return false;
	74	}
	75
	76	bool CatalogueAbstractTreeItem::dropMimeData(const QMimeData *data, Qt::DropAction action)
	77	{
	78	Q_UNUSED(data);
	79	Q_UNUSED(action);
	80	return false;
	81	}

gui/src/Catalogue/CatalogueTreeItems/CatalogueTextTreeItem.cpp created 644 +59 0

@@ -0,0 +1,59
	1	#include "Catalogue/CatalogueTreeItems/CatalogueTextTreeItem.h"
	2
	3	#include <QIcon>
	4
	5	struct CatalogueTextTreeItem::CatalogueTextTreeItemPrivate {
	6
	7	QString m_Text;
	8	QIcon m_Icon;
	9	bool m_IsEnabled = true;
	10
	11	CatalogueTextTreeItemPrivate(const QIcon &icon, const QString &text)
	12	: m_Text(text), m_Icon(icon)
	13	{
	14	}
	15	};
	16
	17
	18	CatalogueTextTreeItem::CatalogueTextTreeItem(const QIcon &icon, const QString &text, int type)
	19	: CatalogueAbstractTreeItem(type),
	20	impl{spimpl::make_unique_impl<CatalogueTextTreeItemPrivate>(icon, text)}
	21	{
	22	}
	23
	24	QVariant CatalogueTextTreeItem::data(int column, int role) const
	25	{
	26	if (column > 0) {
	27	return QVariant();
	28	}
	29
	30	switch (role) {
	31	case Qt::DisplayRole:
	32	return impl->m_Text;
	33	case Qt::DecorationRole:
	34	return impl->m_Icon;
	35	}
	36
	37	return QVariant();
	38	}
	39
	40	Qt::ItemFlags CatalogueTextTreeItem::flags(int column) const
	41	{
	42	Q_UNUSED(column);
	43
	44	if (!impl->m_IsEnabled) {
	45	return Qt::NoItemFlags;
	46	}
	47
	48	return Qt::ItemIsEnabled \| Qt::ItemIsSelectable;
	49	}
	50
	51	QString CatalogueTextTreeItem::text() const
	52	{
	53	return impl->m_Text;
	54	}
	55
	56	void CatalogueTextTreeItem::setEnabled(bool value)
	57	{
	58	impl->m_IsEnabled = value;
	59	}

gui/src/Catalogue/CatalogueTreeModel.cpp created 644 +201 0

@@ -0,0 +1,201
	1	#include "Catalogue/CatalogueTreeModel.h"
	2	#include <Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h>
	3
	4	#include <QMimeData>
	5	#include <memory>
	6
	7	#include <Common/MimeTypesDef.h>
	8
	9	struct CatalogueTreeModel::CatalogueTreeModelPrivate {
	10	std::unique_ptr<CatalogueAbstractTreeItem> m_RootItem = nullptr;
	11
	12	CatalogueTreeModelPrivate() : m_RootItem{std::make_unique<CatalogueAbstractTreeItem>()} {}
	13	};
	14
	15	CatalogueTreeModel::CatalogueTreeModel(QObject *parent)
	16	: QAbstractItemModel(parent), impl{spimpl::make_unique_impl<CatalogueTreeModelPrivate>()}
	17	{
	18	}
	19
	20	QModelIndex CatalogueTreeModel::addTopLevelItem(CatalogueAbstractTreeItem *item)
	21	{
	22	auto nbTopLevelItems = impl->m_RootItem->children().count();
	23	beginInsertRows(QModelIndex(), nbTopLevelItems, nbTopLevelItems);
	24	impl->m_RootItem->addChild(item);
	25	endInsertRows();
	26
	27	emit dataChanged(QModelIndex(), QModelIndex());
	28
	29	return index(nbTopLevelItems, 0);
	30	}
	31
	32	QVector<CatalogueAbstractTreeItem *> CatalogueTreeModel::topLevelItems() const
	33	{
	34	return impl->m_RootItem->children();
	35	}
	36
	37	void CatalogueTreeModel::addChildItem(CatalogueAbstractTreeItem *child,
	38	const QModelIndex &parentIndex)
	39	{
	40	auto parentItem = item(parentIndex);
	41	int c = parentItem->children().count();
	42	beginInsertRows(parentIndex, c, c);
	43	parentItem->addChild(child);
	44	endInsertRows();
	45
	46	emit dataChanged(parentIndex, parentIndex);
	47	}
	48
	49	CatalogueAbstractTreeItem *CatalogueTreeModel::item(const QModelIndex &index) const
	50	{
	51	return static_cast<CatalogueAbstractTreeItem *>(index.internalPointer());
	52	}
	53
	54	QModelIndex CatalogueTreeModel::indexOf(CatalogueAbstractTreeItem *item, int column) const
	55	{
	56	auto parentItem = item->parent();
	57	if (!parentItem) {
	58	return QModelIndex();
	59	}
	60
	61	auto row = parentItem->children().indexOf(item);
	62	return createIndex(row, column, item);
	63	}
	64
	65	QModelIndex CatalogueTreeModel::index(int row, int column, const QModelIndex &parent) const
	66	{
	67	if (column > 0) {
	68	int a = 0;
	69	}
	70
	71	if (!hasIndex(row, column, parent)) {
	72	return QModelIndex();
	73	}
	74
	75	CatalogueAbstractTreeItem *parentItem = nullptr;
	76
	77	if (!parent.isValid()) {
	78	parentItem = impl->m_RootItem.get();
	79	}
	80	else {
	81	parentItem = item(parent);
	82	}
	83
	84	auto childItem = parentItem->children().value(row);
	85	if (childItem) {
	86	return createIndex(row, column, childItem);
	87	}
	88
	89	return QModelIndex();
	90	}
	91
	92
	93	QModelIndex CatalogueTreeModel::parent(const QModelIndex &index) const
	94	{
	95	if (!index.isValid()) {
	96	return QModelIndex();
	97	}
	98
	99	auto childItem = item(index);
	100	auto parentItem = childItem->parent();
	101
	102	if (parentItem == nullptr \|\| parentItem->parent() == nullptr) {
	103	return QModelIndex();
	104	}
	105
	106	auto row = parentItem->parent()->children().indexOf(parentItem);
	107	return createIndex(row, 0, parentItem);
	108	}
	109
	110	int CatalogueTreeModel::rowCount(const QModelIndex &parent) const
	111	{
	112	CatalogueAbstractTreeItem *parentItem = nullptr;
	113
	114	if (!parent.isValid()) {
	115	parentItem = impl->m_RootItem.get();
	116	}
	117	else {
	118	parentItem = item(parent);
	119	}
	120
	121	return parentItem->children().count();
	122	}
	123
	124	int CatalogueTreeModel::columnCount(const QModelIndex &parent) const
	125	{
	126	return (int)Column::Count;
	127	}
	128
	129	Qt::ItemFlags CatalogueTreeModel::flags(const QModelIndex &index) const
	130	{
	131	auto treeItem = item(index);
	132	if (treeItem) {
	133	return treeItem->flags(index.column());
	134	}
	135
	136	return Qt::NoItemFlags;
	137	}
	138
	139	QVariant CatalogueTreeModel::data(const QModelIndex &index, int role) const
	140	{
	141	auto treeItem = item(index);
	142	if (treeItem) {
	143	return treeItem->data(index.column(), role);
	144	}
	145
	146	return QModelIndex();
	147	}
	148
	149	bool CatalogueTreeModel::setData(const QModelIndex &index, const QVariant &value, int role)
	150	{
	151	auto treeItem = item(index);
	152	if (treeItem) {
	153	auto result = treeItem->setData(index.column(), role, value);
	154
	155	if (result && index.column() == (int)Column::Name) {
	156	emit itemRenamed(index);
	157	}
	158
	159	return result;
	160	}
	161
	162	return false;
	163	}
	164	bool CatalogueTreeModel::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row,
	165	int column, const QModelIndex &parent) const
	166	{
	167	auto draggedIndex = parent;
	168	auto draggedItem = item(draggedIndex);
	169	if (draggedItem) {
	170	return draggedItem->canDropMimeData(data, action);
	171	}
	172
	173	return false;
	174	}
	175
	176	bool CatalogueTreeModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row,
	177	int column, const QModelIndex &parent)
	178	{
	179	bool result = false;
	180
	181	auto draggedIndex = parent;
	182	auto draggedItem = item(draggedIndex);
	183	if (draggedItem) {
	184	result = draggedItem->dropMimeData(data, action);
	185	if (result) {
	186	emit itemDropped(draggedIndex);
	187	}
	188	}
	189
	190	return result;
	191	}
	192
	193	Qt::DropActions CatalogueTreeModel::supportedDropActions() const
	194	{
	195	return Qt::CopyAction \| Qt::MoveAction;
	196	}
	197
	198	QStringList CatalogueTreeModel::mimeTypes() const
	199	{
	200	return {MIME_TYPE_EVENT_LIST};
	201	}

app/include/MainWindow.h +1 0

             /*------------------------------------------------------------------------------
             -- This file is a part of the SciQLop Software
             -- Copyright (C) 2017, Plasma Physics Laboratory - CNRS
             --
             -- This program is free software; you can redistribute it and/or modify
             -- it under the terms of the GNU General Public License as published by
             -- the Free Software Foundation; either version 2 of the License, or
             -- (at your option) any later version.
             --
             -- This program is distributed in the hope that it will be useful,
             -- but WITHOUT ANY WARRANTY; without even the implied warranty of
             -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
             -- GNU General Public License for more details.
             --
             -- You should have received a copy of the GNU General Public License
             -- along with this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #ifndef SCIQLOP_MAINWINDOW_H
             #define SCIQLOP_MAINWINDOW_H
             #include <QListWidgetItem>
             #include <QLoggingCategory>
             #include <QMainWindow>
             #include <QProgressBar>
             #include <QProgressDialog>
             #include <QThread>
             #include <QVBoxLayout>
             #include <QWidget>
             #include <Common/spimpl.h>
             #include <memory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_MainWindow)
             namespace Ui {
             class MainWindow;
             } // namespace Ui
             class MainWindow : public QMainWindow {
                 Q_OBJECT
             public:
                 explicit MainWindow(QWidget *parent = 0);
                 virtual ~MainWindow();
             public slots:
             protected:
                 void changeEvent(QEvent *e);
+                void closeEvent(QCloseEvent *event);
             private:
                 std::unique_ptr<Ui::MainWindow> m_Ui;
                 //    QWidget *m_progressWidget;
                 //    QVBoxLayout *m_progressLayout;
                 // QList<QLopService*> m_qlopServices;
                 class MainWindowPrivate;
                 spimpl::unique_impl_ptr<MainWindowPrivate> impl;
             };
             #endif // SCIQLOP_MAINWINDOW_H

app/src/Main.cpp +3 -1

             /*------------------------------------------------------------------------------
             -- This file is a part of the QLop Software
             -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
             --
             -- This program is free software; you can redistribute it and/or modify
             -- it under the terms of the GNU General Public License as published by
             -- the Free Software Foundation; either version 2 of the License, or
             -- (at your option) any later version.
             --
             -- This program is distributed in the hope that it will be useful,
             -- but WITHOUT ANY WARRANTY; without even the implied warranty of
             -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
             -- GNU General Public License for more details.
             --
             -- You should have received a copy of the GNU General Public License
             -- along with this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "MainWindow.h"
             #include <QProcessEnvironment>
             #include <QThread>
             #include <SqpApplication.h>
             #include <qglobal.h>
             #include <Plugin/PluginManager.h>
             #include <QDir>
             #include <QtPlugin>
             #include <QLoggingCategory>
             Q_LOGGING_CATEGORY(LOG_Main, "Main")
             namespace {
             const auto PLUGIN_DIRECTORY_NAME = QStringLiteral("plugins");
             } // namespace
             int main(int argc, char *argv[])
             {
             #ifdef QT_STATICPLUGIN
                 Q_IMPORT_PLUGIN(MockPlugin)
                 Q_IMPORT_PLUGIN(AmdaPlugin)
                 Q_INIT_RESOURCE(amdaresources);
             #endif
                 Q_INIT_RESOURCE(sqpguiresources);
-                SqpApplication a{argc, argv};
                 SqpApplication::setOrganizationName("LPP");
                 SqpApplication::setOrganizationDomain("lpp.fr");
                 SqpApplication::setApplicationName("SciQLop");
+                SqpApplication a{argc, argv};
                 MainWindow w;
                 w.show();
                 // Loads plugins
                 auto pluginDir = QDir{a.applicationDirPath()};
                 auto pluginLookupPath = {
                     a.applicationDirPath(),
                     a.applicationDirPath() + "/" + PLUGIN_DIRECTORY_NAME,
                     a.applicationDirPath() + "/../lib64/SciQlop",
                     a.applicationDirPath() + "/../lib64/sciqlop",
                     a.applicationDirPath() + "/../lib/SciQlop",
                     a.applicationDirPath() + "/../lib/sciqlop",
                     a.applicationDirPath() + "/../plugins",
                 };
             #if _WIN32 || _WIN64
                 pluginDir.mkdir(PLUGIN_DIRECTORY_NAME);
                 pluginDir.cd(PLUGIN_DIRECTORY_NAME);
             #endif
                 PluginManager pluginManager{};
                 for (auto &&path : pluginLookupPath) {
                     QDir directory{path};
                     if (directory.exists()) {
                         qCDebug(LOG_Main())
                             << QObject::tr("Plugin directory: %1").arg(directory.absolutePath());
                         pluginManager.loadPlugins(directory);
                     }
                 }
                 pluginManager.loadStaticPlugins();
                 return a.exec();
             }

app/src/MainWindow.cpp +39 0

             /*------------------------------------------------------------------------------
             -- This file is a part of the SciQLop Software
             -- Copyright (C) 2017, Plasma Physics Laboratory - CNRS
             --
             -- This program is free software; you can redistribute it and/or modify
             -- it under the terms of the GNU General Public License as published by
             -- the Free Software Foundation; either version 2 of the License, or
             -- (at your option) any later version.
             --
             -- This program is distributed in the hope that it will be useful,
             -- but WITHOUT ANY WARRANTY; without even the implied warranty of
             -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
             -- GNU General Public License for more details.
             --
             -- You should have received a copy of the GNU General Public License
             -- along with this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "MainWindow.h"
             #include "ui_MainWindow.h"
+            #include <Catalogue/CatalogueController.h>
             #include <Catalogue/CatalogueExplorer.h>
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceWidget.h>
             #include <Settings/SqpSettingsDialog.h>
             #include <Settings/SqpSettingsGeneralWidget.h>
             #include <SidePane/SqpSidePane.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <TimeWidget/TimeWidget.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/VisualizationController.h>
             #include <QAction>
+            #include <QCloseEvent>
             #include <QDate>
             #include <QDir>
             #include <QFileDialog>
+            #include <QMessageBox>
             #include <QToolBar>
             #include <QToolButton>
             #include <memory.h>
             #include "iostream"
             Q_LOGGING_CATEGORY(LOG_MainWindow, "MainWindow")
             namespace {
             const auto LEFTMAININSPECTORWIDGETSPLITTERINDEX = 0;
             const auto LEFTINSPECTORSIDEPANESPLITTERINDEX = 1;
             const auto VIEWPLITTERINDEX = 2;
             const auto RIGHTINSPECTORSIDEPANESPLITTERINDEX = 3;
             const auto RIGHTMAININSPECTORWIDGETSPLITTERINDEX = 4;
             }
             class MainWindow::MainWindowPrivate {
             public:
                 explicit MainWindowPrivate(MainWindow *mainWindow)
                         : m_LastOpenLeftInspectorSize{},
                           m_LastOpenRightInspectorSize{},
                           m_GeneralSettingsWidget{new SqpSettingsGeneralWidget{mainWindow}},
                           m_SettingsDialog{new SqpSettingsDialog{mainWindow}},
                           m_CatalogExplorer{new CatalogueExplorer{mainWindow}}
                 {
                 }
                 QSize m_LastOpenLeftInspectorSize;
                 QSize m_LastOpenRightInspectorSize;
                 /// General settings widget. MainWindow has the ownership
                 SqpSettingsGeneralWidget *m_GeneralSettingsWidget;
                 /// Settings dialog. MainWindow has the ownership
                 SqpSettingsDialog *m_SettingsDialog;
                 /// Catalogue dialog. MainWindow has the ownership
                 CatalogueExplorer *m_CatalogExplorer;
+                bool checkDataToSave(QWidget *parentWidget);
             };
             MainWindow::MainWindow(QWidget *parent)
                     : QMainWindow{parent},
                       m_Ui{new Ui::MainWindow},
                       impl{spimpl::make_unique_impl<MainWindowPrivate>(this)}
             {
                 m_Ui->setupUi(this);
                 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{
                                                                ":/icones/previous.png",
                                                            },
                                                            tr("Show/hide the left inspector"), this};
                 auto spacerLeftTop = new QWidget{};
                 spacerLeftTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerLeftBottom = new QWidget{};
                 spacerLeftBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 leftSidePane->addWidget(spacerLeftTop);
                 leftSidePane->addAction(openLeftInspectorAction);
                 leftSidePane->addWidget(spacerLeftBottom);
                 auto rightSidePane = m_Ui->rightInspectorSidePane->sidePane();
                 auto openRightInspectorAction = new QAction{QIcon{
                                                                 ":/icones/next.png",
                                                             },
                                                             tr("Show/hide the right inspector"), this};
                 auto spacerRightTop = new QWidget{};
                 spacerRightTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerRightBottom = new QWidget{};
                 spacerRightBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 rightSidePane->addWidget(spacerRightTop);
                 rightSidePane->addAction(openRightInspectorAction);
                 rightSidePane->addWidget(spacerRightBottom);
                 openLeftInspectorAction->setCheckable(true);
                 openRightInspectorAction->setCheckable(true);
                 auto openInspector = [this](bool checked, bool right, auto action) {
                     action->setIcon(QIcon{(checked xor right) ? ":/icones/next.png" : ":/icones/previous.png"});
                     auto &lastInspectorSize
                         = right ? impl->m_LastOpenRightInspectorSize : impl->m_LastOpenLeftInspectorSize;
                     auto nextInspectorSize = right ? m_Ui->rightMainInspectorWidget->size()
                                                    : m_Ui->leftMainInspectorWidget->size();
                     // Update of the last opened geometry
                     if (checked) {
                         lastInspectorSize = nextInspectorSize;
                     }
                     auto startSize = lastInspectorSize;
                     auto endSize = startSize;
                     endSize.setWidth(0);
                     auto splitterInspectorIndex
                         = right ? RIGHTMAININSPECTORWIDGETSPLITTERINDEX : LEFTMAININSPECTORWIDGETSPLITTERINDEX;
                     auto currentSizes = m_Ui->splitter->sizes();
                     if (checked) {
                         // adjust sizes individually here, e.g.
                         currentSizes[splitterInspectorIndex] -= lastInspectorSize.width();
                         currentSizes[VIEWPLITTERINDEX] += lastInspectorSize.width();
                         m_Ui->splitter->setSizes(currentSizes);
                     }
                     else {
                         // adjust sizes individually here, e.g.
                         currentSizes[splitterInspectorIndex] += lastInspectorSize.width();
                         currentSizes[VIEWPLITTERINDEX] -= lastInspectorSize.width();
                         m_Ui->splitter->setSizes(currentSizes);
                     }
                 };
                 connect(openLeftInspectorAction, &QAction::triggered,
                         [openInspector, openLeftInspectorAction](bool checked) {
                             openInspector(checked, false, openLeftInspectorAction);
                         });
                 connect(openRightInspectorAction, &QAction::triggered,
                         [openInspector, openRightInspectorAction](bool checked) {
                             openInspector(checked, true, openRightInspectorAction);
                         });
                 // //////////////// //
                 // Menu and Toolbar //
                 // //////////////// //
                 this->menuBar()->addAction(tr("File"));
                 auto toolsMenu = this->menuBar()->addMenu(tr("Tools"));
                 toolsMenu->addAction(tr("Settings..."), [this]() {
                     // Loads settings
                     impl->m_SettingsDialog->loadSettings();
                     // Open settings dialog and save settings if the dialog is accepted
                     if (impl->m_SettingsDialog->exec() == QDialog::Accepted) {
                         impl->m_SettingsDialog->saveSettings();
                     }
                 });
                 auto mainToolBar = this->addToolBar(QStringLiteral("MainToolBar"));
                 auto timeWidget = new TimeWidget{};
                 mainToolBar->addWidget(timeWidget);
                 // Interaction modes
                 auto actionPointerMode = new QAction{QIcon(":/icones/pointer.png"), "Move", this};
                 actionPointerMode->setCheckable(true);
                 actionPointerMode->setChecked(sqpApp->plotsInteractionMode()
                                               == SqpApplication::PlotsInteractionMode::None);
                 connect(actionPointerMode, &QAction::triggered,
                         []() { sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::None); });
                 auto actionZoomMode = new QAction{QIcon(":/icones/zoom.png"), "Zoom", this};
                 actionZoomMode->setCheckable(true);
                 actionZoomMode->setChecked(sqpApp->plotsInteractionMode()
                                            == SqpApplication::PlotsInteractionMode::ZoomBox);
                 connect(actionZoomMode, &QAction::triggered, []() {
                     sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::ZoomBox);
                 });
                 auto actionOrganisationMode = new QAction{QIcon(":/icones/drag.png"), "Organize", this};
                 actionOrganisationMode->setCheckable(true);
                 actionOrganisationMode->setChecked(sqpApp->plotsInteractionMode()
                                                    == SqpApplication::PlotsInteractionMode::DragAndDrop);
                 connect(actionOrganisationMode, &QAction::triggered, []() {
                     sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::DragAndDrop);
                 });
                 auto actionZonesMode = new QAction{QIcon(":/icones/rectangle.png"), "Zones", this};
                 actionZonesMode->setCheckable(true);
                 actionZonesMode->setChecked(sqpApp->plotsInteractionMode()
                                             == SqpApplication::PlotsInteractionMode::SelectionZones);
                 connect(actionZonesMode, &QAction::triggered, []() {
                     sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::SelectionZones);
                 });
                 auto modeActionGroup = new QActionGroup{this};
                 modeActionGroup->addAction(actionZoomMode);
                 modeActionGroup->addAction(actionZonesMode);
                 modeActionGroup->addAction(actionOrganisationMode);
                 modeActionGroup->addAction(actionPointerMode);
                 modeActionGroup->setExclusive(true);
                 mainToolBar->addSeparator();
                 mainToolBar->addAction(actionPointerMode);
                 mainToolBar->addAction(actionZoomMode);
                 mainToolBar->addAction(actionOrganisationMode);
                 mainToolBar->addAction(actionZonesMode);
                 mainToolBar->addSeparator();
                 // Cursors
                 auto btnCursor = new QToolButton{this};
                 btnCursor->setIcon(QIcon(":/icones/cursor.png"));
                 btnCursor->setText("Cursor");
                 btnCursor->setToolTip("Cursor");
                 btnCursor->setPopupMode(QToolButton::InstantPopup);
                 auto cursorMenu = new QMenu("CursorMenu", this);
                 btnCursor->setMenu(cursorMenu);
                 auto noCursorAction = cursorMenu->addAction("No Cursor");
                 noCursorAction->setCheckable(true);
                 noCursorAction->setChecked(sqpApp->plotsCursorMode()
                                            == SqpApplication::PlotsCursorMode::NoCursor);
                 connect(noCursorAction, &QAction::triggered,
                         []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::NoCursor); });
                 cursorMenu->addSeparator();
                 auto verticalCursorAction = cursorMenu->addAction("Vertical Cursor");
                 verticalCursorAction->setCheckable(true);
                 verticalCursorAction->setChecked(sqpApp->plotsCursorMode()
                                                  == SqpApplication::PlotsCursorMode::Vertical);
                 connect(verticalCursorAction, &QAction::triggered,
                         []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Vertical); });
                 auto temporalCursorAction = cursorMenu->addAction("Temporal Cursor");
                 temporalCursorAction->setCheckable(true);
                 temporalCursorAction->setChecked(sqpApp->plotsCursorMode()
                                                  == SqpApplication::PlotsCursorMode::Temporal);
                 connect(temporalCursorAction, &QAction::triggered,
                         []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Temporal); });
                 auto horizontalCursorAction = cursorMenu->addAction("Horizontal Cursor");
                 horizontalCursorAction->setCheckable(true);
                 horizontalCursorAction->setChecked(sqpApp->plotsCursorMode()
                                                    == SqpApplication::PlotsCursorMode::Horizontal);
                 connect(horizontalCursorAction, &QAction::triggered,
                         []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Horizontal); });
                 auto crossCursorAction = cursorMenu->addAction("Cross Cursor");
                 crossCursorAction->setCheckable(true);
                 crossCursorAction->setChecked(sqpApp->plotsCursorMode()
                                               == SqpApplication::PlotsCursorMode::Cross);
                 connect(crossCursorAction, &QAction::triggered,
                         []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Cross); });
                 mainToolBar->addWidget(btnCursor);
                 auto cursorModeActionGroup = new QActionGroup{this};
                 cursorModeActionGroup->setExclusive(true);
                 cursorModeActionGroup->addAction(noCursorAction);
                 cursorModeActionGroup->addAction(verticalCursorAction);
                 cursorModeActionGroup->addAction(temporalCursorAction);
                 cursorModeActionGroup->addAction(horizontalCursorAction);
                 cursorModeActionGroup->addAction(crossCursorAction);
                 // Catalog
                 mainToolBar->addSeparator();
                 mainToolBar->addAction(QIcon(":/icones/catalogue.png"), "Catalogues",
                                        [this]() { impl->m_CatalogExplorer->show(); });
                 // //////// //
                 // Settings //
                 // //////// //
                 // Registers "general settings" widget to the settings dialog
                 impl->m_SettingsDialog->registerWidget(QStringLiteral("General"),
                                                        impl->m_GeneralSettingsWidget);
                 // /////////// //
                 // Connections //
                 // /////////// //
                 // Controllers / controllers connections
                 connect(&sqpApp->timeController(), SIGNAL(timeUpdated(SqpRange)), &sqpApp->variableController(),
                         SLOT(onDateTimeOnSelection(SqpRange)));
                 // Widgets / controllers connections
                 // DataSource
                 connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem *)),
                         m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem *)));
                 // Time
                 connect(timeWidget, SIGNAL(timeUpdated(SqpRange)), &sqpApp->timeController(),
                         SLOT(onTimeToUpdate(SqpRange)));
                 // Visualization
                 connect(&sqpApp->visualizationController(),
                         SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), m_Ui->view,
                         SLOT(onVariableAboutToBeDeleted(std::shared_ptr<Variable>)));
                 connect(&sqpApp->visualizationController(),
                         SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)), m_Ui->view,
                         SLOT(onRangeChanged(std::shared_ptr<Variable>, const SqpRange &)));
                 // Widgets / widgets connections
                 // For the following connections, we use DirectConnection to allow each widget that can
                 // potentially attach a menu to the variable's menu to do so before this menu is displayed.
                 // The order of connections is also important, since it determines the order in which each
                 // widget will attach its menu
                 connect(
                     m_Ui->variableInspectorWidget,
                     SIGNAL(tableMenuAboutToBeDisplayed(QMenu *, const QVector<std::shared_ptr<Variable> > &)),
                     m_Ui->view, SLOT(attachVariableMenu(QMenu *, const QVector<std::shared_ptr<Variable> > &)),
                     Qt::DirectConnection);
             }
             MainWindow::~MainWindow()
             {
             }
             void MainWindow::changeEvent(QEvent *e)
             {
                 QMainWindow::changeEvent(e);
                 switch (e->type()) {
                     case QEvent::LanguageChange:
                         m_Ui->retranslateUi(this);
                         break;
                     default:
                         break;
                 }
             }
+            void MainWindow::closeEvent(QCloseEvent *event)
+            {
+                if (!impl->checkDataToSave(this)) {
+                    event->ignore();
+                }
+                else {
+                    event->accept();
+                }
+            }
+            bool MainWindow::MainWindowPrivate::checkDataToSave(QWidget *parentWidget)
+            {
+                auto hasChanges = sqpApp->catalogueController().hasChanges();
+                if (hasChanges) {
+                    // There are some unsaved changes
+                    switch (QMessageBox::question(
+                        parentWidget, "Save changes",
+                        tr("The catalogue controller unsaved changes.\nDo you want to save them ?"),
+                        QMessageBox::SaveAll | QMessageBox::Discard | QMessageBox::Cancel,
+                        QMessageBox::SaveAll)) {
+                        case QMessageBox::SaveAll:
+                            sqpApp->catalogueController().saveAll();
+                            break;
+                        case QMessageBox::Discard:
+                            break;
+                        case QMessageBox::Cancel:
+                        default:
+                            return false;
+                    }
+                }
+                return true;
+            }

core/include/Catalogue/CatalogueController.h +12 -4

             #ifndef SCIQLOP_CATALOGUECONTROLLER_H
             #define SCIQLOP_CATALOGUECONTROLLER_H
             #include "CoreGlobal.h"
             #include <Data/SqpRange.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             #include <memory>
             class DBCatalogue;
             class DBEvent;
+            class DBEventProduct;
             Q_DECLARE_LOGGING_CATEGORY(LOG_CatalogueController)
             class DataSourceItem;
             class Variable;
             /**
              * @brief The CatalogueController class aims to handle catalogues and event using the CatalogueAPI
              * library.
              */
             class SCIQLOP_CORE_EXPORT CatalogueController : public QObject {
                 Q_OBJECT
             public:
                 explicit CatalogueController(QObject *parent = 0);
                 virtual ~CatalogueController();
                 // DB
                 QStringList getRepositories() const;
                 void addDB(const QString &dbPath);
                 void saveDB(const QString &destinationPath, const QString &repository);
                 // Event
                 /// retrieveEvents with empty repository retrieve them from the default repository
                 std::list<std::shared_ptr<DBEvent> > retrieveEvents(const QString &repository) const;
                 std::list<std::shared_ptr<DBEvent> > retrieveAllEvents() const;
                 std::list<std::shared_ptr<DBEvent> >
                 retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const;
                 void addEvent(std::shared_ptr<DBEvent> event);
                 void updateEvent(std::shared_ptr<DBEvent> event);
+                void updateEventProduct(std::shared_ptr<DBEventProduct> eventProduct);
                 void removeEvent(std::shared_ptr<DBEvent> event);
                 //    void trashEvent(std::shared_ptr<DBEvent> event);
-                //    void restore(QUuid eventId);
+                //        void restore(std::shared_ptr<DBEvent> event);
                 void saveEvent(std::shared_ptr<DBEvent> event);
+                void discardEvent(std::shared_ptr<DBEvent> event);
+                bool eventHasChanges(std::shared_ptr<DBEvent> event) const;
                 // Catalogue
                 //    bool createCatalogue(const QString &name, QVector<QUuid> eventList);
                 /// retrieveEvents with empty repository retrieve them from the default repository
                 std::list<std::shared_ptr<DBCatalogue> > retrieveCatalogues(const QString &repository
                                                                             = QString()) const;
                 void updateCatalogue(std::shared_ptr<DBCatalogue> catalogue);
                 void removeCatalogue(std::shared_ptr<DBCatalogue> catalogue);
                 void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue);
                 void saveAll();
+                bool hasChanges() const;
+                /// Returns the MIME data associated to a list of variables
+                QByteArray mimeDataForEvents(const QVector<std::shared_ptr<DBEvent> > &events) const;
+                /// Returns the list of variables contained in a MIME data
+                QVector<std::shared_ptr<DBEvent> > eventsForMimeData(const QByteArray &mimeData) const;
             public slots:
                 /// Manage init/end of the controller
                 void initialize();
-                void finalize();
             private:
-                void waitForFinish();
                 class CatalogueControllerPrivate;
                 spimpl::unique_impl_ptr<CatalogueControllerPrivate> impl;
             };
             #endif // SCIQLOP_CATALOGUECONTROLLER_H

core/include/DataSource/DataSourceItem.h +2 0

             #ifndef SCIQLOP_DATASOURCEITEM_H
             #define SCIQLOP_DATASOURCEITEM_H
             #include "CoreGlobal.h"
             #include <Common/spimpl.h>
             #include <QVariant>
             #include <QVector>
             class DataSourceItemAction;
             /**
              * Possible types of an item
              */
             enum class DataSourceItemType { NODE, PRODUCT, COMPONENT };
             /**
              * @brief The DataSourceItem class aims to represent a structure element of a data source.
              * A data source has a tree structure that is made up of a main DataSourceItem object (root)
              * containing other DataSourceItem objects (children).
              * For each DataSourceItem can be associated a set of data representing it.
              */
             class SCIQLOP_CORE_EXPORT DataSourceItem {
             public:
                 /// Key associated with the name of the item
                 static const QString NAME_DATA_KEY;
                 /// Key associated with the plugin of the item
                 static const QString PLUGIN_DATA_KEY;
+                /// Key associated with a unique id of the plugin
+                static const QString ID_DATA_KEY;
                 explicit DataSourceItem(DataSourceItemType type, const QString &name);
                 explicit DataSourceItem(DataSourceItemType type, QVariantHash data = {});
                 std::unique_ptr<DataSourceItem> clone() const;
                 /// @return the actions of the item as a vector
                 QVector<DataSourceItemAction *> actions() const noexcept;
                 /**
                  * Adds an action to the item. The item takes ownership of the action, and the action is
                  * automatically associated to the item
                  * @param action the action to add
                  */
                 void addAction(std::unique_ptr<DataSourceItemAction> action) noexcept;
                 /**
                  * Adds a child to the item. The item takes ownership of the child.
                  * @param child the child to add
                  */
                 void appendChild(std::unique_ptr<DataSourceItem> child) noexcept;
                 /**
                  * Returns the item's child associated to an index
                  * @param childIndex the index to search
                  * @return a pointer to the child if index is valid, nullptr otherwise
                  */
                 DataSourceItem *child(int childIndex) const noexcept;
                 int childCount() const noexcept;
                 /**
                  * Get the data associated to a key
                  * @param key the key to search
                  * @return the data found if key is valid, default QVariant otherwise
                  */
                 QVariant data(const QString &key) const noexcept;
                 /// Gets all data
                 QVariantHash data() const noexcept;
                 /**
                  * Merge in the item the source item passed as parameter.
                  *
                  * The merge is done by adding as child of the item the complete tree represented by the source
                  * item. If a part of the tree already exists in the item (based on the name of the nodes), it
                  * is merged by completing the existing tree by items "leaves" (products, components or nodes
                  * with no child).
                  *
                  * For example, with item representing the tree:
                  * R (root node)
                  *   - N1 (node)
                  *     -- N11 (node)
                  *        --- P1 (product)
                  *        --- P2 (product)
                  *   - N2 (node)
                  *
                  * and the source item representing the tree:
                  * N1 (root node)
                  *   - N11 (node)
                  *     -- P3 (product)
                  *   - N12 (node)
                  *
                  * The leaves of the source item to merge into the item are N1/N11/P3 and N1/N12 => we therefore
                  * have the following merge result:
                  * R
                  *   - N1
                  *     -- N11
                  *        --- P1
                  *        --- P2
                  *        --- P3 (added leaf)
                  *     -- N12 (added leaf)
                  *
                  * @param item the source item
                  * @remarks No control is performed on products or components that are merged into the same tree
                  * part (two products or components may have the same name)
                  * @remarks the merge is made by copy (source item is not changed and still exists after the
                  * operation)
                  */
                 void merge(const DataSourceItem &item);
                 bool isRoot() const noexcept;
                 QString name() const noexcept;
                 /**
                  * Get the item's parent
                  * @return a pointer to the parent if it exists, nullptr if the item is a root
                  */
                 DataSourceItem *parentItem() const noexcept;
                 /**
                  * Gets the item's root
                  * @return the top parent, the item itself if it's the root item
                  */
                 const DataSourceItem &rootItem() const noexcept;
                 /**
                  * Sets or appends a value to a key
                  * @param key the key
                  * @param value the value
                  * @param append if true, the value is added to the values already existing for the key,
                  * otherwise it replaces the existing values
                  */
                 void setData(const QString &key, const QVariant &value, bool append = false) noexcept;
                 DataSourceItemType type() const noexcept;
                 /**
                  * @brief Searches the first child matching the specified data.
                  * @param data The data to search.
                  * @param recursive So the search recursively.
                  * @return the item matching the data or nullptr if it was not found.
                  */
                 DataSourceItem *findItem(const QVariantHash &data, bool recursive);
                 bool operator==(const DataSourceItem &other);
                 bool operator!=(const DataSourceItem &other);
             private:
                 class DataSourceItemPrivate;
                 spimpl::unique_impl_ptr<DataSourceItemPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCEITEMMODEL_H

core/src/Catalogue/CatalogueController.cpp +159 -35

             #include <Catalogue/CatalogueController.h>
             #include <Variable/Variable.h>
             #include <CatalogueDao.h>
             #include <ComparaisonPredicate.h>
             #include <CompoundPredicate.h>
             #include <DBCatalogue.h>
             #include <DBEvent.h>
             #include <DBEventProduct.h>
             #include <DBTag.h>
             #include <IRequestPredicate.h>
+            #include <QDataStream>
             #include <QMutex>
             #include <QThread>
             #include <QDir>
             #include <QStandardPaths>
             Q_LOGGING_CATEGORY(LOG_CatalogueController, "CatalogueController")
             namespace {
-            static QString REPOSITORY_WORK_SUFFIX = QString{"work"};
+            static QString REPOSITORY_WORK_SUFFIX = QString{"_work"};
-            static QString REPOSITORY_TRASH_SUFFIX = QString{"trash"};
+            static QString REPOSITORY_TRASH_SUFFIX = QString{"_trash"};
             }
             class CatalogueController::CatalogueControllerPrivate {
             public:
                 explicit CatalogueControllerPrivate(CatalogueController *parent) : m_Q{parent} {}
-                QMutex m_WorkingMutex;
                 CatalogueDao m_CatalogueDao;
                 QStringList m_RepositoryList;
                 CatalogueController *m_Q;
+                QSet<QString> m_EventKeysWithChanges;
+                QString eventUniqueKey(const std::shared_ptr<DBEvent> &event) const;
                 void copyDBtoDB(const QString &dbFrom, const QString &dbTo);
                 QString toWorkRepository(QString repository);
                 QString toSyncRepository(QString repository);
+                void savAllDB();
+                void saveEvent(std::shared_ptr<DBEvent> event, bool persist = true);
+                void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue, bool persist = true);
             };
             CatalogueController::CatalogueController(QObject *parent)
                     : impl{spimpl::make_unique_impl<CatalogueControllerPrivate>(this)}
             {
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController construction")
                                                    << QThread::currentThread();
             }
             CatalogueController::~CatalogueController()
             {
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController destruction")
                                                    << QThread::currentThread();
-                this->waitForFinish();
             }
             QStringList CatalogueController::getRepositories() const
             {
                 return impl->m_RepositoryList;
             }
             void CatalogueController::addDB(const QString &dbPath)
             {
                 QDir dbDir(dbPath);
                 if (dbDir.exists()) {
                     auto dirName = dbDir.dirName();
                     if (std::find(impl->m_RepositoryList.cbegin(), impl->m_RepositoryList.cend(), dirName)
                         != impl->m_RepositoryList.cend()) {
                         qCCritical(LOG_CatalogueController())
                             << tr("Impossible to addDB that is already loaded");
                     }
                     if (!impl->m_CatalogueDao.addDB(dbPath, dirName)) {
                         qCCritical(LOG_CatalogueController())
                             << tr("Impossible to addDB %1 from %2 ").arg(dirName, dbPath);
                     }
                     else {
                         impl->m_RepositoryList << dirName;
                         impl->copyDBtoDB(dirName, impl->toWorkRepository(dirName));
                     }
                 }
                 else {
                     qCCritical(LOG_CatalogueController()) << tr("Impossible to addDB that not exists: ")
                                                           << dbPath;
                 }
             }
             void CatalogueController::saveDB(const QString &destinationPath, const QString &repository)
             {
                 if (!impl->m_CatalogueDao.saveDB(destinationPath, repository)) {
                     qCCritical(LOG_CatalogueController())
                         << tr("Impossible to saveDB %1 from %2 ").arg(repository, destinationPath);
                 }
             }
             std::list<std::shared_ptr<DBEvent> >
             CatalogueController::retrieveEvents(const QString &repository) const
             {
                 QString dbDireName = repository.isEmpty() ? REPOSITORY_DEFAULT : repository;
                 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
                 auto events = impl->m_CatalogueDao.getEvents(impl->toWorkRepository(dbDireName));
                 for (auto event : events) {
                     eventsShared.push_back(std::make_shared<DBEvent>(event));
                 }
                 return eventsShared;
             }
             std::list<std::shared_ptr<DBEvent> > CatalogueController::retrieveAllEvents() const
             {
                 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
                 for (auto repository : impl->m_RepositoryList) {
                     eventsShared.splice(eventsShared.end(), retrieveEvents(repository));
                 }
                 return eventsShared;
             }
             std::list<std::shared_ptr<DBEvent> >
             CatalogueController::retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const
             {
                 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
                 auto events = impl->m_CatalogueDao.getCatalogueEvents(*catalogue);
                 for (auto event : events) {
                     eventsShared.push_back(std::make_shared<DBEvent>(event));
                 }
                 return eventsShared;
             }
             void CatalogueController::updateEvent(std::shared_ptr<DBEvent> event)
             {
-                event->setRepository(impl->toSyncRepository(event->getRepository()));
+                event->setRepository(impl->toWorkRepository(event->getRepository()));
+                auto uniqueId = impl->eventUniqueKey(event);
+                impl->m_EventKeysWithChanges.insert(uniqueId);
                 impl->m_CatalogueDao.updateEvent(*event);
             }
+            void CatalogueController::updateEventProduct(std::shared_ptr<DBEventProduct> eventProduct)
+            {
+                impl->m_CatalogueDao.updateEventProduct(*eventProduct);
+            }
             void CatalogueController::removeEvent(std::shared_ptr<DBEvent> event)
             {
                 // Remove it from both repository and repository_work
                 event->setRepository(impl->toWorkRepository(event->getRepository()));
                 impl->m_CatalogueDao.removeEvent(*event);
                 event->setRepository(impl->toSyncRepository(event->getRepository()));
                 impl->m_CatalogueDao.removeEvent(*event);
+                impl->savAllDB();
             }
             void CatalogueController::addEvent(std::shared_ptr<DBEvent> event)
             {
                 event->setRepository(impl->toWorkRepository(event->getRepository()));
-                impl->m_CatalogueDao.addEvent(*event);
+                auto eventTemp = *event;
+                impl->m_CatalogueDao.addEvent(eventTemp);
                 // Call update is necessary at the creation of add Event if it has some tags or some event
                 // products
                 if (!event->getEventProducts().empty() || !event->getTags().empty()) {
-                    impl->m_CatalogueDao.updateEvent(*event);
+                    auto eventProductsTemp = eventTemp.getEventProducts();
+                    auto eventProductTempUpdated = std::list<DBEventProduct>{};
+                    for (auto eventProductTemp : eventProductsTemp) {
+                        eventProductTemp.setEvent(eventTemp);
+                        eventProductTempUpdated.push_back(eventProductTemp);
+                    }
+                    eventTemp.setEventProducts(eventProductTempUpdated);
+                    impl->m_CatalogueDao.updateEvent(eventTemp);
                 }
             }
             void CatalogueController::saveEvent(std::shared_ptr<DBEvent> event)
             {
-                impl->m_CatalogueDao.moveEvent(*event, impl->toSyncRepository(event->getRepository()), true);
+                impl->saveEvent(event, true);
+                impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));
+            }
+            void CatalogueController::discardEvent(std::shared_ptr<DBEvent> event)
+            {
+                auto uniqIdPredicate = std::make_shared<ComparaisonPredicate>(
+                    QString{"uniqId"}, event->getUniqId(), ComparaisonOperation::EQUALEQUAL);
+                auto syncRepositoryPredicate = std::make_shared<ComparaisonPredicate>(
+                    QString{"repository"}, impl->toSyncRepository(event->getRepository()),
+                    ComparaisonOperation::EQUALEQUAL);
+                auto syncPred = std::make_shared<CompoundPredicate>(CompoundOperation::AND);
+                syncPred->AddRequestPredicate(uniqIdPredicate);
+                syncPred->AddRequestPredicate(syncRepositoryPredicate);
+                auto workRepositoryPredicate = std::make_shared<ComparaisonPredicate>(
+                    QString{"repository"}, impl->toWorkRepository(event->getRepository()),
+                    ComparaisonOperation::EQUALEQUAL);
+                auto workPred = std::make_shared<CompoundPredicate>(CompoundOperation::AND);
+                workPred->AddRequestPredicate(uniqIdPredicate);
+                workPred->AddRequestPredicate(workRepositoryPredicate);
+                auto syncEvent = impl->m_CatalogueDao.getEvent(syncPred);
+                impl->m_CatalogueDao.copyEvent(syncEvent, impl->toWorkRepository(event->getRepository()), true);
+                auto workEvent = impl->m_CatalogueDao.getEvent(workPred);
+                *event = workEvent;
+                impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));
+            }
+            bool CatalogueController::eventHasChanges(std::shared_ptr<DBEvent> event) const
+            {
+                return impl->m_EventKeysWithChanges.contains(impl->eventUniqueKey(event));
             }
             std::list<std::shared_ptr<DBCatalogue> >
             CatalogueController::retrieveCatalogues(const QString &repository) const
             {
                 QString dbDireName = repository.isEmpty() ? REPOSITORY_DEFAULT : repository;
                 auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};
                 auto catalogues = impl->m_CatalogueDao.getCatalogues(impl->toWorkRepository(dbDireName));
                 for (auto catalogue : catalogues) {
                     cataloguesShared.push_back(std::make_shared<DBCatalogue>(catalogue));
                 }
                 return cataloguesShared;
             }
             void CatalogueController::updateCatalogue(std::shared_ptr<DBCatalogue> catalogue)
             {
-                catalogue->setRepository(impl->toSyncRepository(catalogue->getRepository()));
+                catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
                 impl->m_CatalogueDao.updateCatalogue(*catalogue);
             }
             void CatalogueController::removeCatalogue(std::shared_ptr<DBCatalogue> catalogue)
             {
                 // Remove it from both repository and repository_work
                 catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
                 impl->m_CatalogueDao.removeCatalogue(*catalogue);
                 catalogue->setRepository(impl->toSyncRepository(catalogue->getRepository()));
                 impl->m_CatalogueDao.removeCatalogue(*catalogue);
             }
             void CatalogueController::saveCatalogue(std::shared_ptr<DBCatalogue> catalogue)
             {
-                impl->m_CatalogueDao.moveCatalogue(*catalogue,
+                impl->saveCatalogue(catalogue, true);
-                                                   impl->toSyncRepository(catalogue->getRepository()), true);
             }
             void CatalogueController::saveAll()
             {
                 for (auto repository : impl->m_RepositoryList) {
                     // Save Event
                     auto events = this->retrieveEvents(repository);
                     for (auto event : events) {
-                        this->saveEvent(event);
+                        impl->saveEvent(event, false);
                     }
                     // Save Catalogue
                     auto catalogues = this->retrieveCatalogues(repository);
                     for (auto catalogue : catalogues) {
-                        this->saveCatalogue(catalogue);
+                        impl->saveCatalogue(catalogue, false);
+                    }
+                }
+                impl->savAllDB();
+                impl->m_EventKeysWithChanges.clear();
+            }
+            bool CatalogueController::hasChanges() const
+            {
+                return !impl->m_EventKeysWithChanges.isEmpty(); // TODO: catalogues
+            }
+            QByteArray
+            CatalogueController::mimeDataForEvents(const QVector<std::shared_ptr<DBEvent> > &events) const
+            {
+                auto encodedData = QByteArray{};
+                QMap<QString, QVariantList> idsPerRepository;
+                for (auto event : events) {
+                    idsPerRepository[event->getRepository()] << event->getUniqId();
+                }
+                QDataStream stream{&encodedData, QIODevice::WriteOnly};
+                stream << idsPerRepository;
+                return encodedData;
+            }
+            QVector<std::shared_ptr<DBEvent> >
+            CatalogueController::eventsForMimeData(const QByteArray &mimeData) const
+            {
+                auto events = QVector<std::shared_ptr<DBEvent> >{};
+                QDataStream stream{mimeData};
+                QMap<QString, QVariantList> idsPerRepository;
+                stream >> idsPerRepository;
+                for (auto it = idsPerRepository.cbegin(); it != idsPerRepository.cend(); ++it) {
+                    auto repository = it.key();
+                    auto allRepositoryEvent = retrieveEvents(repository);
+                    for (auto uuid : it.value()) {
+                        for (auto repositoryEvent : allRepositoryEvent) {
+                            if (uuid.toUuid() == repositoryEvent->getUniqId()) {
+                                events << repositoryEvent;
+                            }
+                        }
                     }
                 }
+                return events;
             }
             void CatalogueController::initialize()
             {
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController init")
                                                    << QThread::currentThread();
-                impl->m_WorkingMutex.lock();
                 impl->m_CatalogueDao.initialize();
                 auto defaultRepositoryLocation
                     = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
                 QDir defaultRepositoryLocationDir;
                 if (defaultRepositoryLocationDir.mkpath(defaultRepositoryLocation)) {
                     defaultRepositoryLocationDir.cd(defaultRepositoryLocation);
                     auto defaultRepository = defaultRepositoryLocationDir.absoluteFilePath(REPOSITORY_DEFAULT);
                     qCInfo(LOG_CatalogueController()) << tr("Persistant data loading from: ")
                                                       << defaultRepository;
                     this->addDB(defaultRepository);
                 }
                 else {
                     qCWarning(LOG_CatalogueController())
                         << tr("Cannot load the persistent default repository from ")
                         << defaultRepositoryLocation;
                 }
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController init END");
             }
-            void CatalogueController::finalize()
+            QString CatalogueController::CatalogueControllerPrivate::eventUniqueKey(
+                const std::shared_ptr<DBEvent> &event) const
-                impl->m_WorkingMutex.unlock();
-            void CatalogueController::waitForFinish()
             {
-                QMutexLocker locker{&impl->m_WorkingMutex};
+                return event->getUniqId().toString().append(event->getRepository());
             }
             void CatalogueController::CatalogueControllerPrivate::copyDBtoDB(const QString &dbFrom,
                                                                              const QString &dbTo)
             {
-                auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};
+                //    auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};
                 auto catalogues = m_CatalogueDao.getCatalogues(dbFrom);
+                auto events = m_CatalogueDao.getEvents(dbFrom);
                 for (auto catalogue : catalogues) {
-                    cataloguesShared.push_back(std::make_shared<DBCatalogue>(catalogue));
+                    m_CatalogueDao.copyCatalogue(catalogue, dbTo, true);
                 }
-                auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
-                auto events = m_CatalogueDao.getEvents(dbFrom);
                 for (auto event : events) {
-                    eventsShared.push_back(std::make_shared<DBEvent>(event));
+                    m_CatalogueDao.copyEvent(event, dbTo, true);
-                for (auto catalogue : cataloguesShared) {
-                    m_CatalogueDao.copyCatalogue(*catalogue, dbTo, true);
-                for (auto event : eventsShared) {
-                    m_CatalogueDao.copyEvent(*event, dbTo, true);
                 }
             }
             QString CatalogueController::CatalogueControllerPrivate::toWorkRepository(QString repository)
             {
                 auto syncRepository = toSyncRepository(repository);
-                return QString("%1_%2").arg(syncRepository, REPOSITORY_WORK_SUFFIX);
+                return QString("%1%2").arg(syncRepository, REPOSITORY_WORK_SUFFIX);
             }
             QString CatalogueController::CatalogueControllerPrivate::toSyncRepository(QString repository)
             {
                 auto syncRepository = repository;
                 if (repository.endsWith(REPOSITORY_WORK_SUFFIX)) {
                     syncRepository.remove(REPOSITORY_WORK_SUFFIX);
                 }
                 else if (repository.endsWith(REPOSITORY_TRASH_SUFFIX)) {
                     syncRepository.remove(REPOSITORY_TRASH_SUFFIX);
                 }
                 return syncRepository;
             }
+            void CatalogueController::CatalogueControllerPrivate::savAllDB()
+            {
+                for (auto repository : m_RepositoryList) {
+                    auto defaultRepositoryLocation
+                        = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
+                    m_CatalogueDao.saveDB(defaultRepositoryLocation, repository);
+                }
+            }
+            void CatalogueController::CatalogueControllerPrivate::saveEvent(std::shared_ptr<DBEvent> event,
+                                                                            bool persist)
+            {
+                m_CatalogueDao.copyEvent(*event, toSyncRepository(event->getRepository()), true);
+                if (persist) {
+                    savAllDB();
+                }
+            }
+            void CatalogueController::CatalogueControllerPrivate::saveCatalogue(
+                std::shared_ptr<DBCatalogue> catalogue, bool persist)
+            {
+                m_CatalogueDao.copyCatalogue(*catalogue, toSyncRepository(catalogue->getRepository()), true);
+                if (persist) {
+                    savAllDB();
+                }
+            }

core/src/DataSource/DataSourceItem.cpp +1 0

             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <DataSource/DataSourceItemMergeHelper.h>
             #include <QVector>
             const QString DataSourceItem::NAME_DATA_KEY = QStringLiteral("name");
             const QString DataSourceItem::PLUGIN_DATA_KEY = QStringLiteral("plugin");
+            const QString DataSourceItem::ID_DATA_KEY = QStringLiteral("uuid");
             struct DataSourceItem::DataSourceItemPrivate {
                 explicit DataSourceItemPrivate(DataSourceItemType type, QVariantHash data)
                         : m_Parent{nullptr}, m_Children{}, m_Type{type}, m_Data{std::move(data)}, m_Actions{}
                 {
                 }
                 DataSourceItem *m_Parent;
                 std::vector<std::unique_ptr<DataSourceItem> > m_Children;
                 DataSourceItemType m_Type;
                 QVariantHash m_Data;
                 std::vector<std::unique_ptr<DataSourceItemAction> > m_Actions;
             };
             DataSourceItem::DataSourceItem(DataSourceItemType type, const QString &name)
                     : DataSourceItem{type, QVariantHash{{NAME_DATA_KEY, name}}}
             {
             }
             DataSourceItem::DataSourceItem(DataSourceItemType type, QVariantHash data)
                     : impl{spimpl::make_unique_impl<DataSourceItemPrivate>(type, std::move(data))}
             {
             }
             std::unique_ptr<DataSourceItem> DataSourceItem::clone() const
             {
                 auto result = std::make_unique<DataSourceItem>(impl->m_Type, impl->m_Data);
                 // Clones children
                 for (const auto &child : impl->m_Children) {
                     result->appendChild(std::move(child->clone()));
                 }
                 // Clones actions
                 for (const auto &action : impl->m_Actions) {
                     result->addAction(std::move(action->clone()));
                 }
                 return result;
             }
             QVector<DataSourceItemAction *> DataSourceItem::actions() const noexcept
             {
                 auto result = QVector<DataSourceItemAction *>{};
                 std::transform(std::cbegin(impl->m_Actions), std::cend(impl->m_Actions),
                                std::back_inserter(result), [](const auto &action) { return action.get(); });
                 return result;
             }
             void DataSourceItem::addAction(std::unique_ptr<DataSourceItemAction> action) noexcept
             {
                 action->setDataSourceItem(this);
                 impl->m_Actions.push_back(std::move(action));
             }
             void DataSourceItem::appendChild(std::unique_ptr<DataSourceItem> child) noexcept
             {
                 child->impl->m_Parent = this;
                 impl->m_Children.push_back(std::move(child));
             }
             DataSourceItem *DataSourceItem::child(int childIndex) const noexcept
             {
                 if (childIndex < 0 || childIndex >= childCount()) {
                     return nullptr;
                 }
                 else {
                     return impl->m_Children.at(childIndex).get();
                 }
             }
             int DataSourceItem::childCount() const noexcept
             {
                 return impl->m_Children.size();
             }
             QVariant DataSourceItem::data(const QString &key) const noexcept
             {
                 return impl->m_Data.value(key);
             }
             QVariantHash DataSourceItem::data() const noexcept
             {
                 return impl->m_Data;
             }
             void DataSourceItem::merge(const DataSourceItem &item)
             {
                 DataSourceItemMergeHelper::merge(item, *this);
             }
             bool DataSourceItem::isRoot() const noexcept
             {
                 return impl->m_Parent == nullptr;
             }
             QString DataSourceItem::name() const noexcept
             {
                 return data(NAME_DATA_KEY).toString();
             }
             DataSourceItem *DataSourceItem::parentItem() const noexcept
             {
                 return impl->m_Parent;
             }
             const DataSourceItem &DataSourceItem::rootItem() const noexcept
             {
                 return isRoot() ? *this : parentItem()->rootItem();
             }
             void DataSourceItem::setData(const QString &key, const QVariant &value, bool append) noexcept
             {
                 auto it = impl->m_Data.constFind(key);
                 if (append && it != impl->m_Data.constEnd()) {
                     // Case of an existing value to which we want to add to the new value
                     if (it->canConvert<QVariantList>()) {
                         auto variantList = it->value<QVariantList>();
                         variantList.append(value);
                         impl->m_Data.insert(key, variantList);
                     }
                     else {
                         impl->m_Data.insert(key, QVariantList{*it, value});
                     }
                 }
                 else {
                     // Other cases :
                     // - new value in map OR
                     // - replacement of an existing value (not appending)
                     impl->m_Data.insert(key, value);
                 }
             }
             DataSourceItemType DataSourceItem::type() const noexcept
             {
                 return impl->m_Type;
             }
             DataSourceItem *DataSourceItem::findItem(const QVariantHash &data, bool recursive)
             {
                 for (const auto &child : impl->m_Children) {
                     if (child->impl->m_Data == data) {
                         return child.get();
                     }
                     if (recursive) {
                         if (auto foundItem = child->findItem(data, true)) {
                             return foundItem;
                         }
                     }
                 }
                 return nullptr;
             }
             bool DataSourceItem::operator==(const DataSourceItem &other)
             {
                 // Compares items' attributes
                 if (std::tie(impl->m_Type, impl->m_Data) == std::tie(other.impl->m_Type, other.impl->m_Data)) {
                     // Compares contents of items' children
                     return std::equal(std::cbegin(impl->m_Children), std::cend(impl->m_Children),
                                       std::cbegin(other.impl->m_Children), std::cend(other.impl->m_Children),
                                       [](const auto &itemChild, const auto &otherChild) {
                                           return *itemChild == *otherChild;
                                       });
                 }
                 else {
                     return false;
                 }
             }
             bool DataSourceItem::operator!=(const DataSourceItem &other)
             {
                 return !(*this == other);
             }

gui/include/Catalogue/CatalogueActionManager.h +3 -1

             #ifndef SCIQLOP_CATALOGUEACTIONMANAGER_H
             #define SCIQLOP_CATALOGUEACTIONMANAGER_H
             #include <Common/spimpl.h>
+            class CatalogueExplorer;
             class CatalogueActionManager {
             public:
-                CatalogueActionManager();
+                CatalogueActionManager(CatalogueExplorer *catalogueExplorer);
                 void installSelectionZoneActions();
             private:
                 class CatalogueActionManagerPrivate;
                 spimpl::unique_impl_ptr<CatalogueActionManagerPrivate> impl;
             };
             #endif // SCIQLOP_CATALOGUEACTIONMANAGER_H

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

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

gui/include/Catalogue/CatalogueEventsWidget.h +10 0

             #ifndef SCIQLOP_CATALOGUEEVENTSWIDGET_H
             #define SCIQLOP_CATALOGUEEVENTSWIDGET_H
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             #include <QWidget>
             class DBCatalogue;
             class DBEvent;
             class DBEventProduct;
             class VisualizationWidget;
             namespace Ui {
             class CatalogueEventsWidget;
             }
             Q_DECLARE_LOGGING_CATEGORY(LOG_CatalogueEventsWidget)
             class CatalogueEventsWidget : public QWidget {
                 Q_OBJECT
             signals:
                 void eventsSelected(const QVector<std::shared_ptr<DBEvent> > &event);
                 void eventProductsSelected(
                     const QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > >
                         &eventproducts);
                 void selectionCleared();
             public:
                 explicit CatalogueEventsWidget(QWidget *parent = 0);
                 virtual ~CatalogueEventsWidget();
                 void setVisualizationWidget(VisualizationWidget *visualization);
+                void addEvent(const std::shared_ptr<DBEvent> &event);
                 void setEventChanges(const std::shared_ptr<DBEvent> &event, bool hasChanges);
+                QVector<std::shared_ptr<DBCatalogue> > displayedCatalogues() const;
+                bool isAllEventsDisplayed() const;
+                bool isEventDisplayed(const std::shared_ptr<DBEvent> &event) const;
             public slots:
                 void populateWithCatalogues(const QVector<std::shared_ptr<DBCatalogue> > &catalogues);
                 void populateWithAllEvents();
+                void clear();
+                void refresh();
             private:
                 Ui::CatalogueEventsWidget *ui;
                 class CatalogueEventsWidgetPrivate;
                 spimpl::unique_impl_ptr<CatalogueEventsWidgetPrivate> impl;
+            private slots:
+                void emitSelection();
             };
             #endif // SCIQLOP_CATALOGUEEVENTSWIDGET_H

gui/include/Catalogue/CatalogueExplorer.h +6 0

             #ifndef SCIQLOP_CATALOGUEEXPLORER_H
             #define SCIQLOP_CATALOGUEEXPLORER_H
             #include <Common/spimpl.h>
             #include <QDialog>
             namespace Ui {
             class CatalogueExplorer;
             }
+            class CatalogueEventsWidget;
+            class CatalogueSideBarWidget;
             class VisualizationWidget;
             class CatalogueExplorer : public QDialog {
                 Q_OBJECT
             public:
                 explicit CatalogueExplorer(QWidget *parent = 0);
                 virtual ~CatalogueExplorer();
                 void setVisualizationWidget(VisualizationWidget *visualization);
+                CatalogueEventsWidget &eventsWidget() const;
+                CatalogueSideBarWidget &sideBarWidget() const;
             private:
                 Ui::CatalogueExplorer *ui;
                 class CatalogueExplorerPrivate;
                 spimpl::unique_impl_ptr<CatalogueExplorerPrivate> impl;
             };
             #endif // SCIQLOP_CATALOGUEEXPLORER_H

gui/include/Catalogue/CatalogueSideBarWidget.h +3 0

             #ifndef SCIQLOP_CATALOGUESIDEBARWIDGET_H
             #define SCIQLOP_CATALOGUESIDEBARWIDGET_H
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             #include <QTreeWidgetItem>
             #include <QWidget>
             class DBCatalogue;
             namespace Ui {
             class CatalogueSideBarWidget;
             }
             Q_DECLARE_LOGGING_CATEGORY(LOG_CatalogueSideBarWidget)
             class CatalogueSideBarWidget : public QWidget {
                 Q_OBJECT
             signals:
                 void catalogueSelected(const QVector<std::shared_ptr<DBCatalogue> > &catalogues);
                 void databaseSelected(const QStringList &databases);
                 void allEventsSelected();
                 void trashSelected();
                 void selectionCleared();
             public:
                 explicit CatalogueSideBarWidget(QWidget *parent = 0);
                 virtual ~CatalogueSideBarWidget();
+                void addCatalogue(const std::shared_ptr<DBCatalogue> &catalogue, const QString &repository);
                 void setCatalogueChanges(const std::shared_ptr<DBCatalogue> &catalogue, bool hasChanges);
+                QVector<std::shared_ptr<DBCatalogue> > getCatalogues(const QString &repository) const;
             private:
                 Ui::CatalogueSideBarWidget *ui;
                 class CatalogueSideBarWidgetPrivate;
                 spimpl::unique_impl_ptr<CatalogueSideBarWidgetPrivate> impl;
             private slots:
                 void onContextMenuRequested(const QPoint &pos);
             };
             #endif // SCIQLOP_CATALOGUESIDEBARWIDGET_H

gui/include/Catalogue/CreateEventDialog.h +2 -1

             #ifndef SCIQLOP_CREATEEVENTDIALOG_H
             #define SCIQLOP_CREATEEVENTDIALOG_H
             #include <Common/spimpl.h>
             #include <QDialog>
             #include <memory>
             namespace Ui {
             class CreateEventDialog;
             }
             class DBCatalogue;
             class CreateEventDialog : public QDialog {
                 Q_OBJECT
             public:
-                explicit CreateEventDialog(QWidget *parent = 0);
+                explicit CreateEventDialog(const QVector<std::shared_ptr<DBCatalogue> > &catalogues,
+                                           QWidget *parent = 0);
                 virtual ~CreateEventDialog();
                 void hideCatalogueChoice();
                 QString eventName() const;
                 std::shared_ptr<DBCatalogue> selectedCatalogue() const;
                 QString catalogueName() const;
             private:
                 Ui::CreateEventDialog *ui;
                 class CreateEventDialogPrivate;
                 spimpl::unique_impl_ptr<CreateEventDialogPrivate> impl;
             };
             #endif // SCIQLOP_CREATEEVENTDIALOG_H

gui/meson.build +7 -3

             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',
               'include/Settings/SqpSettingsGeneralWidget.h',
               'include/SidePane/SqpSidePane.h',
               'include/SqpApplication.h',
               'include/DragAndDrop/DragDropScroller.h',
               'include/DragAndDrop/DragDropTabSwitcher.h',
               'include/TimeWidget/TimeWidget.h',
               'include/Variable/VariableInspectorWidget.h',
               'include/Variable/RenameVariableDialog.h',
               'include/Visualization/qcustomplot.h',
               'include/Visualization/VisualizationGraphWidget.h',
               'include/Visualization/VisualizationTabWidget.h',
               'include/Visualization/VisualizationWidget.h',
               'include/Visualization/VisualizationZoneWidget.h',
               'include/Visualization/VisualizationDragDropContainer.h',
               'include/Visualization/VisualizationDragWidget.h',
               'include/Visualization/ColorScaleEditor.h',
               'include/Actions/SelectionZoneAction.h',
               'include/Visualization/VisualizationMultiZoneSelectionDialog.h',
               'include/Catalogue/CatalogueExplorer.h',
               'include/Catalogue/CatalogueEventsWidget.h',
               'include/Catalogue/CatalogueSideBarWidget.h',
               'include/Catalogue/CatalogueInspectorWidget.h',
               'include/Catalogue/CatalogueEventsModel.h',
-              'include/Catalogue/CreateEventDialog.h'
+              'include/Catalogue/CreateEventDialog.h',
+              'include/Catalogue/CatalogueTreeModel.h'
             ]
             gui_ui_files = [
               'ui/DataSource/DataSourceWidget.ui',
               'ui/Settings/SqpSettingsDialog.ui',
               'ui/Settings/SqpSettingsGeneralWidget.ui',
               'ui/SidePane/SqpSidePane.ui',
               'ui/TimeWidget/TimeWidget.ui',
               'ui/Variable/VariableInspectorWidget.ui',
               'ui/Variable/RenameVariableDialog.ui',
               'ui/Variable/VariableMenuHeaderWidget.ui',
               'ui/Visualization/VisualizationGraphWidget.ui',
               'ui/Visualization/VisualizationTabWidget.ui',
               'ui/Visualization/VisualizationWidget.ui',
               'ui/Visualization/VisualizationZoneWidget.ui',
               'ui/Visualization/ColorScaleEditor.ui',
               'ui/Visualization/VisualizationMultiZoneSelectionDialog.ui',
               'ui/Catalogue/CatalogueExplorer.ui',
               'ui/Catalogue/CatalogueEventsWidget.ui',
               'ui/Catalogue/CatalogueSideBarWidget.ui',
               'ui/Catalogue/CatalogueInspectorWidget.ui',
               'ui/Catalogue/CreateEventDialog.ui'
             ]
             gui_qresources = ['resources/sqpguiresources.qrc']
             rcc_gen = generator(rcc,
                             output  : 'qrc_@BASENAME@.cpp',
                             arguments : [
                              '--output',
                              '@OUTPUT@',
                              '@INPUT@',
                              '@EXTRA_ARGS@'])
             rcc_files = rcc_gen.process(gui_qresources, extra_args : ['-name', 'sqpguiresources'])
             gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers,
                                            ui_files : gui_ui_files)
             gui_sources = [
               'src/SqpApplication.cpp',
               'src/DragAndDrop/DragDropGuiController.cpp',
               'src/DragAndDrop/DragDropScroller.cpp',
               'src/DragAndDrop/DragDropTabSwitcher.cpp',
               'src/Common/ColorUtils.cpp',
               'src/Common/VisualizationDef.cpp',
               'src/DataSource/DataSourceTreeWidgetItem.cpp',
               'src/DataSource/DataSourceTreeWidgetHelper.cpp',
               'src/DataSource/DataSourceWidget.cpp',
               'src/DataSource/DataSourceTreeWidget.cpp',
               'src/Settings/SqpSettingsDialog.cpp',
               'src/Settings/SqpSettingsGeneralWidget.cpp',
               'src/SidePane/SqpSidePane.cpp',
               'src/TimeWidget/TimeWidget.cpp',
               'src/Variable/VariableInspectorWidget.cpp',
               'src/Variable/VariableInspectorTableView.cpp',
               'src/Variable/VariableMenuHeaderWidget.cpp',
               'src/Variable/RenameVariableDialog.cpp',
               'src/Visualization/VisualizationGraphHelper.cpp',
               'src/Visualization/VisualizationGraphRenderingDelegate.cpp',
               'src/Visualization/VisualizationGraphWidget.cpp',
               'src/Visualization/VisualizationTabWidget.cpp',
               'src/Visualization/VisualizationWidget.cpp',
               'src/Visualization/VisualizationZoneWidget.cpp',
               'src/Visualization/qcustomplot.cpp',
               'src/Visualization/QCustomPlotSynchronizer.cpp',
               'src/Visualization/operations/FindVariableOperation.cpp',
               'src/Visualization/operations/GenerateVariableMenuOperation.cpp',
               'src/Visualization/operations/MenuBuilder.cpp',
               'src/Visualization/operations/RemoveVariableOperation.cpp',
               'src/Visualization/operations/RescaleAxeOperation.cpp',
               'src/Visualization/VisualizationDragDropContainer.cpp',
               'src/Visualization/VisualizationDragWidget.cpp',
               'src/Visualization/AxisRenderingUtils.cpp',
               'src/Visualization/PlottablesRenderingUtils.cpp',
               'src/Visualization/MacScrollBarStyle.cpp',
               'src/Visualization/VisualizationCursorItem.cpp',
               'src/Visualization/ColorScaleEditor.cpp',
               'src/Visualization/SqpColorScale.cpp',
               'src/Visualization/QCPColorMapIterator.cpp',
               'src/Visualization/VisualizationSelectionZoneItem.cpp',
               'src/Visualization/VisualizationSelectionZoneManager.cpp',
               'src/Actions/SelectionZoneAction.cpp',
               'src/Actions/ActionsGuiController.cpp',
               'src/Visualization/VisualizationActionManager.cpp',
               'src/Visualization/VisualizationMultiZoneSelectionDialog.cpp',
               'src/Catalogue/CatalogueExplorer.cpp',
               'src/Catalogue/CatalogueEventsWidget.cpp',
               'src/Catalogue/CatalogueSideBarWidget.cpp',
               'src/Catalogue/CatalogueInspectorWidget.cpp',
-              'src/Catalogue/CatalogueTreeWidgetItem.cpp',
+              'src/Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.cpp',
+              'src/Catalogue/CatalogueTreeItems/CatalogueTreeItem.cpp',
+              'src/Catalogue/CatalogueTreeItems/CatalogueTextTreeItem.cpp',
               'src/Catalogue/CatalogueEventsModel.cpp',
               'src/Catalogue/CatalogueExplorerHelper.cpp',
               'src/Catalogue/CatalogueActionManager.cpp',
-              'src/Catalogue/CreateEventDialog.cpp'
+              'src/Catalogue/CreateEventDialog.cpp',
+              'src/Catalogue/CatalogueTreeModel.cpp'
             ]
             gui_inc = include_directories(['include'])
             sciqlop_gui_lib = library('sciqlopgui',
                                    gui_sources,
                                    gui_moc_files,
                                    rcc_files,
                                    include_directories : [gui_inc],
                                    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, catalogueapi_dep])

gui/src/Catalogue/CatalogueActionManager.cpp +34 -5

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

gui/src/Catalogue/CatalogueEventsModel.cpp +49 -30

             #include "Catalogue/CatalogueEventsModel.h"
+            #include <Catalogue/CatalogueController.h>
             #include <Common/DateUtils.h>
             #include <Common/MimeTypesDef.h>
             #include <DBEvent.h>
             #include <DBEventProduct.h>
             #include <DBTag.h>
             #include <Data/SqpRange.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <list>
             #include <unordered_map>
             #include <QHash>
             #include <QMimeData>
             Q_LOGGING_CATEGORY(LOG_CatalogueEventsModel, "CatalogueEventsModel")
             const auto EVENT_ITEM_TYPE = 1;
             const auto EVENT_PRODUCT_ITEM_TYPE = 2;
             struct CatalogueEventsModel::CatalogueEventsModelPrivate {
                 QVector<std::shared_ptr<DBEvent> > m_Events;
                 std::unordered_map<DBEvent *, QVector<std::shared_ptr<DBEventProduct> > > m_EventProducts;
-                std::unordered_set<std::shared_ptr<DBEvent> > m_EventsWithChanges;
                 QStringList columnNames()
                 {
                     return QStringList{tr("Event"), tr("TStart"),  tr("TEnd"),
                                        tr("Tags"),  tr("Product"), tr("")};
                 }
                 QVariant sortData(int col, const std::shared_ptr<DBEvent> &event) const
                 {
                     if (col == (int)CatalogueEventsModel::Column::Validation) {
-                        return m_EventsWithChanges.find(event) != m_EventsWithChanges.cend() ? true
+                        auto hasChanges = sqpApp->catalogueController().eventHasChanges(event);
-                                                                                             : QVariant();
+                        return hasChanges ? true : QVariant();
                     }
                     return eventData(col, event);
                 }
                 QVariant eventData(int col, const std::shared_ptr<DBEvent> &event) const
                 {
                     switch (static_cast<Column>(col)) {
                         case CatalogueEventsModel::Column::Name:
                             return event->getName();
                         case CatalogueEventsModel::Column::TStart:
                             return nbEventProducts(event) > 0 ? DateUtils::dateTime(event->getTStart())
                                                               : QVariant{};
                         case CatalogueEventsModel::Column::TEnd:
                             return nbEventProducts(event) > 0 ? DateUtils::dateTime(event->getTEnd())
                                                               : QVariant{};
                         case CatalogueEventsModel::Column::Product:
                             return QString::number(nbEventProducts(event)) + " product(s)";
                         case CatalogueEventsModel::Column::Tags: {
                             QString tagList;
                             auto tags = event->getTags();
                             for (auto tag : tags) {
                                 tagList += tag.getName();
                                 tagList += ' ';
                             }
                             return tagList;
                         }
                         case CatalogueEventsModel::Column::Validation:
                             return QVariant();
                         default:
                             break;
                     }
                     Q_ASSERT(false);
                     return QStringLiteral("Unknown Data");
                 }
                 void parseEventProduct(const std::shared_ptr<DBEvent> &event)
                 {
                     for (auto product : event->getEventProducts()) {
                         m_EventProducts[event.get()].append(std::make_shared<DBEventProduct>(product));
                     }
                 }
                 int nbEventProducts(const std::shared_ptr<DBEvent> &event) const
                 {
                     auto eventProductsIt = m_EventProducts.find(event.get());
                     if (eventProductsIt != m_EventProducts.cend()) {
                         return m_EventProducts.at(event.get()).count();
                     }
                     else {
                         return 0;
                     }
                 }
                 QVariant eventProductData(int col, const std::shared_ptr<DBEventProduct> &eventProduct) const
                 {
                     switch (static_cast<Column>(col)) {
                         case CatalogueEventsModel::Column::Name:
                             return eventProduct->getProductId();
                         case CatalogueEventsModel::Column::TStart:
                             return DateUtils::dateTime(eventProduct->getTStart());
                         case CatalogueEventsModel::Column::TEnd:
                             return DateUtils::dateTime(eventProduct->getTEnd());
                         case CatalogueEventsModel::Column::Product:
                             return eventProduct->getProductId();
                         case CatalogueEventsModel::Column::Tags:
                             return QString();
                         case CatalogueEventsModel::Column::Validation:
                             return QVariant();
                         default:
                             break;
                     }
                     Q_ASSERT(false);
                     return QStringLiteral("Unknown Data");
                 }
+                void refreshChildrenOfIndex(CatalogueEventsModel *model, const QModelIndex &index) const
+                {
+                    auto childCount = model->rowCount(index);
+                    auto colCount = model->columnCount();
+                    emit model->dataChanged(model->index(0, 0, index),
+                                            model->index(childCount, colCount, index));
+                }
             };
             CatalogueEventsModel::CatalogueEventsModel(QObject *parent)
                     : QAbstractItemModel(parent), impl{spimpl::make_unique_impl<CatalogueEventsModelPrivate>()}
             {
             }
             void CatalogueEventsModel::setEvents(const QVector<std::shared_ptr<DBEvent> > &events)
             {
                 beginResetModel();
                 impl->m_Events = events;
                 impl->m_EventProducts.clear();
-                impl->m_EventsWithChanges.clear();
                 for (auto event : events) {
                     impl->parseEventProduct(event);
                 }
                 endResetModel();
             }
             std::shared_ptr<DBEvent> CatalogueEventsModel::getEvent(const QModelIndex &index) const
             {
                 if (itemTypeOf(index) == CatalogueEventsModel::ItemType::Event) {
                     return impl->m_Events.value(index.row());
                 }
                 else {
                     return nullptr;
                 }
             }
             std::shared_ptr<DBEvent> CatalogueEventsModel::getParentEvent(const QModelIndex &index) const
             {
                 if (itemTypeOf(index) == CatalogueEventsModel::ItemType::EventProduct) {
                     return getEvent(index.parent());
                 }
                 else {
                     return nullptr;
                 }
             }
             std::shared_ptr<DBEventProduct>
             CatalogueEventsModel::getEventProduct(const QModelIndex &index) const
             {
                 if (itemTypeOf(index) == CatalogueEventsModel::ItemType::EventProduct) {
                     auto event = static_cast<DBEvent *>(index.internalPointer());
                     return impl->m_EventProducts.at(event).value(index.row());
                 }
                 else {
                     return nullptr;
                 }
             }
             void CatalogueEventsModel::addEvent(const std::shared_ptr<DBEvent> &event)
             {
-                beginInsertRows(QModelIndex(), impl->m_Events.count() - 1, impl->m_Events.count() - 1);
+                beginInsertRows(QModelIndex(), impl->m_Events.count(), impl->m_Events.count());
                 impl->m_Events.append(event);
                 impl->parseEventProduct(event);
                 endInsertRows();
+                // Also refreshes its children event products
+                auto eventIndex = index(impl->m_Events.count(), 0);
+                impl->refreshChildrenOfIndex(this, eventIndex);
             }
             void CatalogueEventsModel::removeEvent(const std::shared_ptr<DBEvent> &event)
             {
                 auto index = impl->m_Events.indexOf(event);
                 if (index >= 0) {
                     beginRemoveRows(QModelIndex(), index, index);
                     impl->m_Events.removeAt(index);
                     impl->m_EventProducts.erase(event.get());
-                    impl->m_EventsWithChanges.erase(event);
                     endRemoveRows();
                 }
             }
             QVector<std::shared_ptr<DBEvent> > CatalogueEventsModel::events() const
             {
                 return impl->m_Events;
             }
-            void CatalogueEventsModel::refreshEvent(const std::shared_ptr<DBEvent> &event)
+            void CatalogueEventsModel::refreshEvent(const std::shared_ptr<DBEvent> &event,
+                                                    bool refreshEventProducts)
             {
                 auto eventIndex = indexOf(event);
                 if (eventIndex.isValid()) {
+                    if (refreshEventProducts) {
+                        // Reparse the associated event products
+                        auto nbEventProducts = impl->nbEventProducts(event);
+                        auto newNbOfEventProducts = event->getEventProducts().size();
+                        if (newNbOfEventProducts < nbEventProducts) {
+                            beginRemoveRows(eventIndex, newNbOfEventProducts, nbEventProducts - 1);
+                            impl->m_EventProducts.erase(event.get());
+                            impl->parseEventProduct(event);
+                            endRemoveRows();
+                        }
+                        else if (newNbOfEventProducts > nbEventProducts) {
+                            beginInsertRows(eventIndex, nbEventProducts, newNbOfEventProducts - 1);
+                            impl->m_EventProducts.erase(event.get());
+                            impl->parseEventProduct(event);
+                            endInsertRows();
+                        }
+                        else { // newNbOfEventProducts == nbEventProducts
+                            impl->m_EventProducts.erase(event.get());
+                            impl->parseEventProduct(event);
+                        }
+                    }
                     // Refreshes the event line
                     auto colCount = columnCount();
                     emit dataChanged(eventIndex, index(eventIndex.row(), colCount));
                     // Also refreshes its children event products
-                    auto childCount = rowCount(eventIndex);
+                    impl->refreshChildrenOfIndex(this, eventIndex);
-                    emit dataChanged(index(0, 0, eventIndex), index(childCount, colCount, eventIndex));
                 }
                 else {
                     qCWarning(LOG_CatalogueEventsModel()) << "refreshEvent: event not found.";
                 }
             }
             QModelIndex CatalogueEventsModel::indexOf(const std::shared_ptr<DBEvent> &event) const
             {
                 auto row = impl->m_Events.indexOf(event);
                 if (row >= 0) {
                     return index(row, 0);
                 }
                 return QModelIndex();
             }
-            void CatalogueEventsModel::setEventHasChanges(const std::shared_ptr<DBEvent> &event,
-                                                          bool hasChanges)
-                if (hasChanges) {
-                    impl->m_EventsWithChanges.insert(event);
-                else {
-                    impl->m_EventsWithChanges.erase(event);
-            bool CatalogueEventsModel::eventsHasChanges(const std::shared_ptr<DBEvent> &event) const
-                return impl->m_EventsWithChanges.find(event) != impl->m_EventsWithChanges.cend();
             QModelIndex CatalogueEventsModel::index(int row, int column, const QModelIndex &parent) const
             {
                 if (!hasIndex(row, column, parent)) {
                     return QModelIndex();
                 }
                 switch (itemTypeOf(parent)) {
                     case CatalogueEventsModel::ItemType::Root:
                         return createIndex(row, column);
                     case CatalogueEventsModel::ItemType::Event: {
                         auto event = getEvent(parent);
                         return createIndex(row, column, event.get());
                     }
                     case CatalogueEventsModel::ItemType::EventProduct:
                         break;
                     default:
                         break;
                 }
                 return QModelIndex();
             }
             QModelIndex CatalogueEventsModel::parent(const QModelIndex &index) const
             {
                 switch (itemTypeOf(index)) {
                     case CatalogueEventsModel::ItemType::EventProduct: {
                         auto parentEvent = static_cast<DBEvent *>(index.internalPointer());
                         auto it
                             = std::find_if(impl->m_Events.cbegin(), impl->m_Events.cend(),
                                            [parentEvent](auto event) { return event.get() == parentEvent; });
                         if (it != impl->m_Events.cend()) {
                             return createIndex(it - impl->m_Events.cbegin(), 0);
                         }
                         else {
                             return QModelIndex();
                         }
                     }
                     case CatalogueEventsModel::ItemType::Root:
                         break;
                     case CatalogueEventsModel::ItemType::Event:
                         break;
                     default:
                         break;
                 }
                 return QModelIndex();
             }
             int CatalogueEventsModel::rowCount(const QModelIndex &parent) const
             {
                 if (parent.column() > 0) {
                     return 0;
                 }
                 switch (itemTypeOf(parent)) {
                     case CatalogueEventsModel::ItemType::Root:
                         return impl->m_Events.count();
                     case CatalogueEventsModel::ItemType::Event: {
                         auto event = getEvent(parent);
                         return impl->m_EventProducts[event.get()].count();
                     }
                     case CatalogueEventsModel::ItemType::EventProduct:
                         break;
                     default:
                         break;
                 }
                 return 0;
             }
             int CatalogueEventsModel::columnCount(const QModelIndex &parent) const
             {
                 return static_cast<int>(CatalogueEventsModel::Column::NbColumn);
             }
             Qt::ItemFlags CatalogueEventsModel::flags(const QModelIndex &index) const
             {
                 return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
             }
             QVariant CatalogueEventsModel::data(const QModelIndex &index, int role) const
             {
                 if (index.isValid()) {
                     auto type = itemTypeOf(index);
                     if (type == CatalogueEventsModel::ItemType::Event) {
                         auto event = getEvent(index);
                         switch (role) {
                             case Qt::DisplayRole:
                                 return impl->eventData(index.column(), event);
                                 break;
                         }
                     }
                     else if (type == CatalogueEventsModel::ItemType::EventProduct) {
                         auto product = getEventProduct(index);
                         switch (role) {
                             case Qt::DisplayRole:
                                 return impl->eventProductData(index.column(), product);
                                 break;
                         }
                     }
                 }
                 return QVariant{};
             }
             QVariant CatalogueEventsModel::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
                     return impl->columnNames().value(section);
                 }
                 return QVariant();
             }
             void CatalogueEventsModel::sort(int column, Qt::SortOrder order)
             {
+                beginResetModel();
                 std::sort(impl->m_Events.begin(), impl->m_Events.end(),
                           [this, column, order](auto e1, auto e2) {
                               auto data1 = impl->sortData(column, e1);
                               auto data2 = impl->sortData(column, e2);
                               auto result = data1.toString() < data2.toString();
                               return order == Qt::AscendingOrder ? result : !result;
                           });
-                emit dataChanged(QModelIndex(), QModelIndex());
+                endResetModel();
                 emit modelSorted();
             }
             Qt::DropActions CatalogueEventsModel::supportedDragActions() const
             {
-                return Qt::CopyAction | Qt::MoveAction;
+                return Qt::CopyAction;
             }
             QStringList CatalogueEventsModel::mimeTypes() const
             {
                 return {MIME_TYPE_EVENT_LIST, MIME_TYPE_TIME_RANGE};
             }
             QMimeData *CatalogueEventsModel::mimeData(const QModelIndexList &indexes) const
             {
                 auto mimeData = new QMimeData;
                 bool isFirst = true;
                 QVector<std::shared_ptr<DBEvent> > eventList;
                 QVector<std::shared_ptr<DBEventProduct> > eventProductList;
                 SqpRange firstTimeRange;
                 for (const auto &index : indexes) {
                     if (index.column() == 0) { // only the first column
                         auto type = itemTypeOf(index);
                         if (type == ItemType::Event) {
                             auto event = getEvent(index);
                             eventList << event;
                             if (isFirst) {
                                 isFirst = false;
                                 firstTimeRange.m_TStart = event->getTStart();
                                 firstTimeRange.m_TEnd = event->getTEnd();
                             }
                         }
                         else if (type == ItemType::EventProduct) {
                             auto product = getEventProduct(index);
                             eventProductList << product;
                             if (isFirst) {
                                 isFirst = false;
                                 firstTimeRange.m_TStart = product->getTStart();
                                 firstTimeRange.m_TEnd = product->getTEnd();
                             }
                         }
                     }
                 }
-                auto eventsEncodedData
+                if (!eventList.isEmpty() && eventProductList.isEmpty()) {
-                    = QByteArray{}; // sqpApp->catalogueController().->mimeDataForEvents(eventList); //TODO
+                    auto eventsEncodedData = sqpApp->catalogueController().mimeDataForEvents(eventList);
-                mimeData->setData(MIME_TYPE_EVENT_LIST, eventsEncodedData);
+                    mimeData->setData(MIME_TYPE_EVENT_LIST, eventsEncodedData);
+                }
                 if (eventList.count() + eventProductList.count() == 1) {
                     // No time range MIME data if multiple events are dragged
                     auto timeEncodedData = TimeController::mimeDataForTimeRange(firstTimeRange);
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeEncodedData);
                 }
                 return mimeData;
             }
             CatalogueEventsModel::ItemType CatalogueEventsModel::itemTypeOf(const QModelIndex &index) const
             {
                 if (!index.isValid()) {
                     return ItemType::Root;
                 }
                 else if (index.internalPointer() == nullptr) {
                     return ItemType::Event;
                 }
                 else {
                     return ItemType::EventProduct;
                 }
             }

gui/src/Catalogue/CatalogueEventsWidget.cpp +138 -38

             #include "Catalogue/CatalogueEventsWidget.h"
             #include "ui_CatalogueEventsWidget.h"
             #include <Catalogue/CatalogueController.h>
             #include <Catalogue/CatalogueEventsModel.h>
             #include <Catalogue/CatalogueExplorerHelper.h>
             #include <CatalogueDao.h>
             #include <DBCatalogue.h>
             #include <SqpApplication.h>
             #include <Visualization/VisualizationTabWidget.h>
             #include <Visualization/VisualizationWidget.h>
             #include <Visualization/VisualizationZoneWidget.h>
             #include <QDialog>
             #include <QDialogButtonBox>
             #include <QListWidget>
+            #include <QMessageBox>
             Q_LOGGING_CATEGORY(LOG_CatalogueEventsWidget, "CatalogueEventsWidget")
             /// Fixed size of the validation column
             const auto VALIDATION_COLUMN_SIZE = 35;
             struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
                 CatalogueEventsModel *m_Model = nullptr;
                 QStringList m_ZonesForTimeMode;
                 QString m_ZoneForGraphMode;
+                QVector<std::shared_ptr<DBCatalogue> > m_DisplayedCatalogues;
                 VisualizationWidget *m_VisualizationWidget = nullptr;
-                void setEvents(const QVector<std::shared_ptr<DBEvent> > &events, QTreeView *treeView)
+                void setEvents(const QVector<std::shared_ptr<DBEvent> > &events, CatalogueEventsWidget *widget)
                 {
-                    treeView->setSortingEnabled(false);
+                    widget->ui->treeView->setSortingEnabled(false);
                     m_Model->setEvents(events);
-                    treeView->setSortingEnabled(true);
+                    widget->ui->treeView->setSortingEnabled(true);
+                    for (auto event : events) {
+                        if (sqpApp->catalogueController().eventHasChanges(event)) {
+                            auto index = m_Model->indexOf(event);
+                            widget->setEventChanges(event, true);
+                        }
+                    }
                 }
                 void addEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
                 {
                     treeView->setSortingEnabled(false);
                     m_Model->addEvent(event);
                     treeView->setSortingEnabled(true);
                 }
                 void removeEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
                 {
                     treeView->setSortingEnabled(false);
                     m_Model->removeEvent(event);
                     treeView->setSortingEnabled(true);
                 }
                 QStringList getAvailableVisualizationZoneList() const
                 {
                     if (m_VisualizationWidget) {
                         if (auto tab = m_VisualizationWidget->currentTabWidget()) {
                             return tab->availableZoneWidgets();
                         }
                     }
                     return QStringList{};
                 }
                 QStringList selectZone(QWidget *parent, const QStringList &selectedZones,
                                        bool allowMultiSelection, const QPoint &location)
                 {
                     auto availableZones = getAvailableVisualizationZoneList();
                     if (availableZones.isEmpty()) {
                         return QStringList{};
                     }
                     QDialog d(parent, Qt::Tool);
                     d.setWindowTitle("Choose a zone");
                     auto layout = new QVBoxLayout{&d};
                     layout->setContentsMargins(0, 0, 0, 0);
                     auto listWidget = new QListWidget{&d};
                     layout->addWidget(listWidget);
                     QSet<QListWidgetItem *> checkedItems;
                     for (auto zone : availableZones) {
                         auto item = new QListWidgetItem{zone};
                         item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
                         if (selectedZones.contains(zone)) {
                             item->setCheckState(Qt::Checked);
                             checkedItems << item;
                         }
                         else {
                             item->setCheckState(Qt::Unchecked);
                         }
                         listWidget->addItem(item);
                     }
                     auto buttonBox = new QDialogButtonBox{QDialogButtonBox::Ok, &d};
                     layout->addWidget(buttonBox);
                     QObject::connect(buttonBox, &QDialogButtonBox::accepted, &d, &QDialog::accept);
                     QObject::connect(buttonBox, &QDialogButtonBox::rejected, &d, &QDialog::reject);
                     QObject::connect(listWidget, &QListWidget::itemChanged,
                                      [&checkedItems, allowMultiSelection, listWidget](auto item) {
                                          if (item->checkState() == Qt::Checked) {
                                              if (!allowMultiSelection) {
                                                  for (auto checkedItem : checkedItems) {
                                                      listWidget->blockSignals(true);
                                                      checkedItem->setCheckState(Qt::Unchecked);
                                                      listWidget->blockSignals(false);
                                                  }
                                                  checkedItems.clear();
                                              }
                                              checkedItems << item;
                                          }
                                          else {
                                              checkedItems.remove(item);
                                          }
                                      });
                     QStringList result;
                     d.setMinimumWidth(120);
                     d.resize(d.minimumSizeHint());
                     d.move(location);
                     if (d.exec() == QDialog::Accepted) {
                         for (auto item : checkedItems) {
                             result += item->text();
                         }
                     }
                     else {
                         result = selectedZones;
                     }
                     return result;
                 }
                 void updateForTimeMode(QTreeView *treeView)
                 {
                     auto selectedRows = treeView->selectionModel()->selectedRows();
                     if (selectedRows.count() == 1) {
                         auto event = m_Model->getEvent(selectedRows.first());
                         if (event) {
                             if (m_VisualizationWidget) {
                                 if (auto tab = m_VisualizationWidget->currentTabWidget()) {
                                     for (auto zoneName : m_ZonesForTimeMode) {
                                         if (auto zone = tab->getZoneWithName(zoneName)) {
                                             SqpRange eventRange;
                                             eventRange.m_TStart = event->getTStart();
                                             eventRange.m_TEnd = event->getTEnd();
                                             zone->setZoneRange(eventRange);
                                         }
                                     }
                                 }
                                 else {
                                     qCWarning(LOG_CatalogueEventsWidget())
                                         << "updateTimeZone: no tab found in the visualization";
                                 }
                             }
                             else {
                                 qCWarning(LOG_CatalogueEventsWidget())
                                     << "updateTimeZone: visualization widget not found";
                             }
                         }
                     }
                     else {
                         qCWarning(LOG_CatalogueEventsWidget())
                             << "updateTimeZone: not compatible with multiple events selected";
                     }
                 }
                 void updateForGraphMode(QTreeView *treeView)
                 {
                     auto selectedRows = treeView->selectionModel()->selectedRows();
                     if (selectedRows.count() == 1) {
                         auto event = m_Model->getEvent(selectedRows.first());
                         if (m_VisualizationWidget) {
                             if (auto tab = m_VisualizationWidget->currentTabWidget()) {
                                 if (auto zone = tab->getZoneWithName(m_ZoneForGraphMode)) {
                                     // TODO
                                 }
                             }
                             else {
                                 qCWarning(LOG_CatalogueEventsWidget())
                                     << "updateGraphMode: no tab found in the visualization";
                             }
                         }
                         else {
                             qCWarning(LOG_CatalogueEventsWidget())
                                 << "updateGraphMode: visualization widget not found";
                         }
                     }
                     else {
                         qCWarning(LOG_CatalogueEventsWidget())
                             << "updateGraphMode: not compatible with multiple events selected";
                     }
                 }
+                void getSelectedItems(
+                    QTreeView *treeView, QVector<std::shared_ptr<DBEvent> > &events,
+                    QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > &eventProducts)
+                {
+                    for (auto rowIndex : treeView->selectionModel()->selectedRows()) {
+                        auto itemType = m_Model->itemTypeOf(rowIndex);
+                        if (itemType == CatalogueEventsModel::ItemType::Event) {
+                            events << m_Model->getEvent(rowIndex);
+                        }
+                        else if (itemType == CatalogueEventsModel::ItemType::EventProduct) {
+                            eventProducts << qMakePair(m_Model->getParentEvent(rowIndex),
+                                                       m_Model->getEventProduct(rowIndex));
+                        }
+                    }
+                }
             };
             CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
                     : QWidget(parent),
                       ui(new Ui::CatalogueEventsWidget),
                       impl{spimpl::make_unique_impl<CatalogueEventsWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 impl->m_Model = new CatalogueEventsModel{this};
                 ui->treeView->setModel(impl->m_Model);
                 ui->treeView->setSortingEnabled(true);
                 ui->treeView->setDragDropMode(QAbstractItemView::DragDrop);
                 ui->treeView->setDragEnabled(true);
                 connect(ui->btnTime, &QToolButton::clicked, [this](auto checked) {
                     if (checked) {
                         ui->btnChart->setChecked(false);
                         impl->m_ZonesForTimeMode
                             = impl->selectZone(this, impl->m_ZonesForTimeMode, true,
                                                this->mapToGlobal(ui->btnTime->frameGeometry().center()));
                         impl->updateForTimeMode(ui->treeView);
                     }
                 });
                 connect(ui->btnChart, &QToolButton::clicked, [this](auto checked) {
                     if (checked) {
                         ui->btnTime->setChecked(false);
                         impl->m_ZoneForGraphMode
                             = impl->selectZone(this, {impl->m_ZoneForGraphMode}, false,
                                                this->mapToGlobal(ui->btnChart->frameGeometry().center()))
                                   .value(0);
                         impl->updateForGraphMode(ui->treeView);
                     }
                 });
-                auto emitSelection = [this]() {
+                connect(ui->btnRemove, &QToolButton::clicked, [this]() {
                     QVector<std::shared_ptr<DBEvent> > events;
                     QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
+                    impl->getSelectedItems(ui->treeView, events, eventProducts);
-                    for (auto rowIndex : ui->treeView->selectionModel()->selectedRows()) {
+                    if (!events.isEmpty() && eventProducts.isEmpty()) {
-                        auto itemType = impl->m_Model->itemTypeOf(rowIndex);
+                        if (QMessageBox::warning(this, tr("Remove Event(s)"),
-                        if (itemType == CatalogueEventsModel::ItemType::Event) {
+                                                 tr("The selected event(s) will be completly removed "
-                            events << impl->m_Model->getEvent(rowIndex);
+                                                    "from the repository!\nAre you sure you want to continue?"),
+                                                 QMessageBox::Yes | QMessageBox::No, QMessageBox::No)
-                        else if (itemType == CatalogueEventsModel::ItemType::EventProduct) {
+                            == QMessageBox::Yes) {
-                            eventProducts << qMakePair(impl->m_Model->getParentEvent(rowIndex),
-                                                       impl->m_Model->getEventProduct(rowIndex));
-                    if (!events.isEmpty() && eventProducts.isEmpty()) {
+                            for (auto event : events) {
-                        emit this->eventsSelected(events);
+                                sqpApp->catalogueController().removeEvent(event);
+                                impl->removeEvent(event, ui->treeView);
-                    else if (events.isEmpty() && !eventProducts.isEmpty()) {
-                        emit this->eventProductsSelected(eventProducts);
-                    else {
-                        emit this->selectionCleared();
                     }
-                };
+                });
-                connect(ui->treeView, &QTreeView::clicked, emitSelection);
+                connect(ui->treeView, &QTreeView::clicked, this, &CatalogueEventsWidget::emitSelection);
-                connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, emitSelection);
+                connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, this,
+                        &CatalogueEventsWidget::emitSelection);
+                ui->btnRemove->setEnabled(false); // Disabled by default when nothing is selected
                 connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, [this]() {
                     auto isNotMultiSelection = ui->treeView->selectionModel()->selectedRows().count() <= 1;
                     ui->btnChart->setEnabled(isNotMultiSelection);
                     ui->btnTime->setEnabled(isNotMultiSelection);
                     if (isNotMultiSelection && ui->btnTime->isChecked()) {
                         impl->updateForTimeMode(ui->treeView);
                     }
                     else if (isNotMultiSelection && ui->btnChart->isChecked()) {
                         impl->updateForGraphMode(ui->treeView);
                     }
+                    QVector<std::shared_ptr<DBEvent> > events;
+                    QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
+                    impl->getSelectedItems(ui->treeView, events, eventProducts);
+                    ui->btnRemove->setEnabled(!events.isEmpty() && eventProducts.isEmpty());
                 });
                 ui->treeView->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
-                ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Name,
+                ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Tags,
                                                              QHeaderView::Stretch);
                 ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Validation,
                                                              QHeaderView::Fixed);
+                ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Name,
+                                                             QHeaderView::Interactive);
                 ui->treeView->header()->resizeSection((int)CatalogueEventsModel::Column::Validation,
                                                       VALIDATION_COLUMN_SIZE);
                 ui->treeView->header()->setSortIndicatorShown(true);
                 connect(impl->m_Model, &CatalogueEventsModel::modelSorted, [this]() {
                     auto allEvents = impl->m_Model->events();
                     for (auto event : allEvents) {
-                        setEventChanges(event, impl->m_Model->eventsHasChanges(event));
+                        setEventChanges(event, sqpApp->catalogueController().eventHasChanges(event));
                     }
                 });
+                populateWithAllEvents();
             }
             CatalogueEventsWidget::~CatalogueEventsWidget()
             {
                 delete ui;
             }
             void CatalogueEventsWidget::setVisualizationWidget(VisualizationWidget *visualization)
             {
                 impl->m_VisualizationWidget = visualization;
             }
+            void CatalogueEventsWidget::addEvent(const std::shared_ptr<DBEvent> &event)
+            {
+                impl->addEvent(event, ui->treeView);
+            }
             void CatalogueEventsWidget::setEventChanges(const std::shared_ptr<DBEvent> &event, bool hasChanges)
             {
                 impl->m_Model->refreshEvent(event);
                 auto eventIndex = impl->m_Model->indexOf(event);
                 auto validationIndex
                     = eventIndex.sibling(eventIndex.row(), (int)CatalogueEventsModel::Column::Validation);
-                if (hasChanges) {
+                if (validationIndex.isValid()) {
-                    if (ui->treeView->indexWidget(validationIndex) == nullptr) {
+                    if (hasChanges) {
-                        auto widget = CatalogueExplorerHelper::buildValidationWidget(
+                        if (ui->treeView->indexWidget(validationIndex) == nullptr) {
-                            ui->treeView, [this, event]() { setEventChanges(event, false); },
+                            auto widget = CatalogueExplorerHelper::buildValidationWidget(
-                            [this, event]() { setEventChanges(event, false); });
+                                ui->treeView,
-                        ui->treeView->setIndexWidget(validationIndex, widget);
+                                [this, event]() {
+                                    sqpApp->catalogueController().saveEvent(event);
+                                    setEventChanges(event, false);
+                                },
+                                [this, event]() {
+                                    sqpApp->catalogueController().discardEvent(event);
+                                    setEventChanges(event, false);
+                                    impl->m_Model->refreshEvent(event, true);
+                                    emitSelection();
+                                });
+                            ui->treeView->setIndexWidget(validationIndex, widget);
+                        }
+                    }
+                    else {
+                        // Note: the widget is destroyed
+                        ui->treeView->setIndexWidget(validationIndex, nullptr);
                     }
                 }
                 else {
-                    // Note: the widget is destroyed
+                    qCWarning(LOG_CatalogueEventsWidget())
-                    ui->treeView->setIndexWidget(validationIndex, nullptr);
+                        << "setEventChanges: the event is not displayed in the model.";
                 }
+            }
-                impl->m_Model->setEventHasChanges(event, hasChanges);
+            QVector<std::shared_ptr<DBCatalogue> > CatalogueEventsWidget::displayedCatalogues() const
+            {
+                return impl->m_DisplayedCatalogues;
+            }
+            bool CatalogueEventsWidget::isAllEventsDisplayed() const
+            {
+                return impl->m_DisplayedCatalogues.isEmpty() && !impl->m_Model->events().isEmpty();
+            }
+            bool CatalogueEventsWidget::isEventDisplayed(const std::shared_ptr<DBEvent> &event) const
+            {
+                return impl->m_Model->indexOf(event).isValid();
             }
             void CatalogueEventsWidget::populateWithCatalogues(
                 const QVector<std::shared_ptr<DBCatalogue> > &catalogues)
             {
+                impl->m_DisplayedCatalogues = catalogues;
                 QSet<QUuid> eventIds;
                 QVector<std::shared_ptr<DBEvent> > events;
                 for (auto catalogue : catalogues) {
                     auto catalogueEvents = sqpApp->catalogueController().retrieveEventsFromCatalogue(catalogue);
                     for (auto event : catalogueEvents) {
                         if (!eventIds.contains(event->getUniqId())) {
                             events << event;
                             eventIds.insert(event->getUniqId());
                         }
                     }
                 }
-                impl->setEvents(events, ui->treeView);
+                impl->setEvents(events, this);
             }
             void CatalogueEventsWidget::populateWithAllEvents()
             {
+                impl->m_DisplayedCatalogues.clear();
                 auto allEvents = sqpApp->catalogueController().retrieveAllEvents();
                 QVector<std::shared_ptr<DBEvent> > events;
                 for (auto event : allEvents) {
                     events << event;
                 }
-                impl->setEvents(events, ui->treeView);
+                impl->setEvents(events, this);
+            }
+            void CatalogueEventsWidget::clear()
+            {
+                impl->m_DisplayedCatalogues.clear();
+                impl->setEvents({}, this);
+            }
+            void CatalogueEventsWidget::refresh()
+            {
+                if (impl->m_DisplayedCatalogues.isEmpty()) {
+                    populateWithAllEvents();
+                }
+                else {
+                    populateWithCatalogues(impl->m_DisplayedCatalogues);
+                }
+            }
+            void CatalogueEventsWidget::emitSelection()
+            {
+                QVector<std::shared_ptr<DBEvent> > events;
+                QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
+                impl->getSelectedItems(ui->treeView, events, eventProducts);
+                if (!events.isEmpty() && eventProducts.isEmpty()) {
+                    emit eventsSelected(events);
+                }
+                else if (events.isEmpty() && !eventProducts.isEmpty()) {
+                    emit eventProductsSelected(eventProducts);
+                }
+                else {
+                    emit selectionCleared();
+                }
             }

gui/src/Catalogue/CatalogueExplorer.cpp +37 -6

             #include "Catalogue/CatalogueExplorer.h"
             #include "ui_CatalogueExplorer.h"
             #include <Catalogue/CatalogueActionManager.h>
             #include <Catalogue/CatalogueController.h>
             #include <SqpApplication.h>
             #include <Visualization/VisualizationWidget.h>
             #include <DBCatalogue.h>
             #include <DBEvent.h>
             struct CatalogueExplorer::CatalogueExplorerPrivate {
                 CatalogueActionManager m_ActionManager;
+                CatalogueExplorerPrivate(CatalogueExplorer *catalogueExplorer)
+                        : m_ActionManager(catalogueExplorer)
+                {
+                }
             };
             CatalogueExplorer::CatalogueExplorer(QWidget *parent)
                     : QDialog(parent, Qt::Dialog | Qt::WindowMinMaxButtonsHint | Qt::WindowCloseButtonHint),
                       ui(new Ui::CatalogueExplorer),
-                      impl{spimpl::make_unique_impl<CatalogueExplorerPrivate>()}
+                      impl{spimpl::make_unique_impl<CatalogueExplorerPrivate>(this)}
             {
                 ui->setupUi(this);
                 impl->m_ActionManager.installSelectionZoneActions();
                 connect(ui->catalogues, &CatalogueSideBarWidget::catalogueSelected, [this](auto catalogues) {
                     if (catalogues.count() == 1) {
                         ui->inspector->setCatalogue(catalogues.first());
                     }
                     else {
                         ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
                     }
                     ui->events->populateWithCatalogues(catalogues);
                 });
                 connect(ui->catalogues, &CatalogueSideBarWidget::databaseSelected, [this](auto databases) {
                     ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
                 });
-                connect(ui->catalogues, &CatalogueSideBarWidget::trashSelected,
+                connect(ui->catalogues, &CatalogueSideBarWidget::trashSelected, [this]() {
-                        [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
+                    ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
+                    ui->events->clear();
+                });
                 connect(ui->catalogues, &CatalogueSideBarWidget::allEventsSelected, [this]() {
                     ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
                     ui->events->populateWithAllEvents();
                 });
-                connect(ui->catalogues, &CatalogueSideBarWidget::selectionCleared,
+                connect(ui->catalogues, &CatalogueSideBarWidget::databaseSelected, [this](auto databaseList) {
-                        [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
+                    QVector<std::shared_ptr<DBCatalogue> > catalogueList;
+                    for (auto database : databaseList) {
+                        catalogueList.append(ui->catalogues->getCatalogues(database));
+                    }
+                    ui->events->populateWithCatalogues(catalogueList);
+                    ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
+                });
+                connect(ui->catalogues, &CatalogueSideBarWidget::selectionCleared, [this]() {
+                    ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
+                    ui->events->clear();
+                });
                 connect(ui->events, &CatalogueEventsWidget::eventsSelected, [this](auto events) {
                     if (events.count() == 1) {
                         ui->inspector->setEvent(events.first());
                     }
                     else {
                         ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
                     }
                 });
                 connect(ui->events, &CatalogueEventsWidget::eventProductsSelected, [this](auto eventProducts) {
                     if (eventProducts.count() == 1) {
                         ui->inspector->setEventProduct(eventProducts.first().first,
                                                        eventProducts.first().second);
                     }
                     else {
                         ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
                     }
                 });
                 connect(ui->events, &CatalogueEventsWidget::selectionCleared,
                         [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
                 connect(ui->inspector, &CatalogueInspectorWidget::catalogueUpdated, [this](auto catalogue) {
                     sqpApp->catalogueController().updateCatalogue(catalogue);
                     ui->catalogues->setCatalogueChanges(catalogue, true);
                 });
                 connect(ui->inspector, &CatalogueInspectorWidget::eventUpdated, [this](auto event) {
                     sqpApp->catalogueController().updateEvent(event);
                     ui->events->setEventChanges(event, true);
                 });
                 connect(ui->inspector, &CatalogueInspectorWidget::eventProductUpdated,
-                        [this](auto event, auto eventProduct) { ui->events->setEventChanges(event, true); });
+                        [this](auto event, auto eventProduct) {
+                            sqpApp->catalogueController().updateEventProduct(eventProduct);
+                            ui->events->setEventChanges(event, true);
+                        });
             }
             CatalogueExplorer::~CatalogueExplorer()
             {
                 delete ui;
             }
             void CatalogueExplorer::setVisualizationWidget(VisualizationWidget *visualization)
             {
                 ui->events->setVisualizationWidget(visualization);
             }
+            CatalogueEventsWidget &CatalogueExplorer::eventsWidget() const
+            {
+                return *ui->events;
+            }
+            CatalogueSideBarWidget &CatalogueExplorer::sideBarWidget() const
+            {
+                return *ui->catalogues;
+            }

gui/src/Catalogue/CatalogueInspectorWidget.cpp +34 -4

             #include "Catalogue/CatalogueInspectorWidget.h"
             #include "ui_CatalogueInspectorWidget.h"
             #include <Common/DateUtils.h>
             #include <DBCatalogue.h>
             #include <DBEvent.h>
             #include <DBEventProduct.h>
             #include <DBTag.h>
             struct CatalogueInspectorWidget::CatalogueInspectorWidgetPrivate {
                 std::shared_ptr<DBCatalogue> m_DisplayedCatalogue = nullptr;
                 std::shared_ptr<DBEvent> m_DisplayedEvent = nullptr;
                 std::shared_ptr<DBEventProduct> m_DisplayedEventProduct = nullptr;
                 void connectCatalogueUpdateSignals(CatalogueInspectorWidget *inspector,
                                                    Ui::CatalogueInspectorWidget *ui);
                 void connectEventUpdateSignals(CatalogueInspectorWidget *inspector,
                                                Ui::CatalogueInspectorWidget *ui);
             };
             CatalogueInspectorWidget::CatalogueInspectorWidget(QWidget *parent)
                     : QWidget(parent),
                       ui(new Ui::CatalogueInspectorWidget),
                       impl{spimpl::make_unique_impl<CatalogueInspectorWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 showPage(Page::Empty);
                 impl->connectCatalogueUpdateSignals(this, ui);
                 impl->connectEventUpdateSignals(this, ui);
             }
             CatalogueInspectorWidget::~CatalogueInspectorWidget()
             {
                 delete ui;
             }
             void CatalogueInspectorWidget::CatalogueInspectorWidgetPrivate::connectCatalogueUpdateSignals(
                 CatalogueInspectorWidget *inspector, Ui::CatalogueInspectorWidget *ui)
             {
                 connect(ui->leCatalogueName, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     if (ui->leCatalogueName->text() != m_DisplayedCatalogue->getName()) {
                         m_DisplayedCatalogue->setName(ui->leCatalogueName->text());
                         emit inspector->catalogueUpdated(m_DisplayedCatalogue);
                     }
                 });
                 connect(ui->leCatalogueAuthor, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     if (ui->leCatalogueAuthor->text() != m_DisplayedCatalogue->getAuthor()) {
                         m_DisplayedCatalogue->setAuthor(ui->leCatalogueAuthor->text());
                         emit inspector->catalogueUpdated(m_DisplayedCatalogue);
                     }
                 });
             }
             void CatalogueInspectorWidget::CatalogueInspectorWidgetPrivate::connectEventUpdateSignals(
                 CatalogueInspectorWidget *inspector, Ui::CatalogueInspectorWidget *ui)
             {
                 connect(ui->leEventName, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     if (ui->leEventName->text() != m_DisplayedEvent->getName()) {
                         m_DisplayedEvent->setName(ui->leEventName->text());
                         emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
                 connect(ui->leEventTags, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     auto tags = ui->leEventTags->text().split(QRegExp("\\s+"));
                     std::list<QString> tagNames;
                     for (auto tag : tags) {
                         tagNames.push_back(tag);
                     }
                     if (m_DisplayedEvent->getTagsNames() != tagNames) {
                         m_DisplayedEvent->setTagsNames(tagNames);
                         emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
                 connect(ui->leEventProduct, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     if (ui->leEventProduct->text() != m_DisplayedEventProduct->getProductId()) {
+                        auto oldProductId = m_DisplayedEventProduct->getProductId();
                         m_DisplayedEventProduct->setProductId(ui->leEventProduct->text());
-                        emit inspector->eventProductUpdated(m_DisplayedEvent, m_DisplayedEventProduct);
+                        auto eventProducts = m_DisplayedEvent->getEventProducts();
+                        for (auto &eventProduct : eventProducts) {
+                            if (eventProduct.getProductId() == oldProductId) {
+                                eventProduct.setProductId(m_DisplayedEventProduct->getProductId());
+                            }
+                        }
+                        m_DisplayedEvent->setEventProducts(eventProducts);
+                        emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
                 connect(ui->dateTimeEventTStart, &QDateTimeEdit::editingFinished, [ui, inspector, this]() {
                     auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTStart->dateTime());
                     if (time != m_DisplayedEventProduct->getTStart()) {
                         m_DisplayedEventProduct->setTStart(time);
-                        emit inspector->eventProductUpdated(m_DisplayedEvent, m_DisplayedEventProduct);
+                        auto eventProducts = m_DisplayedEvent->getEventProducts();
+                        for (auto &eventProduct : eventProducts) {
+                            if (eventProduct.getProductId() == m_DisplayedEventProduct->getProductId()) {
+                                eventProduct.setTStart(m_DisplayedEventProduct->getTStart());
+                            }
+                        }
+                        m_DisplayedEvent->setEventProducts(eventProducts);
+                        emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
                 connect(ui->dateTimeEventTEnd, &QDateTimeEdit::editingFinished, [ui, inspector, this]() {
                     auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTEnd->dateTime());
                     if (time != m_DisplayedEventProduct->getTEnd()) {
                         m_DisplayedEventProduct->setTEnd(time);
-                        emit inspector->eventProductUpdated(m_DisplayedEvent, m_DisplayedEventProduct);
+                        auto eventProducts = m_DisplayedEvent->getEventProducts();
+                        for (auto &eventProduct : eventProducts) {
+                            if (eventProduct.getProductId() == m_DisplayedEventProduct->getProductId()) {
+                                eventProduct.setTEnd(m_DisplayedEventProduct->getTEnd());
+                            }
+                        }
+                        m_DisplayedEvent->setEventProducts(eventProducts);
+                        emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
             }
             void CatalogueInspectorWidget::showPage(CatalogueInspectorWidget::Page page)
             {
                 ui->stackedWidget->setCurrentIndex(static_cast<int>(page));
             }
             CatalogueInspectorWidget::Page CatalogueInspectorWidget::currentPage() const
             {
                 return static_cast<Page>(ui->stackedWidget->currentIndex());
             }
             void CatalogueInspectorWidget::setEvent(const std::shared_ptr<DBEvent> &event)
             {
                 impl->m_DisplayedEvent = event;
                 blockSignals(true);
                 showPage(Page::EventProperties);
                 ui->leEventName->setEnabled(true);
                 ui->leEventName->setText(event->getName());
                 ui->leEventProduct->setEnabled(false);
                 ui->leEventProduct->setText(
                     QString::number(event->getEventProducts().size()).append(" product(s)"));
                 QString tagList;
                 auto tags = event->getTagsNames();
                 for (auto tag : tags) {
                     tagList += tag;
                     tagList += ' ';
                 }
                 ui->leEventTags->setEnabled(true);
                 ui->leEventTags->setText(tagList);
                 ui->dateTimeEventTStart->setEnabled(false);
                 ui->dateTimeEventTEnd->setEnabled(false);
                 ui->dateTimeEventTStart->setDateTime(DateUtils::dateTime(event->getTStart()));
                 ui->dateTimeEventTEnd->setDateTime(DateUtils::dateTime(event->getTEnd()));
                 blockSignals(false);
             }
             void CatalogueInspectorWidget::setEventProduct(const std::shared_ptr<DBEvent> &event,
                                                            const std::shared_ptr<DBEventProduct> &eventProduct)
             {
+                impl->m_DisplayedEvent = event;
                 impl->m_DisplayedEventProduct = eventProduct;
                 blockSignals(true);
                 showPage(Page::EventProperties);
                 ui->leEventName->setEnabled(false);
                 ui->leEventName->setText(event->getName());
-                ui->leEventProduct->setEnabled(true);
+                ui->leEventProduct->setEnabled(false);
                 ui->leEventProduct->setText(eventProduct->getProductId());
                 ui->leEventTags->setEnabled(false);
                 ui->leEventTags->clear();
                 ui->dateTimeEventTStart->setEnabled(true);
                 ui->dateTimeEventTEnd->setEnabled(true);
                 ui->dateTimeEventTStart->setDateTime(DateUtils::dateTime(eventProduct->getTStart()));
                 ui->dateTimeEventTEnd->setDateTime(DateUtils::dateTime(eventProduct->getTEnd()));
                 blockSignals(false);
             }
             void CatalogueInspectorWidget::setCatalogue(const std::shared_ptr<DBCatalogue> &catalogue)
             {
                 impl->m_DisplayedCatalogue = catalogue;
                 blockSignals(true);
                 showPage(Page::CatalogueProperties);
                 ui->leCatalogueName->setText(catalogue->getName());
                 ui->leCatalogueAuthor->setText(catalogue->getAuthor());
                 blockSignals(false);
             }

gui/src/Catalogue/CatalogueSideBarWidget.cpp +213 -126

@@ -1,250 +1,337
1	#include "Catalogue/CatalogueSideBarWidget.h"	1	#include "Catalogue/CatalogueSideBarWidget.h"
2	#include "ui_CatalogueSideBarWidget.h"	2	#include "ui_CatalogueSideBarWidget.h"
3	#include <SqpApplication.h>	3	#include <SqpApplication.h>
4		4
5	#include <Catalogue/CatalogueController.h>	5	#include <Catalogue/CatalogueController.h>
6	#include <Catalogue/Catalogue~~TreeWidgetItem~~.h>	6	#include <Catalogue/CatalogueExplorerHelper.h>
		7	#include <Catalogue/CatalogueTreeItems/CatalogueTextTreeItem.h>
		8	#include <Catalogue/CatalogueTreeItems/CatalogueTreeItem.h>
		9	#include <Catalogue/CatalogueTreeModel.h>
7	#include <CatalogueDao.h>	10	#include <CatalogueDao.h>
8	#include <ComparaisonPredicate.h>	11	#include <ComparaisonPredicate.h>
9	#include <DBCatalogue.h>	12	#include <DBCatalogue.h>
10		13
11	#include <QMenu>	14	#include <QMenu>
12		15
13	Q_LOGGING_CATEGORY(LOG_CatalogueSideBarWidget, "CatalogueSideBarWidget")	16	Q_LOGGING_CATEGORY(LOG_CatalogueSideBarWidget, "CatalogueSideBarWidget")
14		17
15		18
16	constexpr auto ALL_EVENT_ITEM_TYPE = ~~QTreeWidget~~Item::~~UserType~~;	19	constexpr auto ALL_EVENT_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 1;
17	constexpr auto TRASH_ITEM_TYPE = ~~QTreeWidget~~Item::~~UserType~~ + 1;	20	constexpr auto TRASH_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 2;
18	constexpr auto CATALOGUE_ITEM_TYPE = ~~QTreeWidget~~Item::~~UserType~~ + 2;	21	constexpr auto CATALOGUE_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 3;
19	constexpr auto DATABASE_ITEM_TYPE = ~~QTreeWidget~~Item::~~UserType~~ + 3;	22	constexpr auto DATABASE_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 4;
20		23
21		24
22	struct CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate {	25	struct CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate {
23		26
24	void configureTreeWidget(QTreeWidget *treeWidget);	27	CatalogueTreeModel *m_TreeModel = nullptr;
25	QTreeWidgetItem addDatabaseItem(const QString &name, QTreeWidget treeWidget);	28
26	QTreeWidgetItem getDatabaseItem(const QString &name, QTreeWidget treeWidget);	29	void configureTreeWidget(QTreeView *treeView);
		30	QModelIndex addDatabaseItem(const QString &name);
		31	CatalogueAbstractTreeItem *getDatabaseItem(const QString &name);
27	void addCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue,	32	void addCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue,
28	~~QTreeWidgetItem~~ *~~parentDatabaseItem~~);	33	const QModelIndex &databaseIndex);
		34
		35	CatalogueTreeItem *getCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue) const;
		36	void setHasChanges(bool value, const QModelIndex &index, QTreeView *treeView);
		37	bool hasChanges(const QModelIndex &index, QTreeView *treeView);
		38
		39	int selectionType(QTreeView *treeView) const
		40	{
		41	auto selectedItems = treeView->selectionModel()->selectedRows();
		42	if (selectedItems.isEmpty()) {
		43	return CatalogueAbstractTreeItem::DEFAULT_TYPE;
		44	}
		45	else {
		46	auto firstIndex = selectedItems.first();
		47	auto firstItem = m_TreeModel->item(firstIndex);
		48	if (!firstItem) {
		49	Q_ASSERT(false);
		50	return CatalogueAbstractTreeItem::DEFAULT_TYPE;
		51	}
		52	auto selectionType = firstItem->type();
		53
		54	for (auto itemIndex : selectedItems) {
		55	auto item = m_TreeModel->item(itemIndex);
		56	if (!item \|\| item->type() != selectionType) {
		57	// Incoherent multi selection
		58	selectionType = CatalogueAbstractTreeItem::DEFAULT_TYPE;
		59	break;
		60	}
		61	}
		62
		63	return selectionType;
		64	}
		65	}
		66
		67	QVector<std::shared_ptr<DBCatalogue> > selectedCatalogues(QTreeView *treeView) const
		68	{
		69	QVector<std::shared_ptr<DBCatalogue> > catalogues;
		70	auto selectedItems = treeView->selectionModel()->selectedRows();
		71	for (auto itemIndex : selectedItems) {
		72	auto item = m_TreeModel->item(itemIndex);
		73	if (item && item->type() == CATALOGUE_ITEM_TYPE) {
		74	catalogues.append(static_cast<CatalogueTreeItem *>(item)->catalogue());
		75	}
		76	}
29		77
30	CatalogueTreeWidgetItem *getCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue,	78	return catalogues;
31	QTreeWidget *treeWidget) const;	79	}
		80
		81	QStringList selectedRepositories(QTreeView *treeView) const
		82	{
		83	QStringList repositories;
		84	auto selectedItems = treeView->selectionModel()->selectedRows();
		85	for (auto itemIndex : selectedItems) {
		86	auto item = m_TreeModel->item(itemIndex);
		87	if (item && item->type() == DATABASE_ITEM_TYPE) {
		88	repositories.append(item->text());
		89	}
		90	}
		91
		92	return repositories;
		93	}
32	};	94	};
33		95
34	CatalogueSideBarWidget::CatalogueSideBarWidget(QWidget *parent)	96	CatalogueSideBarWidget::CatalogueSideBarWidget(QWidget *parent)
35	: QWidget(parent),	97	: QWidget(parent),
36	ui(new Ui::CatalogueSideBarWidget),	98	ui(new Ui::CatalogueSideBarWidget),
37	impl{spimpl::make_unique_impl<CatalogueSideBarWidgetPrivate>()}	99	impl{spimpl::make_unique_impl<CatalogueSideBarWidgetPrivate>()}
38	{	100	{
39	ui->setupUi(this);	101	ui->setupUi(this);
40	impl->configureTreeWidget(ui->treeWidget);
41		102
42	ui->treeWidget->setColumnCount(2);	103	impl->m_TreeModel = new CatalogueTreeModel(this);
43	ui->treeWidget->header()->setStretchLastSection(false);	104	ui->treeView->setModel(impl->m_TreeModel);
44	ui->treeWidget->header()->setSectionResizeMode(QHeaderView::ResizeToContents);	105
45	ui->treeWidget->header()->setSectionResizeMode(0, QHeaderView::Stretch);	106	impl->configureTreeWidget(ui->treeView);
		107
		108	ui->treeView->header()->setStretchLastSection(false);
		109	ui->treeView->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
		110	ui->treeView->header()->setSectionResizeMode(0, QHeaderView::Stretch);
46		111
47	auto emitSelection = [this]() {	112	auto emitSelection = [this]() {
48		113
49	auto selectedItems = ui->treeWidget->selectedItems();	114	auto selectionType = impl->selectionType(ui->treeView);
50	if (selectedItems.isEmpty()) {	115
51	emit this->selectionCleared();	116	switch (selectionType) {
		117	case CATALOGUE_ITEM_TYPE:
		118	emit this->catalogueSelected(impl->selectedCatalogues(ui->treeView));
		119	break;
		120	case DATABASE_ITEM_TYPE:
		121	emit this->databaseSelected(impl->selectedRepositories(ui->treeView));
		122	break;
		123	case ALL_EVENT_ITEM_TYPE:
		124	emit this->allEventsSelected();
		125	break;
		126	case TRASH_ITEM_TYPE:
		127	emit this->trashSelected();
		128	break;
		129	default:
		130	emit this->selectionCleared();
		131	break;
52	}	132	}
53	else {	133	};
54	QVector<std::shared_ptr<DBCatalogue> > catalogues;
55	QStringList databases;
56	int selectionType = selectedItems.first()->type();
57
58	for (auto item : ui->treeWidget->selectedItems()) {
59	if (item->type() == selectionType) {
60	switch (selectionType) {
61	case CATALOGUE_ITEM_TYPE:
62	catalogues.append(
63	static_cast<CatalogueTreeWidgetItem *>(item)->catalogue());
64	break;
65	case DATABASE_ITEM_TYPE:
66	selectionType = DATABASE_ITEM_TYPE;
67	databases.append(item->text(0));
68	case ALL_EVENT_ITEM_TYPE: // fallthrough
69	case TRASH_ITEM_TYPE: // fallthrough
70	default:
71	break;
72	}
73	}
74	else {
75	// Incoherent multi selection
76	selectionType = -1;
77	break;
78	}
79	}
80		134
81	switch (selectionType) {	135	connect(ui->treeView, &QTreeView::clicked, emitSelection);
82	case CATALOGUE_ITEM_TYPE:	136	connect(ui->treeView->selectionModel(), &QItemSelectionModel::currentChanged, emitSelection);
83	emit this->catalogueSelected(catalogues);	137	connect(impl->m_TreeModel, &CatalogueTreeModel::itemRenamed, [emitSelection, this](auto index) {
84	break;	138	auto selectedIndexes = ui->treeView->selectionModel()->selectedRows();
85	case DATABASE_ITEM_TYPE:	139	if (selectedIndexes.contains(index)) {
86	emit this->databaseSelected(databases);	140	emitSelection();
87	break;
88	case ALL_EVENT_ITEM_TYPE:
89	emit this->allEventsSelected();
90	break;
91	case TRASH_ITEM_TYPE:
92	emit this->trashSelected();
93	break;
94	default:
95	emit this->selectionCleared();
96	break;
97	}
98	}	141	}
99		142
		143	auto item = impl->m_TreeModel->item(index);
		144	impl->setHasChanges(true, index, ui->treeView);
		145	});
100		146
101	};	147	ui->treeView->setContextMenuPolicy(Qt::CustomContextMenu);
102		148	connect(ui->treeView, &QTreeView::customContextMenuRequested, this,
103	connect(ui->treeWidget, &QTreeWidget::itemClicked, emitSelection);
104	connect(ui->treeWidget, &QTreeWidget::currentItemChanged, emitSelection);
105	connect(ui->treeWidget, &QTreeWidget::itemChanged,
106	[emitSelection, this](auto item, auto column) {
107	auto selectedItems = ui->treeWidget->selectedItems();
108	qDebug() << "ITEM CHANGED" << column;
109	if (selectedItems.contains(item) && column == 0) {
110	emitSelection();
111	}
112	});
113
114	ui->treeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
115	connect(ui->treeWidget, &QTreeWidget::customContextMenuRequested, this,
116	&CatalogueSideBarWidget::onContextMenuRequested);	149	&CatalogueSideBarWidget::onContextMenuRequested);
117	}	150	}
118		151
119	CatalogueSideBarWidget::~CatalogueSideBarWidget()	152	CatalogueSideBarWidget::~CatalogueSideBarWidget()
120	{	153	{
121	delete ui;	154	delete ui;
122	}	155	}
123		156
		157	void CatalogueSideBarWidget::addCatalogue(const std::shared_ptr<DBCatalogue> &catalogue,
		158	const QString &repository)
		159	{
		160	auto repositoryItem = impl->getDatabaseItem(repository);
		161	impl->addCatalogueItem(catalogue, impl->m_TreeModel->indexOf(repositoryItem));
		162	}
		163
124	void CatalogueSideBarWidget::setCatalogueChanges(const std::shared_ptr<DBCatalogue> &catalogue,	164	void CatalogueSideBarWidget::setCatalogueChanges(const std::shared_ptr<DBCatalogue> &catalogue,
125	bool hasChanges)	165	bool hasChanges)
126	{	166	{
127	if (auto catalogueItem = impl->getCatalogueItem(catalogue, ui->~~treeWidget~~)) {	167	if (auto catalogueItem = impl->getCatalogueItem(catalogue)) {
128	catalogueItem->setHasChanges(hasChanges);	168	auto index = impl->m_TreeModel->indexOf(catalogueItem);
129	catalogueItem->refresh();	169	impl->setHasChanges(hasChanges, index, ui->treeView);
		170	// catalogueItem->refresh();
130	}	171	}
131	}	172	}
132		173
		174	QVector<std::shared_ptr<DBCatalogue> >
		175	CatalogueSideBarWidget::getCatalogues(const QString &repository) const
		176	{
		177	QVector<std::shared_ptr<DBCatalogue> > result;
		178	auto repositoryItem = impl->getDatabaseItem(repository);
		179	for (auto child : repositoryItem->children()) {
		180	if (child->type() == CATALOGUE_ITEM_TYPE) {
		181	auto catalogueItem = static_cast<CatalogueTreeItem *>(child);
		182	result << catalogueItem->catalogue();
		183	}
		184	else {
		185	qCWarning(LOG_CatalogueSideBarWidget()) << "getCatalogues: invalid structure";
		186	}
		187	}
		188
		189	return result;
		190	}
		191
133	void CatalogueSideBarWidget::onContextMenuRequested(const QPoint &pos)	192	void CatalogueSideBarWidget::onContextMenuRequested(const QPoint &pos)
134	{	193	{
135	QMenu menu{this};	194	QMenu menu{this};
136		195
137	auto currentI~~tem~~ = ui->tree~~Widget~~->currentI~~tem~~();	196	auto currentIndex = ui->treeView->currentIndex();
		197	auto currentItem = impl->m_TreeModel->item(currentIndex);
		198	if (!currentItem) {
		199	return;
		200	}
		201
138	switch (currentItem->type()) {	202	switch (currentItem->type()) {
139	case CATALOGUE_ITEM_TYPE:	203	case CATALOGUE_ITEM_TYPE:
140	menu.addAction("Rename",	204	menu.addAction("Rename", [this, currentIndex]() { ui->treeView->edit(currentIndex); });
141	[this, currentItem]() { ui->treeWidget->editItem(currentItem); });
142	break;	205	break;
143	case DATABASE_ITEM_TYPE:	206	case DATABASE_ITEM_TYPE:
144	break;	207	break;
145	case ALL_EVENT_ITEM_TYPE:	208	case ALL_EVENT_ITEM_TYPE:
146	break;	209	break;
147	case TRASH_ITEM_TYPE:	210	case TRASH_ITEM_TYPE:
148	menu.addAction("Empty Trash", []() {	211	menu.addAction("Empty Trash", []() {
149	// TODO	212	// TODO
150	});	213	});
151	break;	214	break;
152	default:	215	default:
153	break;	216	break;
154	}	217	}
155		218
156	if (!menu.isEmpty()) {	219	if (!menu.isEmpty()) {
157	menu.exec(ui->tree~~Widget~~->mapToGlobal(pos));	220	menu.exec(ui->treeView->mapToGlobal(pos));
158	}	221	}
159	}	222	}
160		223
161	void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::configureTreeWidget(	224	void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::configureTreeWidget(QTreeView *treeView)
162	QTreeWidget *treeWidget)
163	{	225	{
164	auto allEventsItem = new QTreeWidgetItem{{"All Events"}, ALL_EVENT_ITEM_TYPE};	226	auto allEventsItem = new CatalogueTextTreeItem{QIcon{":/icones/allEvents.png"}, "All Events",
165	allEventsItem->setIcon(0, QIcon(":/icones/allEvents.png"));	227	ALL_EVENT_ITEM_TYPE};
166	~~treeWidget~~->addTopLevelItem(allEventsItem);	228	auto allEventIndex = m_TreeModel->addTopLevelItem(allEventsItem);
		229	treeView->setCurrentIndex(allEventIndex);
167		230
168	auto trashItem = new QTreeWidgetItem{{"Trash"}, TRASH_ITEM_TYPE};	231	auto trashItem
169	trashItem->setIcon(0, QIcon(":/icones/trash.png"));	232	= new CatalogueTextTreeItem{QIcon{":/icones/trash.png"}, "Trash", TRASH_ITEM_TYPE};
170	~~treeWidget~~->addTopLevelItem(trashItem);	233	m_TreeModel->addTopLevelItem(trashItem);
171		234
172	auto separator = new QFrame{tree~~Widget~~};	235	auto separator = new QFrame{treeView};
173	separator->setFrameShape(QFrame::HLine);	236	separator->setFrameShape(QFrame::HLine);
174	auto separatorItem = ~~new~~ ~~QTreeWidgetItem{};~~	237	auto separatorItem
175	separatorItem->setFlags(Qt::NoItemFlags);	238	= new CatalogueTextTreeItem{QIcon{}, QString{}, CatalogueAbstractTreeItem::DEFAULT_TYPE};
176	treeWidget->addTopLevelItem(separatorItem);	239	separatorItem->setEnabled(false);
177	treeWidget->setItemWidget(separatorItem, 0, separator);	240	auto separatorIndex = m_TreeModel->addTopLevelItem(separatorItem);
		241	treeView->setIndexWidget(separatorIndex, separator);
178		242
179	auto repositories = sqpApp->catalogueController().getRepositories();	243	auto repositories = sqpApp->catalogueController().getRepositories();
180	for (auto dbname : repositories) {	244	for (auto dbname : repositories) {
181	auto db = addDatabaseItem(dbname, ~~treeWidget~~);	245	auto dbIndex = addDatabaseItem(dbname);
182
183	auto catalogues = sqpApp->catalogueController().retrieveCatalogues(dbname);	246	auto catalogues = sqpApp->catalogueController().retrieveCatalogues(dbname);
184	for (auto catalogue : catalogues) {	247	for (auto catalogue : catalogues) {
185	addCatalogueItem(catalogue, db);	248	addCatalogueItem(catalogue, dbIndex);
186	}	249	}
187	}	250	}
188		251
189	tree~~Widget~~->expandAll();	252	treeView->expandAll();
190	}	253	}
191		254
192	QTreeWidgetItem *	255	QModelIndex
193	CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addDatabaseItem(const QString &name,	256	CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addDatabaseItem(const QString &name)
194	QTreeWidget *treeWidget)
195	{	257	{
196	auto databaseItem = new QTreeWidgetItem{{name}, DATABASE_ITEM_TYPE};	258	auto databaseItem
197	databaseItem->setIcon(0, QIcon{":/icones/database.png"});	259	= new CatalogueTextTreeItem{QIcon{":/icones/database.png"}, {name}, DATABASE_ITEM_TYPE};
198	~~treeWidget~~->addTopLevelItem(databaseItem);	260	auto databaseIndex = m_TreeModel->addTopLevelItem(databaseItem);
199		261
200	return databaseI~~tem~~;	262	return databaseIndex;
201	}	263	}
202		264
203	QTreeWidgetItem *	265	CatalogueAbstractTreeItem *
204	CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getDatabaseItem(const QString &name,	266	CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getDatabaseItem(const QString &name)
205	QTreeWidget *treeWidget)
206	{	267	{
207	for (auto i = 0; i < ~~treeWidget~~->topLevelItem~~Count~~(); ++i) {	268	for (auto item : m_TreeModel->topLevelItems()) {
208	auto item = treeWidget->topLevelItem(i);	269	if (item->type() == DATABASE_ITEM_TYPE && item->text() == name) {
209	if (item->type() == DATABASE_ITEM_TYPE && item->text(0) == name) {
210	return item;	270	return item;
211	}	271	}
212	}	272	}
213		273
214	return nullptr;	274	return nullptr;
215	}	275	}
216		276
217	void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addCatalogueItem(	277	void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addCatalogueItem(
218	const std::shared_ptr<DBCatalogue> &catalogue, ~~QTreeWidgetItem~~ *~~parentDatabaseItem~~)	278	const std::shared_ptr<DBCatalogue> &catalogue, const QModelIndex &databaseIndex)
219	{	279	{
220	auto catalogueItem = new CatalogueTreeWidgetItem{catalogue, CATALOGUE_ITEM_TYPE};	280	auto catalogueItem
221	catalogueItem->setIcon(0, QIcon{":/icones/catalogue.png"});	281	= new CatalogueTreeItem{catalogue, QIcon{":/icones/catalogue.png"}, CATALOGUE_ITEM_TYPE};
222	~~parentDatabaseItem~~->addChild(catalogueItem);	282	m_TreeModel->addChildItem(catalogueItem, databaseIndex);
223	}	283	}
224		284
225	CatalogueTree~~Widget~~Item *CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getCatalogueItem(	285	CatalogueTreeItem *CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getCatalogueItem(
226	const std::shared_ptr<DBCatalogue> &catalogue, ~~QTreeWidget~~ *~~treeWidget~~) const	286	const std::shared_ptr<DBCatalogue> &catalogue) const
227	{	287	{
228	for (auto i = 0; i < ~~treeWidget~~->topLevelItem~~Count~~(); ++i) {	288	for (auto item : m_TreeModel->topLevelItems()) {
229	auto item = treeWidget->topLevelItem(i);
230	if (item->type() == DATABASE_ITEM_TYPE) {	289	if (item->type() == DATABASE_ITEM_TYPE) {
231	for (auto j = 0; j < item->child~~Count~~(); ++j) {	290	for (auto childItem : item->children()) {
232	auto childItem = item->child(j);
233	if (childItem->type() == CATALOGUE_ITEM_TYPE) {	291	if (childItem->type() == CATALOGUE_ITEM_TYPE) {
234	auto catalogueItem = static_cast<CatalogueTree~~Widget~~Item *>(childItem);	292	auto catalogueItem = static_cast<CatalogueTreeItem *>(childItem);
235	if (catalogueItem->catalogue() == catalogue) {	293	if (catalogueItem->catalogue() == catalogue) {
236	return catalogueItem;	294	return catalogueItem;
237	}	295	}
238	}	296	}
239	else {	297	else {
240	qCWarning(LOG_CatalogueSideBarWidget()) << "getCatalogueItem: Invalid tree "	298	qCWarning(LOG_CatalogueSideBarWidget()) << "getCatalogueItem: Invalid tree "
241	"structure. A database item should "	299	"structure. A database item should "
242	"only contain catalogues.";	300	"only contain catalogues.";
243	Q_ASSERT(false);	301	Q_ASSERT(false);
244	}	302	}
245	}	303	}
246	}	304	}
247	}	305	}
248		306
249	return nullptr;	307	return nullptr;
250	}	308	}
		309
		310	void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::setHasChanges(bool value,
		311	const QModelIndex &index,
		312	QTreeView *treeView)
		313	{
		314	auto validationIndex = index.sibling(index.row(), (int)CatalogueTreeModel::Column::Validation);
		315	if (value) {
		316	if (!hasChanges(validationIndex, treeView)) {
		317	auto widget = CatalogueExplorerHelper::buildValidationWidget(
		318	treeView, [this, validationIndex,
		319	treeView]() { setHasChanges(false, validationIndex, treeView); },
		320	[this, validationIndex, treeView]() {
		321	setHasChanges(false, validationIndex, treeView);
		322	});
		323	treeView->setIndexWidget(validationIndex, widget);
		324	}
		325	}
		326	else {
		327	// Note: the widget is destroyed
		328	treeView->setIndexWidget(validationIndex, nullptr);
		329	}
		330	}
		331
		332	bool CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::hasChanges(const QModelIndex &index,
		333	QTreeView *treeView)
		334	{
		335	auto validationIndex = index.sibling(index.row(), (int)CatalogueTreeModel::Column::Validation);
		336	return treeView->indexWidget(validationIndex) != nullptr;
		337	}

gui/src/Catalogue/CatalogueTreeItems/CatalogueTreeItem.cpp ~~gui/src/Catalogue/CatalogueTreeWidgetItem.cpp~~ renamed +40 -36

-            #include "Catalogue/CatalogueTreeWidgetItem.h"
+            #include "Catalogue/CatalogueTreeItems/CatalogueTreeItem.h"
             #include <Catalogue/CatalogueExplorerHelper.h>
             #include <Catalogue/CatalogueController.h>
+            #include <Common/MimeTypesDef.h>
+            #include <QIcon>
+            #include <QMimeData>
             #include <SqpApplication.h>
             #include <memory>
             #include <DBCatalogue.h>
-            /// Column in the tree widget where the apply and cancel buttons must appear
+            struct CatalogueTreeItem::CatalogueTreeItemPrivate {
-            const auto APPLY_CANCEL_BUTTONS_COLUMN = 1;
-            struct CatalogueTreeWidgetItem::CatalogueTreeWidgetItemPrivate {
                 std::shared_ptr<DBCatalogue> m_Catalogue;
+                QIcon m_Icon;
-                CatalogueTreeWidgetItemPrivate(std::shared_ptr<DBCatalogue> catalogue) : m_Catalogue(catalogue)
+                CatalogueTreeItemPrivate(std::shared_ptr<DBCatalogue> catalogue, const QIcon &icon)
+                        : m_Catalogue(catalogue), m_Icon(icon)
                 {
                 }
             };
-            CatalogueTreeWidgetItem::CatalogueTreeWidgetItem(std::shared_ptr<DBCatalogue> catalogue, int type)
+            CatalogueTreeItem::CatalogueTreeItem(std::shared_ptr<DBCatalogue> catalogue, const QIcon &icon,
-                    : QTreeWidgetItem(type),
+                                                 int type)
-                      impl{spimpl::make_unique_impl<CatalogueTreeWidgetItemPrivate>(catalogue)}
+                    : CatalogueAbstractTreeItem(type),
+                      impl{spimpl::make_unique_impl<CatalogueTreeItemPrivate>(catalogue, icon)}
             {
-                setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable);
             }
-            QVariant CatalogueTreeWidgetItem::data(int column, int role) const
+            QVariant CatalogueTreeItem::data(int column, int role) const
             {
                 if (column == 0) {
                     switch (role) {
                         case Qt::EditRole: // fallthrough
                         case Qt::DisplayRole:
                             return impl->m_Catalogue->getName();
+                        case Qt::DecorationRole:
+                            return impl->m_Icon;
                         default:
                             break;
                     }
                 }
-                return QTreeWidgetItem::data(column, role);
+                return QVariant();
             }
-            void CatalogueTreeWidgetItem::setData(int column, int role, const QVariant &value)
+            bool CatalogueTreeItem::setData(int column, int role, const QVariant &value)
             {
+                bool result = false;
                 if (role == Qt::EditRole && column == 0) {
                     auto newName = value.toString();
                     if (newName != impl->m_Catalogue->getName()) {
-                        setText(0, newName);
                         impl->m_Catalogue->setName(newName);
                         sqpApp->catalogueController().updateCatalogue(impl->m_Catalogue);
-                        setHasChanges(true);
+                        result = true;
                     }
                 }
-                else {
-                    QTreeWidgetItem::setData(column, role, value);
-            std::shared_ptr<DBCatalogue> CatalogueTreeWidgetItem::catalogue() const
+                return result;
-                return impl->m_Catalogue;
             }
-            void CatalogueTreeWidgetItem::setHasChanges(bool value)
+            Qt::ItemFlags CatalogueTreeItem::flags(int column) const
             {
-                if (value) {
+                if (column == 0) {
-                    if (!hasChanges()) {
+                    return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable
-                        auto widget = CatalogueExplorerHelper::buildValidationWidget(
+                           | Qt::ItemIsDropEnabled;
-                            treeWidget(), [this]() { setHasChanges(false); },
-                            [this]() { setHasChanges(false); });
-                        treeWidget()->setItemWidget(this, APPLY_CANCEL_BUTTONS_COLUMN, widget);
                 }
                 else {
-                    // Note: the widget is destroyed
+                    return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
-                    treeWidget()->setItemWidget(this, APPLY_CANCEL_BUTTONS_COLUMN, nullptr);
                 }
             }
-            bool CatalogueTreeWidgetItem::hasChanges()
+            bool CatalogueTreeItem::canDropMimeData(const QMimeData *data, Qt::DropAction action)
             {
-                return treeWidget()->itemWidget(this, APPLY_CANCEL_BUTTONS_COLUMN) != nullptr;
+                return data->hasFormat(MIME_TYPE_EVENT_LIST);
             }
-            void CatalogueTreeWidgetItem::refresh()
+            bool CatalogueTreeItem::dropMimeData(const QMimeData *data, Qt::DropAction action)
             {
-                emitDataChanged();
+                Q_ASSERT(canDropMimeData(data, action));
+                auto events = sqpApp->catalogueController().eventsForMimeData(data->data(MIME_TYPE_EVENT_LIST));
+                // impl->m_Catalogue->addEvents(events); TODO: move events in the new catalogue
+                // Warning: Check that the events aren't already in the catalogue
+                // Also check for the repository !!!
+            }
+            std::shared_ptr<DBCatalogue> CatalogueTreeItem::catalogue() const
+            {
+                return impl->m_Catalogue;
             }

gui/src/Catalogue/CreateEventDialog.cpp +4 -4

             #include "Catalogue/CreateEventDialog.h"
             #include "ui_CreateEventDialog.h"
             #include <Catalogue/CatalogueController.h>
             #include <SqpApplication.h>
             #include <DBCatalogue.h>
             struct CreateEventDialog::CreateEventDialogPrivate {
                 QVector<std::shared_ptr<DBCatalogue> > m_DisplayedCatalogues;
             };
-            CreateEventDialog::CreateEventDialog(QWidget *parent)
+            CreateEventDialog::CreateEventDialog(const QVector<std::shared_ptr<DBCatalogue> > &catalogues,
+                                                 QWidget *parent)
                     : QDialog(parent),
                       ui(new Ui::CreateEventDialog),
                       impl{spimpl::make_unique_impl<CreateEventDialogPrivate>()}
             {
                 ui->setupUi(this);
                 connect(ui->buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
                 connect(ui->buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
-                auto catalogues = sqpApp->catalogueController().retrieveCatalogues();
+                impl->m_DisplayedCatalogues = catalogues;
-                for (auto cat : catalogues) {
+                for (auto cat : impl->m_DisplayedCatalogues) {
                     ui->cbCatalogue->addItem(cat->getName());
-                    impl->m_DisplayedCatalogues << cat;
                 }
             }
             CreateEventDialog::~CreateEventDialog()
             {
                 delete ui;
             }
             void CreateEventDialog::hideCatalogueChoice()
             {
                 ui->cbCatalogue->hide();
                 ui->lblCatalogue->hide();
             }
             QString CreateEventDialog::eventName() const
             {
                 return ui->leEvent->text();
             }
             std::shared_ptr<DBCatalogue> CreateEventDialog::selectedCatalogue() const
             {
                 auto catalogue = impl->m_DisplayedCatalogues.value(ui->cbCatalogue->currentIndex());
                 if (!catalogue || catalogue->getName() != catalogueName()) {
                     return nullptr;
                 }
                 return catalogue;
             }
             QString CreateEventDialog::catalogueName() const
             {
                 return ui->cbCatalogue->currentText();
             }

gui/src/SqpApplication.cpp +1 -13

             #include "SqpApplication.h"
             #include <Actions/ActionsGuiController.h>
             #include <Catalogue/CatalogueController.h>
             #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
             #include <DragAndDrop/DragDropGuiController.h>
             #include <Network/NetworkController.h>
             #include <QThread>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Visualization/VisualizationController.h>
             Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
             class SqpApplication::SqpApplicationPrivate {
             public:
                 SqpApplicationPrivate()
                         : m_DataSourceController{std::make_unique<DataSourceController>()},
                           m_VariableController{std::make_unique<VariableController>()},
                           m_TimeController{std::make_unique<TimeController>()},
                           m_NetworkController{std::make_unique<NetworkController>()},
                           m_VisualizationController{std::make_unique<VisualizationController>()},
                           m_DragDropGuiController{std::make_unique<DragDropGuiController>()},
                           m_CatalogueController{std::make_unique<CatalogueController>()},
                           m_ActionsGuiController{std::make_unique<ActionsGuiController>()},
                           m_PlotInterractionMode(SqpApplication::PlotsInteractionMode::None),
                           m_PlotCursorMode(SqpApplication::PlotsCursorMode::NoCursor)
                 {
                     // /////////////////////////////// //
                     // Connections between controllers //
                     // /////////////////////////////// //
                     // VariableController <-> DataSourceController
                     connect(m_DataSourceController.get(),
                             SIGNAL(variableCreationRequested(const QString &, const QVariantHash &,
                                                              std::shared_ptr<IDataProvider>)),
                             m_VariableController.get(),
                             SLOT(createVariable(const QString &, const QVariantHash &,
                                                 std::shared_ptr<IDataProvider>)));
                     connect(m_VariableController->variableModel(), &VariableModel::requestVariable,
                             m_DataSourceController.get(), &DataSourceController::requestVariable);
                     // VariableController <-> VisualizationController
                     connect(m_VariableController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
                             m_VisualizationController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
                     connect(m_VariableController.get(),
                             SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)),
                             m_VisualizationController.get(),
                             SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)));
                     m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
                     m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
                     m_NetworkController->moveToThread(&m_NetworkControllerThread);
                     m_NetworkControllerThread.setObjectName("NetworkControllerThread");
                     m_VariableController->moveToThread(&m_VariableControllerThread);
                     m_VariableControllerThread.setObjectName("VariableControllerThread");
                     m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
                     m_VisualizationControllerThread.setObjectName("VsualizationControllerThread");
-                    m_CatalogueController->moveToThread(&m_CatalogueControllerThread);
-                    m_CatalogueControllerThread.setObjectName("CatalogueControllerThread");
                     // Additionnal init
                     m_VariableController->setTimeController(m_TimeController.get());
                 }
                 virtual ~SqpApplicationPrivate()
                 {
                     m_DataSourceControllerThread.quit();
                     m_DataSourceControllerThread.wait();
                     m_NetworkControllerThread.quit();
                     m_NetworkControllerThread.wait();
                     m_VariableControllerThread.quit();
                     m_VariableControllerThread.wait();
                     m_VisualizationControllerThread.quit();
                     m_VisualizationControllerThread.wait();
-                    m_CatalogueControllerThread.quit();
-                    m_CatalogueControllerThread.wait();
                 }
                 std::unique_ptr<DataSourceController> m_DataSourceController;
                 std::unique_ptr<VariableController> m_VariableController;
                 std::unique_ptr<TimeController> m_TimeController;
                 std::unique_ptr<NetworkController> m_NetworkController;
                 std::unique_ptr<VisualizationController> m_VisualizationController;
                 std::unique_ptr<CatalogueController> m_CatalogueController;
                 QThread m_DataSourceControllerThread;
                 QThread m_NetworkControllerThread;
                 QThread m_VariableControllerThread;
                 QThread m_VisualizationControllerThread;
-                QThread m_CatalogueControllerThread;
                 std::unique_ptr<DragDropGuiController> m_DragDropGuiController;
                 std::unique_ptr<ActionsGuiController> m_ActionsGuiController;
                 SqpApplication::PlotsInteractionMode m_PlotInterractionMode;
                 SqpApplication::PlotsCursorMode m_PlotCursorMode;
             };
             SqpApplication::SqpApplication(int &argc, char **argv)
                     : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
             {
                 qCDebug(LOG_SqpApplication()) << tr("SqpApplication construction") << QThread::currentThread();
                 connect(&impl->m_DataSourceControllerThread, &QThread::started,
                         impl->m_DataSourceController.get(), &DataSourceController::initialize);
                 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
                         impl->m_DataSourceController.get(), &DataSourceController::finalize);
                 connect(&impl->m_NetworkControllerThread, &QThread::started, impl->m_NetworkController.get(),
                         &NetworkController::initialize);
                 connect(&impl->m_NetworkControllerThread, &QThread::finished, impl->m_NetworkController.get(),
                         &NetworkController::finalize);
                 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
                         &VariableController::initialize);
                 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
                         &VariableController::finalize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::started,
                         impl->m_VisualizationController.get(), &VisualizationController::initialize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
                         impl->m_VisualizationController.get(), &VisualizationController::finalize);
-                connect(&impl->m_CatalogueControllerThread, &QThread::started,
-                        impl->m_CatalogueController.get(), &CatalogueController::initialize);
-                connect(&impl->m_CatalogueControllerThread, &QThread::finished,
-                        impl->m_CatalogueController.get(), &CatalogueController::finalize);
                 impl->m_DataSourceControllerThread.start();
                 impl->m_NetworkControllerThread.start();
                 impl->m_VariableControllerThread.start();
                 impl->m_VisualizationControllerThread.start();
-                impl->m_CatalogueControllerThread.start();
+                impl->m_CatalogueController->initialize();
             }
             SqpApplication::~SqpApplication()
             {
             }
             void SqpApplication::initialize()
             {
             }
             DataSourceController &SqpApplication::dataSourceController() noexcept
             {
                 return *impl->m_DataSourceController;
             }
             NetworkController &SqpApplication::networkController() noexcept
             {
                 return *impl->m_NetworkController;
             }
             TimeController &SqpApplication::timeController() noexcept
             {
                 return *impl->m_TimeController;
             }
             VariableController &SqpApplication::variableController() noexcept
             {
                 return *impl->m_VariableController;
             }
             VisualizationController &SqpApplication::visualizationController() noexcept
             {
                 return *impl->m_VisualizationController;
             }
             CatalogueController &SqpApplication::catalogueController() noexcept
             {
                 return *impl->m_CatalogueController;
             }
             DragDropGuiController &SqpApplication::dragDropGuiController() noexcept
             {
                 return *impl->m_DragDropGuiController;
             }
             ActionsGuiController &SqpApplication::actionsGuiController() noexcept
             {
                 return *impl->m_ActionsGuiController;
             }
             SqpApplication::PlotsInteractionMode SqpApplication::plotsInteractionMode() const
             {
                 return impl->m_PlotInterractionMode;
             }
             void SqpApplication::setPlotsInteractionMode(SqpApplication::PlotsInteractionMode mode)
             {
                 impl->m_PlotInterractionMode = mode;
             }
             SqpApplication::PlotsCursorMode SqpApplication::plotsCursorMode() const
             {
                 return impl->m_PlotCursorMode;
             }
             void SqpApplication::setPlotsCursorMode(SqpApplication::PlotsCursorMode mode)
             {
                 impl->m_PlotCursorMode = mode;
             }

gui/ui/Catalogue/CatalogueEventsWidget.ui +6 0

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>CatalogueEventsWidget</class>
              <widget class="QWidget" name="CatalogueEventsWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>566</width>
                 <height>258</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QVBoxLayout" name="verticalLayout">
                <property name="leftMargin">
                 <number>0</number>
                </property>
                <property name="topMargin">
                 <number>0</number>
                </property>
                <property name="rightMargin">
                 <number>0</number>
                </property>
                <property name="bottomMargin">
                 <number>0</number>
                </property>
                <item>
                 <layout class="QHBoxLayout" name="horizontalLayout">
                  <item>
                   <widget class="QToolButton" name="btnAdd">
+                   <property name="enabled">
+                    <bool>false</bool>
+                   </property>
                    <property name="text">
                     <string>+</string>
                    </property>
                    <property name="icon">
                     <iconset resource="../../resources/sqpguiresources.qrc">
                      <normaloff>:/icones/add.png</normaloff>:/icones/add.png</iconset>
                    </property>
                    <property name="autoRaise">
                     <bool>true</bool>
                    </property>
                   </widget>
                  </item>
                  <item>
                   <widget class="QToolButton" name="btnRemove">
                    <property name="text">
                     <string> - </string>
                    </property>
                    <property name="icon">
                     <iconset resource="../../resources/sqpguiresources.qrc">
                      <normaloff>:/icones/remove.png</normaloff>:/icones/remove.png</iconset>
                    </property>
                    <property name="autoRaise">
                     <bool>true</bool>
                    </property>
                   </widget>
                  </item>
                  <item>
                   <widget class="Line" name="line">
                    <property name="orientation">
                     <enum>Qt::Vertical</enum>
                    </property>
                   </widget>
                  </item>
                  <item>
                   <widget class="QToolButton" name="btnTime">
                    <property name="text">
                     <string>T</string>
                    </property>
                    <property name="icon">
                     <iconset resource="../../resources/sqpguiresources.qrc">
                      <normaloff>:/icones/time.png</normaloff>:/icones/time.png</iconset>
                    </property>
                    <property name="checkable">
                     <bool>true</bool>
                    </property>
                    <property name="autoRaise">
                     <bool>true</bool>
                    </property>
                   </widget>
                  </item>
                  <item>
                   <widget class="QToolButton" name="btnChart">
+                   <property name="enabled">
+                    <bool>false</bool>
+                   </property>
                    <property name="text">
                     <string>G</string>
                    </property>
                    <property name="icon">
                     <iconset resource="../../resources/sqpguiresources.qrc">
                      <normaloff>:/icones/chart.png</normaloff>:/icones/chart.png</iconset>
                    </property>
                    <property name="checkable">
                     <bool>true</bool>
                    </property>
                    <property name="autoRaise">
                     <bool>true</bool>
                    </property>
                   </widget>
                  </item>
                  <item>
                   <widget class="Line" name="line_2">
                    <property name="orientation">
                     <enum>Qt::Vertical</enum>
                    </property>
                   </widget>
                  </item>
                  <item>
                   <widget class="QLineEdit" name="lineEdit">
                    <property name="enabled">
                     <bool>false</bool>
                    </property>
                   </widget>
                  </item>
                 </layout>
                </item>
                <item>
                 <widget class="QTreeView" name="treeView">
                  <property name="dragEnabled">
                   <bool>true</bool>
                  </property>
                  <property name="dragDropMode">
                   <enum>QAbstractItemView::DragDrop</enum>
                  </property>
                  <property name="selectionMode">
                   <enum>QAbstractItemView::ExtendedSelection</enum>
                  </property>
                  <property name="selectionBehavior">
                   <enum>QAbstractItemView::SelectRows</enum>
                  </property>
                  <attribute name="headerStretchLastSection">
                   <bool>false</bool>
                  </attribute>
                 </widget>
                </item>
               </layout>
              </widget>
              <resources>
               <include location="../../resources/sqpguiresources.qrc"/>
               <include location="../../resources/sqpguiresources.qrc"/>
              </resources>
              <connections/>
             </ui>

gui/ui/Catalogue/CatalogueSideBarWidget.ui +16 -6

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>CatalogueSideBarWidget</class>
              <widget class="QWidget" name="CatalogueSideBarWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>330</width>
                 <height>523</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QVBoxLayout" name="verticalLayout">
                <property name="leftMargin">
                 <number>0</number>
                </property>
                <property name="topMargin">
                 <number>0</number>
                </property>
                <property name="rightMargin">
                 <number>0</number>
                </property>
                <property name="bottomMargin">
                 <number>0</number>
                </property>
                <item>
                 <layout class="QHBoxLayout" name="horizontalLayout">
                  <item>
                   <widget class="QToolButton" name="btnAdd">
+                   <property name="enabled">
+                    <bool>false</bool>
+                   </property>
                    <property name="text">
                     <string>+</string>
                    </property>
                    <property name="icon">
                     <iconset resource="../../resources/sqpguiresources.qrc">
                      <normaloff>:/icones/add.png</normaloff>:/icones/add.png</iconset>
                    </property>
                    <property name="autoRaise">
                     <bool>true</bool>
                    </property>
                   </widget>
                  </item>
                  <item>
                   <widget class="QToolButton" name="btnRemove">
+                   <property name="enabled">
+                    <bool>false</bool>
+                   </property>
                    <property name="text">
                     <string> - </string>
                    </property>
                    <property name="icon">
                     <iconset resource="../../resources/sqpguiresources.qrc">
                      <normaloff>:/icones/remove.png</normaloff>:/icones/remove.png</iconset>
                    </property>
                    <property name="autoRaise">
                     <bool>true</bool>
                    </property>
                   </widget>
                  </item>
                  <item>
                   <spacer name="horizontalSpacer">
                    <property name="orientation">
                     <enum>Qt::Horizontal</enum>
                    </property>
                    <property name="sizeHint" stdset="0">
                     <size>
                      <width>40</width>
                      <height>20</height>
                     </size>
                    </property>
                   </spacer>
                  </item>
                 </layout>
                </item>
                <item>
-                <widget class="QTreeWidget" name="treeWidget">
+                <widget class="QTreeView" name="treeView">
+                 <property name="acceptDrops">
+                  <bool>true</bool>
+                 </property>
+                 <property name="dragDropMode">
+                  <enum>QAbstractItemView::DragDrop</enum>
+                 </property>
                  <property name="selectionMode">
                   <enum>QAbstractItemView::ExtendedSelection</enum>
                  </property>
                  <attribute name="headerVisible">
                   <bool>false</bool>
                  </attribute>
-                 <column>
+                 <attribute name="headerStretchLastSection">
-                  <property name="text">
+                  <bool>false</bool>
-                   <string notr="true">1</string>
+                 </attribute>
-                  </property>
-                 </column>
                 </widget>
                </item>
               </layout>
              </widget>
              <resources>
               <include location="../../resources/sqpguiresources.qrc"/>
               <include location="../../resources/sqpguiresources.qrc"/>
              </resources>
              <connections/>
             </ui>

plugins/amda/src/AmdaPlugin.cpp +1 0

             #include "AmdaPlugin.h"
             #include "AmdaDefs.h"
             #include "AmdaParser.h"
             #include "AmdaProvider.h"
             #include "AmdaServer.h"
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_AmdaPlugin, "AmdaPlugin")
             namespace {
             /// Path of the file used to generate the data source item for AMDA
             const auto JSON_FILE_PATH = QStringLiteral(":/samples/AmdaSampleV3.json");
             void associateActions(DataSourceItem &item, const QUuid &dataSourceUid)
             {
                 auto addLoadAction = [&item, dataSourceUid](const QString &label) {
                     item.addAction(
                         std::make_unique<DataSourceItemAction>(label, [dataSourceUid](DataSourceItem &item) {
                             if (auto app = sqpApp) {
                                 app->dataSourceController().loadProductItem(dataSourceUid, item);
                             }
                         }));
                 };
                 const auto itemType = item.type();
                 if (itemType == DataSourceItemType::PRODUCT || itemType == DataSourceItemType::COMPONENT) {
                     // Adds plugin name to item metadata
                     item.setData(DataSourceItem::PLUGIN_DATA_KEY, AmdaServer::instance().name());
                     // Adds load action
                     auto actionLabel = QObject::tr(
                         itemType == DataSourceItemType::PRODUCT ? "Load %1 product" : "Load %1 component");
                     addLoadAction(actionLabel.arg(item.name()));
+                    item.setData(DataSourceItem::ID_DATA_KEY, item.data(AMDA_XML_ID_KEY));
                 }
                 auto count = item.childCount();
                 for (auto i = 0; i < count; ++i) {
                     if (auto child = item.child(i)) {
                         associateActions(*child, dataSourceUid);
                     }
                 }
             }
             } // namespace
             void AmdaPlugin::initialize()
             {
                 if (auto app = sqpApp) {
                     auto dataSourceName = AmdaServer::instance().name();
                     // Registers to the data source controller
                     auto &dataSourceController = app->dataSourceController();
                     auto dataSourceUid = dataSourceController.registerDataSource(dataSourceName);
                     // Sets data source tree
                     if (auto dataSourceItem = AmdaParser::readJson(JSON_FILE_PATH)) {
                         dataSourceItem->setData(DataSourceItem::NAME_DATA_KEY, dataSourceName);
                         associateActions(*dataSourceItem, dataSourceUid);
                         dataSourceController.setDataSourceItem(dataSourceUid, std::move(dataSourceItem));
                     }
                     else {
                         qCCritical(LOG_AmdaPlugin()) << tr("No data source item could be generated for AMDA");
                     }
                     // Sets data provider
                     dataSourceController.setDataProvider(dataSourceUid, std::make_unique<AmdaProvider>());
                 }
                 else {
                     qCWarning(LOG_AmdaPlugin()) << tr("Can't access to SciQlop application");
                 }
             }

plugins/mockplugin/src/MockPlugin.cpp +1 0

             #include "MockPlugin.h"
             #include "CosinusProvider.h"
             #include "MockDefs.h"
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_MockPlugin, "MockPlugin")
             namespace {
             /// Name of the data source
             const auto DATA_SOURCE_NAME = QStringLiteral("MMS");
             /// Creates the data provider relative to the plugin
             std::unique_ptr<IDataProvider> createDataProvider() noexcept
             {
                 return std::make_unique<CosinusProvider>();
             }
             std::unique_ptr<DataSourceItem> createProductItem(const QVariantHash &data,
                                                               const QUuid &dataSourceUid)
             {
                 auto result = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, data);
                 // Adds plugin name to product metadata
                 result->setData(DataSourceItem::PLUGIN_DATA_KEY, DATA_SOURCE_NAME);
+                result->setData(DataSourceItem::ID_DATA_KEY, data.value(DataSourceItem::NAME_DATA_KEY));
                 auto productName = data.value(DataSourceItem::NAME_DATA_KEY).toString();
                 // Add action to load product from DataSourceController
                 result->addAction(std::make_unique<DataSourceItemAction>(
                     QObject::tr("Load %1 product").arg(productName),
                     [productName, dataSourceUid](DataSourceItem &item) {
                         if (auto app = sqpApp) {
                             app->dataSourceController().loadProductItem(dataSourceUid, item);
                         }
                     }));
                 return result;
             }
             /// Creates the data source item relative to the plugin
             std::unique_ptr<DataSourceItem> createDataSourceItem(const QUuid &dataSourceUid) noexcept
             {
                 // Magnetic field products
                 auto magneticFieldFolder = std::make_unique<DataSourceItem>(DataSourceItemType::NODE,
                                                                             QStringLiteral("_Magnetic field"));
                 magneticFieldFolder->appendChild(
                     createProductItem({{DataSourceItem::NAME_DATA_KEY, QStringLiteral("Scalar 10 Hz")},
                                        {COSINUS_TYPE_KEY, "scalar"},
                                        {COSINUS_FREQUENCY_KEY, 10.}},
                                       dataSourceUid));
                 magneticFieldFolder->appendChild(
                     createProductItem({{DataSourceItem::NAME_DATA_KEY, QStringLiteral("Scalar 60 Hz")},
                                        {COSINUS_TYPE_KEY, "scalar"},
                                        {COSINUS_FREQUENCY_KEY, 60.}},
                                       dataSourceUid));
                 magneticFieldFolder->appendChild(
                     createProductItem({{DataSourceItem::NAME_DATA_KEY, QStringLiteral("Scalar 100 Hz")},
                                        {COSINUS_TYPE_KEY, "scalar"},
                                        {COSINUS_FREQUENCY_KEY, 100.}},
                                       dataSourceUid));
                 magneticFieldFolder->appendChild(
                     createProductItem({{DataSourceItem::NAME_DATA_KEY, QStringLiteral("Vector 10 Hz")},
                                        {COSINUS_TYPE_KEY, "vector"},
                                        {COSINUS_FREQUENCY_KEY, 10.}},
                                       dataSourceUid));
                 magneticFieldFolder->appendChild(
                     createProductItem({{DataSourceItem::NAME_DATA_KEY, QStringLiteral("Vector 60 Hz")},
                                        {COSINUS_TYPE_KEY, "vector"},
                                        {COSINUS_FREQUENCY_KEY, 60.}},
                                       dataSourceUid));
                 magneticFieldFolder->appendChild(
                     createProductItem({{DataSourceItem::NAME_DATA_KEY, QStringLiteral("Vector 100 Hz")},
                                        {COSINUS_TYPE_KEY, "vector"},
                                        {COSINUS_FREQUENCY_KEY, 100.}},
                                       dataSourceUid));
                 magneticFieldFolder->appendChild(
                     createProductItem({{DataSourceItem::NAME_DATA_KEY, QStringLiteral("Spectrogram 1 Hz")},
                                        {COSINUS_TYPE_KEY, "spectrogram"},
                                        {COSINUS_FREQUENCY_KEY, 1.}},
                                       dataSourceUid));
                 // Electric field products
                 auto electricFieldFolder = std::make_unique<DataSourceItem>(DataSourceItemType::NODE,
                                                                             QStringLiteral("_Electric field"));
                 // Root
                 auto root = std::make_unique<DataSourceItem>(DataSourceItemType::NODE, DATA_SOURCE_NAME);
                 root->appendChild(std::move(magneticFieldFolder));
                 root->appendChild(std::move(electricFieldFolder));
                 return root;
             }
             } // namespace
             void MockPlugin::initialize()
             {
                 if (auto app = sqpApp) {
                     // Registers to the data source controller
                     auto &dataSourceController = app->dataSourceController();
                     auto dataSourceUid = dataSourceController.registerDataSource(DATA_SOURCE_NAME);
                     // Sets data source tree
                     dataSourceController.setDataSourceItem(dataSourceUid, createDataSourceItem(dataSourceUid));
                     // Sets data provider
                     dataSourceController.setDataProvider(dataSourceUid, createDataProvider());
                 }
                 else {
                     qCWarning(LOG_MockPlugin()) << tr("Can't access to SciQlop application");
                 }
             }

gui/include/Catalogue/CatalogueTreeWidgetItem.h removed 0 -36

NO CONTENT: file was removed

General Comments 3

perrinel

|

Auto status change to "Under Review"

perrinel

|

Status change > Approved

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages