GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1197:c3afe020c8f9

Merge branch 'feature/CatalogueGuiPart3' into develop

trabillard -

r1197:c3afe020c8f9

parent child

Context file:

r1197:c3afe020c8f9

gui/include/Catalogue/CatalogueActionManager.h created 644 +17 0

@@ -0,0 +1,17
	1	#ifndef SCIQLOP_CATALOGUEACTIONMANAGER_H
	2	#define SCIQLOP_CATALOGUEACTIONMANAGER_H
	3
	4	#include <Common/spimpl.h>
	5
	6	class CatalogueActionManager {
	7	public:
	8	CatalogueActionManager();
	9
	10	void installSelectionZoneActions();
	11
	12	private:
	13	class CatalogueActionManagerPrivate;
	14	spimpl::unique_impl_ptr<CatalogueActionManagerPrivate> impl;
	15	};
	16
	17	#endif // SCIQLOP_CATALOGUEACTIONMANAGER_H

gui/include/Catalogue/CatalogueExplorerHelper.h created 644 +13 0

@@ -0,0 +1,13
	1	#ifndef SCIQLOP_CATALOGUEEXPLORERHELPER_H
	2	#define SCIQLOP_CATALOGUEEXPLORERHELPER_H
	3
	4	#include <QWidget>
	5
	6	#include <functional>
	7
	8	struct CatalogueExplorerHelper {
	9	static QWidget buildValidationWidget(QWidget parent, std::function<void()> save,
	10	std::function<void()> discard);
	11	};
	12
	13	#endif // SCIQLOP_CATALOGUEEXPLORERHELPER_H

gui/include/Catalogue/CreateEventDialog.h created 644 +35 0

@@ -0,0 +1,35
	1	#ifndef SCIQLOP_CREATEEVENTDIALOG_H
	2	#define SCIQLOP_CREATEEVENTDIALOG_H
	3
	4	#include <Common/spimpl.h>
	5	#include <QDialog>
	6	#include <memory>
	7
	8	namespace Ui {
	9	class CreateEventDialog;
	10	}
	11
	12	class DBCatalogue;
	13
	14	class CreateEventDialog : public QDialog {
	15	Q_OBJECT
	16
	17	public:
	18	explicit CreateEventDialog(QWidget *parent = 0);
	19	virtual ~CreateEventDialog();
	20
	21	void hideCatalogueChoice();
	22
	23	QString eventName() const;
	24
	25	std::shared_ptr<DBCatalogue> selectedCatalogue() const;
	26	QString catalogueName() const;
	27
	28	private:
	29	Ui::CreateEventDialog *ui;
	30
	31	class CreateEventDialogPrivate;
	32	spimpl::unique_impl_ptr<CreateEventDialogPrivate> impl;
	33	};
	34
	35	#endif // SCIQLOP_CREATEEVENTDIALOG_H

gui/src/Catalogue/CatalogueActionManager.cpp created 644 +107 0

@@ -0,0 +1,107
	1	#include "Catalogue/CatalogueActionManager.h"
	2
	3	#include <Actions/ActionsGuiController.h>
	4	#include <Catalogue/CatalogueController.h>
	5	#include <SqpApplication.h>
	6	#include <Variable/Variable.h>
	7	#include <Visualization/VisualizationGraphWidget.h>
	8	#include <Visualization/VisualizationSelectionZoneItem.h>
	9
	10	#include <Catalogue/CreateEventDialog.h>
	11
	12	#include <DBCatalogue.h>
	13	#include <DBEvent.h>
	14	#include <DBEventProduct.h>
	15
	16	#include <QBoxLayout>
	17	#include <QComboBox>
	18	#include <QDialog>
	19	#include <QDialogButtonBox>
	20	#include <QLineEdit>
	21	#include <memory>
	22
	23	struct CatalogueActionManager::CatalogueActionManagerPrivate {
	24	void createEventFromZones(const QString &eventName,
	25	const QVector<VisualizationSelectionZoneItem *> &zones,
	26	const std::shared_ptr<DBCatalogue> &catalogue = nullptr)
	27	{
	28	auto event = std::make_shared<DBEvent>();
	29	event->setName(eventName);
	30
	31	std::list<DBEventProduct> productList;
	32	for (auto zone : zones) {
	33	auto graph = zone->parentGraphWidget();
	34	for (auto var : graph->variables()) {
	35	auto eventProduct = std::make_shared<DBEventProduct>();
	36	eventProduct->setEvent(*event);
	37
	38	auto zoneRange = zone->range();
	39	eventProduct->setTStart(zoneRange.m_TStart);
	40	eventProduct->setTEnd(zoneRange.m_TEnd);
	41
	42	eventProduct->setProductId(var->metadata().value("id", "TODO").toString()); // todo
	43
	44	productList.push_back(*eventProduct);
	45	}
	46	}
	47
	48	event->setEventProducts(productList);
	49
	50	sqpApp->catalogueController().addEvent(event);
	51
	52	if (catalogue) {
	53	// TODO
	54	// catalogue->addEvent(event);
	55	}
	56	}
	57	};
	58
	59	CatalogueActionManager::CatalogueActionManager()
	60	: impl{spimpl::make_unique_impl<CatalogueActionManagerPrivate>()}
	61	{
	62	}
	63
	64	void CatalogueActionManager::installSelectionZoneActions()
	65	{
	66	auto &actionController = sqpApp->actionsGuiController();
	67
	68	auto createEventEnableFuntion = [](auto zones) {
	69	QSet<VisualizationGraphWidget *> usedGraphs;
	70	for (auto zone : zones) {
	71	auto graph = zone->parentGraphWidget();
	72	if (!usedGraphs.contains(graph)) {
	73	usedGraphs.insert(graph);
	74	}
	75	else {
	76	return false;
	77	}
	78	}
	79
	80	return true;
	81	};
	82
	83	auto createEventAction = actionController.addSectionZoneAction(
	84	{QObject::tr("Catalogues")}, QObject::tr("New Event..."), [this](auto zones) {
	85	CreateEventDialog dialog;
	86	dialog.hideCatalogueChoice();
	87	if (dialog.exec() == QDialog::Accepted) {
	88	impl->createEventFromZones(dialog.eventName(), zones);
	89	}
	90	});
	91	createEventAction->setEnableFunction(createEventEnableFuntion);
	92
	93	auto createEventInCatalogueAction = actionController.addSectionZoneAction(
	94	{QObject::tr("Catalogues")}, QObject::tr("New Event in Catalogue..."), [this](auto zones) {
	95	CreateEventDialog dialog;
	96	if (dialog.exec() == QDialog::Accepted) {
	97	auto selectedCatalogue = dialog.selectedCatalogue();
	98	if (!selectedCatalogue) {
	99	selectedCatalogue = std::make_shared<DBCatalogue>();
	100	selectedCatalogue->setName(dialog.catalogueName());
	101	}
	102
	103	impl->createEventFromZones(dialog.eventName(), zones, selectedCatalogue);
	104	}
	105	});
	106	createEventInCatalogueAction->setEnableFunction(createEventEnableFuntion);
	107	}

gui/src/Catalogue/CatalogueExplorerHelper.cpp created 644 +32 0

@@ -0,0 +1,32
	1	#include "Catalogue/CatalogueExplorerHelper.h"
	2
	3	#include <QBoxLayout>
	4	#include <QToolButton>
	5
	6	const auto VALIDATION_BUTTON_ICON_SIZE = 12;
	7
	8	QWidget CatalogueExplorerHelper::buildValidationWidget(QWidget parent, std::function<void()> save,
	9	std::function<void()> discard)
	10	{
	11	auto widget = new QWidget{parent};
	12
	13	auto layout = new QHBoxLayout{widget};
	14	layout->setContentsMargins(0, 0, 0, 0);
	15	layout->setSpacing(0);
	16
	17	auto btnValid = new QToolButton{widget};
	18	btnValid->setIcon(QIcon{":/icones/save"});
	19	btnValid->setIconSize(QSize{VALIDATION_BUTTON_ICON_SIZE, VALIDATION_BUTTON_ICON_SIZE});
	20	btnValid->setAutoRaise(true);
	21	QObject::connect(btnValid, &QToolButton::clicked, save);
	22	layout->addWidget(btnValid);
	23
	24	auto btnDiscard = new QToolButton{widget};
	25	btnDiscard->setIcon(QIcon{":/icones/discard"});
	26	btnDiscard->setIconSize(QSize{VALIDATION_BUTTON_ICON_SIZE, VALIDATION_BUTTON_ICON_SIZE});
	27	btnDiscard->setAutoRaise(true);
	28	QObject::connect(btnDiscard, &QToolButton::clicked, discard);
	29	layout->addWidget(btnDiscard);
	30
	31	return widget;
	32	}

gui/src/Catalogue/CreateEventDialog.cpp created 644 +59 0

@@ -0,0 +1,59
	1	#include "Catalogue/CreateEventDialog.h"
	2	#include "ui_CreateEventDialog.h"
	3
	4	#include <Catalogue/CatalogueController.h>
	5	#include <SqpApplication.h>
	6
	7	#include <DBCatalogue.h>
	8
	9	struct CreateEventDialog::CreateEventDialogPrivate {
	10	QVector<std::shared_ptr<DBCatalogue> > m_DisplayedCatalogues;
	11	};
	12
	13	CreateEventDialog::CreateEventDialog(QWidget *parent)
	14	: QDialog(parent),
	15	ui(new Ui::CreateEventDialog),
	16	impl{spimpl::make_unique_impl<CreateEventDialogPrivate>()}
	17	{
	18	ui->setupUi(this);
	19
	20	connect(ui->buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
	21	connect(ui->buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
	22
	23	auto catalogues = sqpApp->catalogueController().retrieveCatalogues();
	24	for (auto cat : catalogues) {
	25	ui->cbCatalogue->addItem(cat->getName());
	26	impl->m_DisplayedCatalogues << cat;
	27	}
	28	}
	29
	30	CreateEventDialog::~CreateEventDialog()
	31	{
	32	delete ui;
	33	}
	34
	35	void CreateEventDialog::hideCatalogueChoice()
	36	{
	37	ui->cbCatalogue->hide();
	38	ui->lblCatalogue->hide();
	39	}
	40
	41	QString CreateEventDialog::eventName() const
	42	{
	43	return ui->leEvent->text();
	44	}
	45
	46	std::shared_ptr<DBCatalogue> CreateEventDialog::selectedCatalogue() const
	47	{
	48	auto catalogue = impl->m_DisplayedCatalogues.value(ui->cbCatalogue->currentIndex());
	49	if (!catalogue \|\| catalogue->getName() != catalogueName()) {
	50	return nullptr;
	51	}
	52
	53	return catalogue;
	54	}
	55
	56	QString CreateEventDialog::catalogueName() const
	57	{
	58	return ui->cbCatalogue->currentText();
	59	}

gui/ui/Catalogue/CreateEventDialog.ui created 644 +55 0

@@ -0,0 +1,55
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<ui version="4.0">
	3	<class>CreateEventDialog</class>
	4	<widget class="QDialog" name="CreateEventDialog">
	5	<property name="geometry">
	6	<rect>
	7	<x>0</x>
	8	<y>0</y>
	9	<width>324</width>
	10	<height>93</height>
	11	</rect>
	12	</property>
	13	<property name="windowTitle">
	14	<string>New Event</string>
	15	</property>
	16	<layout class="QGridLayout" name="gridLayout">
	17	<item row="0" column="0">
	18	<widget class="QLabel" name="label">
	19	<property name="text">
	20	<string>Event Name</string>
	21	</property>
	22	</widget>
	23	</item>
	24	<item row="0" column="1">
	25	<widget class="QLineEdit" name="leEvent"/>
	26	</item>
	27	<item row="1" column="0">
	28	<widget class="QLabel" name="lblCatalogue">
	29	<property name="text">
	30	<string>Catalogue</string>
	31	</property>
	32	</widget>
	33	</item>
	34	<item row="1" column="1">
	35	<widget class="QComboBox" name="cbCatalogue">
	36	<property name="editable">
	37	<bool>true</bool>
	38	</property>
	39	<property name="insertPolicy">
	40	<enum>QComboBox::NoInsert</enum>
	41	</property>
	42	</widget>
	43	</item>
	44	<item row="2" column="0" colspan="2">
	45	<widget class="QDialogButtonBox" name="buttonBox">
	46	<property name="standardButtons">
	47	<set>QDialogButtonBox::Ok</set>
	48	</property>
	49	</widget>
	50	</item>
	51	</layout>
	52	</widget>
	53	<resources/>
	54	<connections/>
	55	</ui>

core/include/Catalogue/CatalogueController.h +2 -1

             #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;
             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 removeEvent(std::shared_ptr<DBEvent> event);
                 //    void trashEvent(std::shared_ptr<DBEvent> event);
                 //    void restore(QUuid eventId);
                 void saveEvent(std::shared_ptr<DBEvent> event);
                 // 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) const;
+                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();
             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/src/Catalogue/CatalogueController.cpp +14 -5

             #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 <QMutex>
             #include <QThread>
             #include <QDir>
             #include <QStandardPaths>
             Q_LOGGING_CATEGORY(LOG_CatalogueController, "CatalogueController")
             namespace {
             static QString REPOSITORY_WORK_SUFFIX = QString{"work"};
             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;
                 void copyDBtoDB(const QString &dbFrom, const QString &dbTo);
                 QString toWorkRepository(QString repository);
                 QString toSyncRepository(QString repository);
             };
             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()));
                 impl->m_CatalogueDao.updateEvent(*event);
             }
             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);
             }
             void CatalogueController::addEvent(std::shared_ptr<DBEvent> event)
             {
-                event->setRepository(impl->toSyncRepository(event->getRepository()));
+                event->setRepository(impl->toWorkRepository(event->getRepository()));
                 impl->m_CatalogueDao.addEvent(*event);
                 // 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);
                 }
             }
             void CatalogueController::saveEvent(std::shared_ptr<DBEvent> event)
             {
                 impl->m_CatalogueDao.moveEvent(*event, impl->toSyncRepository(event->getRepository()), true);
             }
             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()));
                 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->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);
                     }
                     // Save Catalogue
                     auto catalogues = this->retrieveCatalogues(repository);
                     for (auto catalogue : catalogues) {
                         this->saveCatalogue(catalogue);
                     }
                 }
             }
             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()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void CatalogueController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }
             void CatalogueController::CatalogueControllerPrivate::copyDBtoDB(const QString &dbFrom,
                                                                              const QString &dbTo)
             {
-                auto catalogues = m_Q->retrieveCatalogues(dbFrom);
+                auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};
-                auto events = m_Q->retrieveEvents(dbFrom);
+                auto catalogues = m_CatalogueDao.getCatalogues(dbFrom);
                 for (auto catalogue : catalogues) {
-                    m_CatalogueDao.copyCatalogue(*catalogue, dbTo, true);
+                    cataloguesShared.push_back(std::make_shared<DBCatalogue>(catalogue));
                 }
+                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));
+                }
+                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);
             }
             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;
             }

gui/include/Catalogue/CatalogueEventsModel.h +22 0

             #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);
+                /// 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 +1 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 setEventChanges(const std::shared_ptr<DBEvent> &event, bool hasChanges);
             public slots:
                 void populateWithCatalogues(const QVector<std::shared_ptr<DBCatalogue> > &catalogues);
+                void populateWithAllEvents();
             private:
                 Ui::CatalogueEventsWidget *ui;
                 class CatalogueEventsWidgetPrivate;
                 spimpl::unique_impl_ptr<CatalogueEventsWidgetPrivate> impl;
             };
             #endif // SCIQLOP_CATALOGUEEVENTSWIDGET_H

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

             #ifndef SCIQLOP_CATALOGUETREEWIDGETITEM_H
             #define SCIQLOP_CATALOGUETREEWIDGETITEM_H
             #include <Common/spimpl.h>
             #include <QTreeWidgetItem>
             class DBCatalogue;
             class CatalogueTreeWidgetItem : public QTreeWidgetItem {
             public:
                 CatalogueTreeWidgetItem(std::shared_ptr<DBCatalogue> catalogue,
                                         int type = QTreeWidgetItem::Type);
                 QVariant data(int column, int role) const override;
                 void setData(int column, int role, const QVariant &value) override;
                 /// Returns the catalogue represented by the item
                 std::shared_ptr<DBCatalogue> catalogue() const;
                 /// Displays or hides the save and cancel buttons indicating that the catalogue has unsaved
                 /// changes
                 void setHasChanges(bool value);
+                /// Returns true if the widget indicating the event has unsaved changes is displayed
+                bool hasChanges();
                 /// Refreshes the data displayed by the item from the catalogue
                 void refresh();
             private:
                 class CatalogueTreeWidgetItemPrivate;
                 spimpl::unique_impl_ptr<CatalogueTreeWidgetItemPrivate> impl;
             };
             #endif // SCIQLOP_CATALOGUETREEWIDGETITEM_H

gui/meson.build +9 -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/CatalogueInspectorWidget.h',
+              'include/Catalogue/CatalogueEventsModel.h',
+              'include/Catalogue/CreateEventDialog.ui'
             ]
             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/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/CatalogueEventsModel.cpp'
+              'src/Catalogue/CatalogueEventsModel.cpp',
+              'src/Catalogue/CatalogueExplorerHelper.cpp',
+              'src/Catalogue/CatalogueActionManager.cpp',
+              'src/Catalogue/CreateEventDialog.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/CatalogueEventsModel.cpp +91 -30

             #include "Catalogue/CatalogueEventsModel.h"
             #include <Common/DateUtils.h>
             #include <Common/MimeTypesDef.h>
             #include <DBEvent.h>
             #include <DBEventProduct.h>
             #include <DBTag.h>
             #include <Data/SqpRange.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <list>
             #include <unordered_map>
             #include <QHash>
             #include <QMimeData>
+            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;
-                enum class Column { Name, TStart, TEnd, Tags, Product, NbColumn };
                 QStringList columnNames()
                 {
-                    return QStringList{tr("Event"), tr("TStart"), tr("TEnd"), tr("Tags"), tr("Product")};
+                    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
+                                                                                             : QVariant();
+                    }
+                    return eventData(col, event);
                 }
                 QVariant eventData(int col, const std::shared_ptr<DBEvent> &event) const
                 {
                     switch (static_cast<Column>(col)) {
-                        case Column::Name:
+                        case CatalogueEventsModel::Column::Name:
                             return event->getName();
-                        case Column::TStart:
+                        case CatalogueEventsModel::Column::TStart:
-                            return DateUtils::dateTime(event->getTStart());
+                            return nbEventProducts(event) > 0 ? DateUtils::dateTime(event->getTStart())
-                        case Column::TEnd:
+                                                              : QVariant{};
-                            return DateUtils::dateTime(event->getTEnd());
+                        case CatalogueEventsModel::Column::TEnd:
-                        case Column::Product: {
+                            return nbEventProducts(event) > 0 ? DateUtils::dateTime(event->getTEnd())
-                            auto eventProductsIt = m_EventProducts.find(event.get());
+                                                              : QVariant{};
-                            if (eventProductsIt != m_EventProducts.cend()) {
+                        case CatalogueEventsModel::Column::Product:
-                                return QString::number(m_EventProducts.at(event.get()).count()) + " product(s)";
+                            return QString::number(nbEventProducts(event)) + " product(s)";
+                        case CatalogueEventsModel::Column::Tags: {
-                            else {
-                                return "0 product";
-                        case 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 Column::Name:
+                        case CatalogueEventsModel::Column::Name:
                             return eventProduct->getProductId();
-                        case Column::TStart:
+                        case CatalogueEventsModel::Column::TStart:
                             return DateUtils::dateTime(eventProduct->getTStart());
-                        case Column::TEnd:
+                        case CatalogueEventsModel::Column::TEnd:
                             return DateUtils::dateTime(eventProduct->getTEnd());
-                        case Column::Product:
+                        case CatalogueEventsModel::Column::Product:
                             return eventProduct->getProductId();
-                        case Column::Tags: {
+                        case CatalogueEventsModel::Column::Tags:
                             return QString();
+                        case CatalogueEventsModel::Column::Validation:
+                            return QVariant();
                         default:
                             break;
                     }
                     Q_ASSERT(false);
                     return QStringLiteral("Unknown Data");
                 }
             };
             CatalogueEventsModel::CatalogueEventsModel(QObject *parent)
                     : QAbstractItemModel(parent), impl{spimpl::make_unique_impl<CatalogueEventsModelPrivate>()}
             {
             }
             void CatalogueEventsModel::setEvents(const QVector<std::shared_ptr<DBEvent> > &events)
             {
                 beginResetModel();
                 impl->m_Events = events;
                 impl->m_EventProducts.clear();
+                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);
                 impl->m_Events.append(event);
                 impl->parseEventProduct(event);
                 endInsertRows();
             }
             void CatalogueEventsModel::removeEvent(const std::shared_ptr<DBEvent> &event)
             {
                 auto index = impl->m_Events.indexOf(event);
                 if (index >= 0) {
                     beginRemoveRows(QModelIndex(), index, index);
                     impl->m_Events.removeAt(index);
                     impl->m_EventProducts.erase(event.get());
+                    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)
             {
-                auto i = impl->m_Events.indexOf(event);
+                auto eventIndex = indexOf(event);
-                if (i >= 0) {
+                if (eventIndex.isValid()) {
-                    auto eventIndex = index(i, 0);
+                    // Refreshes the event line
                     auto colCount = columnCount();
-                    emit dataChanged(eventIndex, index(i, colCount));
+                    emit dataChanged(eventIndex, index(eventIndex.row(), colCount));
+                    // Also refreshes its children event products
                     auto childCount = rowCount(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>(CatalogueEventsModelPrivate::Column::NbColumn);
+                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)
             {
                 std::sort(impl->m_Events.begin(), impl->m_Events.end(),
                           [this, column, order](auto e1, auto e2) {
-                              auto data1 = impl->eventData(column, e1);
+                              auto data1 = impl->sortData(column, e1);
-                              auto data2 = impl->eventData(column, e2);
+                              auto data2 = impl->sortData(column, e2);
                               auto result = data1.toString() < data2.toString();
                               return order == Qt::AscendingOrder ? result : !result;
                           });
                 emit dataChanged(QModelIndex(), QModelIndex());
+                emit modelSorted();
             }
             Qt::DropActions CatalogueEventsModel::supportedDragActions() const
             {
                 return Qt::CopyAction | Qt::MoveAction;
             }
             QStringList CatalogueEventsModel::mimeTypes() const
             {
                 return {MIME_TYPE_EVENT_LIST, MIME_TYPE_TIME_RANGE};
             }
             QMimeData *CatalogueEventsModel::mimeData(const QModelIndexList &indexes) const
             {
                 auto mimeData = new QMimeData;
                 bool isFirst = true;
                 QVector<std::shared_ptr<DBEvent> > eventList;
                 QVector<std::shared_ptr<DBEventProduct> > eventProductList;
                 SqpRange firstTimeRange;
                 for (const auto &index : indexes) {
                     if (index.column() == 0) { // only the first column
                         auto type = itemTypeOf(index);
                         if (type == ItemType::Event) {
                             auto event = getEvent(index);
                             eventList << event;
                             if (isFirst) {
                                 isFirst = false;
                                 firstTimeRange.m_TStart = event->getTStart();
                                 firstTimeRange.m_TEnd = event->getTEnd();
                             }
                         }
                         else if (type == ItemType::EventProduct) {
                             auto product = getEventProduct(index);
                             eventProductList << product;
                             if (isFirst) {
                                 isFirst = false;
                                 firstTimeRange.m_TStart = product->getTStart();
                                 firstTimeRange.m_TEnd = product->getTEnd();
                             }
                         }
                     }
                 }
                 auto eventsEncodedData
                     = QByteArray{}; // sqpApp->catalogueController().->mimeDataForEvents(eventList); //TODO
                 mimeData->setData(MIME_TYPE_EVENT_LIST, eventsEncodedData);
                 if (eventList.count() + eventProductList.count() == 1) {
                     // No time range MIME data if multiple events are dragged
                     auto timeEncodedData = TimeController::mimeDataForTimeRange(firstTimeRange);
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeEncodedData);
                 }
                 return mimeData;
             }
             CatalogueEventsModel::ItemType CatalogueEventsModel::itemTypeOf(const QModelIndex &index) const
             {
                 if (!index.isValid()) {
                     return ItemType::Root;
                 }
                 else if (index.internalPointer() == nullptr) {
                     return ItemType::Event;
                 }
                 else {
                     return ItemType::EventProduct;
                 }
             }

gui/src/Catalogue/CatalogueEventsWidget.cpp +47 -3

             #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>
             Q_LOGGING_CATEGORY(LOG_CatalogueEventsWidget, "CatalogueEventsWidget")
-            /// Format of the dates appearing in the label of a cursor
+            /// Fixed size of the validation column
-            const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss");
+            const auto VALIDATION_COLUMN_SIZE = 35;
             struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
                 CatalogueEventsModel *m_Model = nullptr;
                 QStringList m_ZonesForTimeMode;
                 QString m_ZoneForGraphMode;
                 VisualizationWidget *m_VisualizationWidget = nullptr;
                 void setEvents(const QVector<std::shared_ptr<DBEvent> > &events, QTreeView *treeView)
                 {
                     treeView->setSortingEnabled(false);
                     m_Model->setEvents(events);
                     treeView->setSortingEnabled(true);
                 }
                 void addEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
                 {
                     treeView->setSortingEnabled(false);
                     m_Model->addEvent(event);
                     treeView->setSortingEnabled(true);
                 }
                 void removeEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
                 {
                     treeView->setSortingEnabled(false);
                     m_Model->removeEvent(event);
                     treeView->setSortingEnabled(true);
                 }
                 QStringList getAvailableVisualizationZoneList() const
                 {
                     if (m_VisualizationWidget) {
                         if (auto tab = m_VisualizationWidget->currentTabWidget()) {
                             return tab->availableZoneWidgets();
                         }
                     }
                     return QStringList{};
                 }
                 QStringList selectZone(QWidget *parent, const QStringList &selectedZones,
                                        bool allowMultiSelection, const QPoint &location)
                 {
                     auto availableZones = getAvailableVisualizationZoneList();
                     if (availableZones.isEmpty()) {
                         return QStringList{};
                     }
                     QDialog d(parent, Qt::Tool);
                     d.setWindowTitle("Choose a zone");
                     auto layout = new QVBoxLayout{&d};
                     layout->setContentsMargins(0, 0, 0, 0);
                     auto listWidget = new QListWidget{&d};
                     layout->addWidget(listWidget);
                     QSet<QListWidgetItem *> checkedItems;
                     for (auto zone : availableZones) {
                         auto item = new QListWidgetItem{zone};
                         item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
                         if (selectedZones.contains(zone)) {
                             item->setCheckState(Qt::Checked);
                             checkedItems << item;
                         }
                         else {
                             item->setCheckState(Qt::Unchecked);
                         }
                         listWidget->addItem(item);
                     }
                     auto buttonBox = new QDialogButtonBox{QDialogButtonBox::Ok, &d};
                     layout->addWidget(buttonBox);
                     QObject::connect(buttonBox, &QDialogButtonBox::accepted, &d, &QDialog::accept);
                     QObject::connect(buttonBox, &QDialogButtonBox::rejected, &d, &QDialog::reject);
                     QObject::connect(listWidget, &QListWidget::itemChanged,
                                      [&checkedItems, allowMultiSelection, listWidget](auto item) {
                                          if (item->checkState() == Qt::Checked) {
                                              if (!allowMultiSelection) {
                                                  for (auto checkedItem : checkedItems) {
                                                      listWidget->blockSignals(true);
                                                      checkedItem->setCheckState(Qt::Unchecked);
                                                      listWidget->blockSignals(false);
                                                  }
                                                  checkedItems.clear();
                                              }
                                              checkedItems << item;
                                          }
                                          else {
                                              checkedItems.remove(item);
                                          }
                                      });
                     QStringList result;
                     d.setMinimumWidth(120);
                     d.resize(d.minimumSizeHint());
                     d.move(location);
                     if (d.exec() == QDialog::Accepted) {
                         for (auto item : checkedItems) {
                             result += item->text();
                         }
                     }
                     else {
                         result = selectedZones;
                     }
                     return result;
                 }
                 void updateForTimeMode(QTreeView *treeView)
                 {
                     auto selectedRows = treeView->selectionModel()->selectedRows();
                     if (selectedRows.count() == 1) {
                         auto event = m_Model->getEvent(selectedRows.first());
                         if (event) {
                             if (m_VisualizationWidget) {
                                 if (auto tab = m_VisualizationWidget->currentTabWidget()) {
                                     for (auto zoneName : m_ZonesForTimeMode) {
                                         if (auto zone = tab->getZoneWithName(zoneName)) {
                                             SqpRange eventRange;
                                             eventRange.m_TStart = event->getTStart();
                                             eventRange.m_TEnd = event->getTEnd();
                                             zone->setZoneRange(eventRange);
                                         }
                                     }
                                 }
                                 else {
                                     qCWarning(LOG_CatalogueEventsWidget())
                                         << "updateTimeZone: no tab found in the visualization";
                                 }
                             }
                             else {
                                 qCWarning(LOG_CatalogueEventsWidget())
                                     << "updateTimeZone: visualization widget not found";
                             }
                         }
                     }
                     else {
                         qCWarning(LOG_CatalogueEventsWidget())
                             << "updateTimeZone: not compatible with multiple events selected";
                     }
                 }
                 void updateForGraphMode(QTreeView *treeView)
                 {
                     auto selectedRows = treeView->selectionModel()->selectedRows();
                     if (selectedRows.count() == 1) {
                         auto event = m_Model->getEvent(selectedRows.first());
                         if (m_VisualizationWidget) {
                             if (auto tab = m_VisualizationWidget->currentTabWidget()) {
                                 if (auto zone = tab->getZoneWithName(m_ZoneForGraphMode)) {
                                     // TODO
                                 }
                             }
                             else {
                                 qCWarning(LOG_CatalogueEventsWidget())
                                     << "updateGraphMode: no tab found in the visualization";
                             }
                         }
                         else {
                             qCWarning(LOG_CatalogueEventsWidget())
                                 << "updateGraphMode: visualization widget not found";
                         }
                     }
                     else {
                         qCWarning(LOG_CatalogueEventsWidget())
                             << "updateGraphMode: not compatible with multiple events selected";
                     }
                 }
             };
             CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
                     : QWidget(parent),
                       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]() {
                     QVector<std::shared_ptr<DBEvent> > events;
                     QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
                     for (auto rowIndex : ui->treeView->selectionModel()->selectedRows()) {
                         auto itemType = impl->m_Model->itemTypeOf(rowIndex);
                         if (itemType == CatalogueEventsModel::ItemType::Event) {
                             events << impl->m_Model->getEvent(rowIndex);
                         }
                         else if (itemType == CatalogueEventsModel::ItemType::EventProduct) {
                             eventProducts << qMakePair(impl->m_Model->getParentEvent(rowIndex),
                                                        impl->m_Model->getEventProduct(rowIndex));
                         }
                     }
                     if (!events.isEmpty() && eventProducts.isEmpty()) {
                         emit this->eventsSelected(events);
                     }
                     else if (events.isEmpty() && !eventProducts.isEmpty()) {
                         emit this->eventProductsSelected(eventProducts);
                     }
                     else {
                         emit this->selectionCleared();
                     }
                 };
                 connect(ui->treeView, &QTreeView::clicked, emitSelection);
                 connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, emitSelection);
                 connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, [this]() {
                     auto isNotMultiSelection = ui->treeView->selectionModel()->selectedRows().count() <= 1;
                     ui->btnChart->setEnabled(isNotMultiSelection);
                     ui->btnTime->setEnabled(isNotMultiSelection);
                     if (isNotMultiSelection && ui->btnTime->isChecked()) {
                         impl->updateForTimeMode(ui->treeView);
                     }
                     else if (isNotMultiSelection && ui->btnChart->isChecked()) {
                         impl->updateForGraphMode(ui->treeView);
                     }
                 });
                 ui->treeView->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
-                ui->treeView->header()->setSectionResizeMode(0, QHeaderView::Stretch);
+                ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Name,
+                                                             QHeaderView::Stretch);
+                ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Validation,
+                                                             QHeaderView::Fixed);
+                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));
+                    }
+                });
             }
             CatalogueEventsWidget::~CatalogueEventsWidget()
             {
                 delete ui;
             }
             void CatalogueEventsWidget::setVisualizationWidget(VisualizationWidget *visualization)
             {
                 impl->m_VisualizationWidget = visualization;
             }
             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 (ui->treeView->indexWidget(validationIndex) == nullptr) {
+                        auto widget = CatalogueExplorerHelper::buildValidationWidget(
+                            ui->treeView, [this, event]() { setEventChanges(event, false); },
+                            [this, event]() { setEventChanges(event, false); });
+                        ui->treeView->setIndexWidget(validationIndex, widget);
+                    }
+                }
+                else {
+                    // Note: the widget is destroyed
+                    ui->treeView->setIndexWidget(validationIndex, nullptr);
+                }
+                impl->m_Model->setEventHasChanges(event, hasChanges);
             }
             void CatalogueEventsWidget::populateWithCatalogues(
                 const QVector<std::shared_ptr<DBCatalogue> > &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);
             }
+            void CatalogueEventsWidget::populateWithAllEvents()
+            {
+                auto allEvents = sqpApp->catalogueController().retrieveAllEvents();
+                QVector<std::shared_ptr<DBEvent> > events;
+                for (auto event : allEvents) {
+                    events << event;
+                }
+                impl->setEvents(events, ui->treeView);
+            }

gui/src/Catalogue/CatalogueExplorer.cpp +18 -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;
             };
             CatalogueExplorer::CatalogueExplorer(QWidget *parent)
                     : QDialog(parent, Qt::Dialog | Qt::WindowMinMaxButtonsHint | Qt::WindowCloseButtonHint),
                       ui(new Ui::CatalogueExplorer),
                       impl{spimpl::make_unique_impl<CatalogueExplorerPrivate>()}
             {
                 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,
                         [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
-                connect(ui->catalogues, &CatalogueSideBarWidget::allEventsSelected,
+                connect(ui->catalogues, &CatalogueSideBarWidget::allEventsSelected, [this]() {
-                        [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
+                    ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
+                    ui->events->populateWithAllEvents();
+                });
                 connect(ui->catalogues, &CatalogueSideBarWidget::selectionCleared,
                         [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
                 connect(ui->events, &CatalogueEventsWidget::eventsSelected, [this](auto events) {
                     if (events.count() == 1) {
                         ui->inspector->setEvent(events.first());
                     }
                     else {
                         ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
                     }
                 });
                 connect(ui->events, &CatalogueEventsWidget::eventProductsSelected, [this](auto eventProducts) {
                     if (eventProducts.count() == 1) {
                         ui->inspector->setEventProduct(eventProducts.first().first,
                                                        eventProducts.first().second);
                     }
                     else {
                         ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
                     }
                 });
                 connect(ui->events, &CatalogueEventsWidget::selectionCleared,
                         [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
-                connect(ui->inspector, &CatalogueInspectorWidget::catalogueUpdated,
+                connect(ui->inspector, &CatalogueInspectorWidget::catalogueUpdated, [this](auto catalogue) {
-                        [this](auto catalogue) { ui->catalogues->setCatalogueChanges(catalogue, true); });
+                    sqpApp->catalogueController().updateCatalogue(catalogue);
+                    ui->catalogues->setCatalogueChanges(catalogue, true);
+                });
-                connect(ui->inspector, &CatalogueInspectorWidget::eventUpdated,
+                connect(ui->inspector, &CatalogueInspectorWidget::eventUpdated, [this](auto event) {
-                        [this](auto event) { ui->events->setEventChanges(event, true); });
+                    sqpApp->catalogueController().updateEvent(event);
+                    ui->events->setEventChanges(event, true);
+                });
                 connect(ui->inspector, &CatalogueInspectorWidget::eventProductUpdated,
                         [this](auto event, auto eventProduct) { ui->events->setEventChanges(event, true); });
             }
             CatalogueExplorer::~CatalogueExplorer()
             {
                 delete ui;
             }
             void CatalogueExplorer::setVisualizationWidget(VisualizationWidget *visualization)
             {
                 ui->events->setVisualizationWidget(visualization);
             }

gui/src/Catalogue/CatalogueSideBarWidget.cpp +5 -2

             #include "Catalogue/CatalogueSideBarWidget.h"
             #include "ui_CatalogueSideBarWidget.h"
             #include <SqpApplication.h>
             #include <Catalogue/CatalogueController.h>
             #include <Catalogue/CatalogueTreeWidgetItem.h>
             #include <CatalogueDao.h>
             #include <ComparaisonPredicate.h>
             #include <DBCatalogue.h>
             #include <QMenu>
             Q_LOGGING_CATEGORY(LOG_CatalogueSideBarWidget, "CatalogueSideBarWidget")
             constexpr auto ALL_EVENT_ITEM_TYPE = QTreeWidgetItem::UserType;
             constexpr auto TRASH_ITEM_TYPE = QTreeWidgetItem::UserType + 1;
             constexpr auto CATALOGUE_ITEM_TYPE = QTreeWidgetItem::UserType + 2;
             constexpr auto DATABASE_ITEM_TYPE = QTreeWidgetItem::UserType + 3;
             struct CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate {
                 void configureTreeWidget(QTreeWidget *treeWidget);
                 QTreeWidgetItem *addDatabaseItem(const QString &name, QTreeWidget *treeWidget);
                 QTreeWidgetItem *getDatabaseItem(const QString &name, QTreeWidget *treeWidget);
                 void addCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue,
                                       QTreeWidgetItem *parentDatabaseItem);
                 CatalogueTreeWidgetItem *getCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue,
                                                           QTreeWidget *treeWidget) const;
             };
             CatalogueSideBarWidget::CatalogueSideBarWidget(QWidget *parent)
                     : QWidget(parent),
                       ui(new Ui::CatalogueSideBarWidget),
                       impl{spimpl::make_unique_impl<CatalogueSideBarWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 impl->configureTreeWidget(ui->treeWidget);
                 ui->treeWidget->setColumnCount(2);
                 ui->treeWidget->header()->setStretchLastSection(false);
                 ui->treeWidget->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
                 ui->treeWidget->header()->setSectionResizeMode(0, QHeaderView::Stretch);
                 auto emitSelection = [this]() {
                     auto selectedItems = ui->treeWidget->selectedItems();
                     if (selectedItems.isEmpty()) {
                         emit this->selectionCleared();
                     }
                     else {
                         QVector<std::shared_ptr<DBCatalogue> > catalogues;
                         QStringList databases;
                         int selectionType = selectedItems.first()->type();
                         for (auto item : ui->treeWidget->selectedItems()) {
                             if (item->type() == selectionType) {
                                 switch (selectionType) {
                                     case CATALOGUE_ITEM_TYPE:
                                         catalogues.append(
                                             static_cast<CatalogueTreeWidgetItem *>(item)->catalogue());
                                         break;
                                     case DATABASE_ITEM_TYPE:
                                         selectionType = DATABASE_ITEM_TYPE;
                                         databases.append(item->text(0));
                                     case ALL_EVENT_ITEM_TYPE: // fallthrough
                                     case TRASH_ITEM_TYPE:     // fallthrough
                                     default:
                                         break;
                                 }
                             }
                             else {
                                 // Incoherent multi selection
                                 selectionType = -1;
                                 break;
                             }
                         }
                         switch (selectionType) {
                             case CATALOGUE_ITEM_TYPE:
                                 emit this->catalogueSelected(catalogues);
                                 break;
                             case DATABASE_ITEM_TYPE:
                                 emit this->databaseSelected(databases);
                                 break;
                             case ALL_EVENT_ITEM_TYPE:
                                 emit this->allEventsSelected();
                                 break;
                             case TRASH_ITEM_TYPE:
                                 emit this->trashSelected();
                                 break;
                             default:
                                 emit this->selectionCleared();
                                 break;
                         }
                     }
                 };
                 connect(ui->treeWidget, &QTreeWidget::itemClicked, emitSelection);
                 connect(ui->treeWidget, &QTreeWidget::currentItemChanged, emitSelection);
                 connect(ui->treeWidget, &QTreeWidget::itemChanged,
                         [emitSelection, this](auto item, auto column) {
                             auto selectedItems = ui->treeWidget->selectedItems();
                             qDebug() << "ITEM CHANGED" << column;
                             if (selectedItems.contains(item) && column == 0) {
                                 emitSelection();
                             }
                         });
                 ui->treeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->treeWidget, &QTreeWidget::customContextMenuRequested, this,
                         &CatalogueSideBarWidget::onContextMenuRequested);
             }
             CatalogueSideBarWidget::~CatalogueSideBarWidget()
             {
                 delete ui;
             }
             void CatalogueSideBarWidget::setCatalogueChanges(const std::shared_ptr<DBCatalogue> &catalogue,
                                                              bool hasChanges)
             {
                 if (auto catalogueItem = impl->getCatalogueItem(catalogue, ui->treeWidget)) {
                     catalogueItem->setHasChanges(hasChanges);
                     catalogueItem->refresh();
                 }
             }
             void CatalogueSideBarWidget::onContextMenuRequested(const QPoint &pos)
             {
                 QMenu menu{this};
                 auto currentItem = ui->treeWidget->currentItem();
                 switch (currentItem->type()) {
                     case CATALOGUE_ITEM_TYPE:
                         menu.addAction("Rename",
                                        [this, currentItem]() { ui->treeWidget->editItem(currentItem); });
                         break;
                     case DATABASE_ITEM_TYPE:
                         break;
                     case ALL_EVENT_ITEM_TYPE:
                         break;
                     case TRASH_ITEM_TYPE:
                         menu.addAction("Empty Trash", []() {
                             // TODO
                         });
                         break;
                     default:
                         break;
                 }
                 if (!menu.isEmpty()) {
                     menu.exec(ui->treeWidget->mapToGlobal(pos));
                 }
             }
             void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::configureTreeWidget(
                 QTreeWidget *treeWidget)
             {
                 auto allEventsItem = new QTreeWidgetItem{{"All Events"}, ALL_EVENT_ITEM_TYPE};
                 allEventsItem->setIcon(0, QIcon(":/icones/allEvents.png"));
                 treeWidget->addTopLevelItem(allEventsItem);
                 auto trashItem = new QTreeWidgetItem{{"Trash"}, TRASH_ITEM_TYPE};
                 trashItem->setIcon(0, QIcon(":/icones/trash.png"));
                 treeWidget->addTopLevelItem(trashItem);
                 auto separator = new QFrame{treeWidget};
                 separator->setFrameShape(QFrame::HLine);
                 auto separatorItem = new QTreeWidgetItem{};
                 separatorItem->setFlags(Qt::NoItemFlags);
                 treeWidget->addTopLevelItem(separatorItem);
                 treeWidget->setItemWidget(separatorItem, 0, separator);
-                auto db = addDatabaseItem("Default", treeWidget);
+                auto repositories = sqpApp->catalogueController().getRepositories();
+                for (auto dbname : repositories) {
+                    auto db = addDatabaseItem(dbname, treeWidget);
-                auto catalogues = sqpApp->catalogueController().retrieveCatalogues("Default");
+                    auto catalogues = sqpApp->catalogueController().retrieveCatalogues(dbname);
                     for (auto catalogue : catalogues) {
                         addCatalogueItem(catalogue, db);
                     }
+                }
                 treeWidget->expandAll();
             }
             QTreeWidgetItem *
             CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addDatabaseItem(const QString &name,
                                                                                    QTreeWidget *treeWidget)
             {
                 auto databaseItem = new QTreeWidgetItem{{name}, DATABASE_ITEM_TYPE};
                 databaseItem->setIcon(0, QIcon{":/icones/database.png"});
                 treeWidget->addTopLevelItem(databaseItem);
                 return databaseItem;
             }
             QTreeWidgetItem *
             CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getDatabaseItem(const QString &name,
                                                                                    QTreeWidget *treeWidget)
             {
                 for (auto i = 0; i < treeWidget->topLevelItemCount(); ++i) {
                     auto item = treeWidget->topLevelItem(i);
                     if (item->type() == DATABASE_ITEM_TYPE && item->text(0) == name) {
                         return item;
                     }
                 }
                 return nullptr;
             }
             void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addCatalogueItem(
                 const std::shared_ptr<DBCatalogue> &catalogue, QTreeWidgetItem *parentDatabaseItem)
             {
                 auto catalogueItem = new CatalogueTreeWidgetItem{catalogue, CATALOGUE_ITEM_TYPE};
                 catalogueItem->setIcon(0, QIcon{":/icones/catalogue.png"});
                 parentDatabaseItem->addChild(catalogueItem);
             }
             CatalogueTreeWidgetItem *CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getCatalogueItem(
                 const std::shared_ptr<DBCatalogue> &catalogue, QTreeWidget *treeWidget) const
             {
                 for (auto i = 0; i < treeWidget->topLevelItemCount(); ++i) {
                     auto item = treeWidget->topLevelItem(i);
                     if (item->type() == DATABASE_ITEM_TYPE) {
                         for (auto j = 0; j < item->childCount(); ++j) {
                             auto childItem = item->child(j);
                             if (childItem->type() == CATALOGUE_ITEM_TYPE) {
                                 auto catalogueItem = static_cast<CatalogueTreeWidgetItem *>(childItem);
                                 if (catalogueItem->catalogue() == catalogue) {
                                     return catalogueItem;
                                 }
                             }
                             else {
                                 qCWarning(LOG_CatalogueSideBarWidget()) << "getCatalogueItem: Invalid tree "
                                                                            "structure. A database item should "
                                                                            "only contain catalogues.";
                                 Q_ASSERT(false);
                             }
                         }
                     }
                 }
                 return nullptr;
             }

gui/src/Catalogue/CatalogueTreeWidgetItem.cpp +15 -27

             #include "Catalogue/CatalogueTreeWidgetItem.h"
+            #include <Catalogue/CatalogueExplorerHelper.h>
+            #include <Catalogue/CatalogueController.h>
+            #include <SqpApplication.h>
             #include <memory>
             #include <DBCatalogue.h>
-            #include <QBoxLayout>
-            #include <QToolButton>
-            const auto VALIDATION_BUTTON_ICON_SIZE = 12;
             /// Column in the tree widget where the apply and cancel buttons must appear
             const auto APPLY_CANCEL_BUTTONS_COLUMN = 1;
             struct CatalogueTreeWidgetItem::CatalogueTreeWidgetItemPrivate {
                 std::shared_ptr<DBCatalogue> m_Catalogue;
                 CatalogueTreeWidgetItemPrivate(std::shared_ptr<DBCatalogue> catalogue) : m_Catalogue(catalogue)
                 {
                 }
             };
             CatalogueTreeWidgetItem::CatalogueTreeWidgetItem(std::shared_ptr<DBCatalogue> catalogue, int type)
                     : QTreeWidgetItem(type),
                       impl{spimpl::make_unique_impl<CatalogueTreeWidgetItemPrivate>(catalogue)}
             {
                 setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable);
             }
             QVariant CatalogueTreeWidgetItem::data(int column, int role) const
             {
                 if (column == 0) {
                     switch (role) {
                         case Qt::EditRole: // fallthrough
                         case Qt::DisplayRole:
                             return impl->m_Catalogue->getName();
                         default:
                             break;
                     }
                 }
                 return QTreeWidgetItem::data(column, role);
             }
             void CatalogueTreeWidgetItem::setData(int column, int role, const QVariant &value)
             {
                 if (role == Qt::EditRole && column == 0) {
                     auto newName = value.toString();
                     if (newName != impl->m_Catalogue->getName()) {
                         setText(0, newName);
                         impl->m_Catalogue->setName(newName);
+                        sqpApp->catalogueController().updateCatalogue(impl->m_Catalogue);
                         setHasChanges(true);
                     }
                 }
                 else {
                     QTreeWidgetItem::setData(column, role, value);
                 }
             }
             std::shared_ptr<DBCatalogue> CatalogueTreeWidgetItem::catalogue() const
             {
                 return impl->m_Catalogue;
             }
             void CatalogueTreeWidgetItem::setHasChanges(bool value)
             {
                 if (value) {
-                    if (treeWidget()->itemWidget(this, APPLY_CANCEL_BUTTONS_COLUMN) == nullptr) {
+                    if (!hasChanges()) {
-                        auto widet = new QWidget{treeWidget()};
+                        auto widget = CatalogueExplorerHelper::buildValidationWidget(
+                            treeWidget(), [this]() { setHasChanges(false); },
-                        auto layout = new QHBoxLayout{widet};
+                            [this]() { setHasChanges(false); });
-                        layout->setContentsMargins(0, 0, 0, 0);
+                        treeWidget()->setItemWidget(this, APPLY_CANCEL_BUTTONS_COLUMN, widget);
-                        layout->setSpacing(0);
-                        auto btnValid = new QToolButton{widet};
-                        btnValid->setIcon(QIcon{":/icones/save"});
-                        btnValid->setIconSize(QSize{VALIDATION_BUTTON_ICON_SIZE, VALIDATION_BUTTON_ICON_SIZE});
-                        btnValid->setAutoRaise(true);
-                        QObject::connect(btnValid, &QToolButton::clicked, [this]() { setHasChanges(false); });
-                        layout->addWidget(btnValid);
-                        auto btnDiscard = new QToolButton{widet};
-                        btnDiscard->setIcon(QIcon{":/icones/discard"});
-                        btnDiscard->setIconSize(
-                            QSize{VALIDATION_BUTTON_ICON_SIZE, VALIDATION_BUTTON_ICON_SIZE});
-                        btnDiscard->setAutoRaise(true);
-                        QObject::connect(btnDiscard, &QToolButton::clicked, [this]() { setHasChanges(false); });
-                        layout->addWidget(btnDiscard);
-                        treeWidget()->setItemWidget(this, APPLY_CANCEL_BUTTONS_COLUMN, {widet});
                     }
                 }
                 else {
                     // Note: the widget is destroyed
                     treeWidget()->setItemWidget(this, APPLY_CANCEL_BUTTONS_COLUMN, nullptr);
                 }
             }
+            bool CatalogueTreeWidgetItem::hasChanges()
+            {
+                return treeWidget()->itemWidget(this, APPLY_CANCEL_BUTTONS_COLUMN) != nullptr;
+            }
             void CatalogueTreeWidgetItem::refresh()
             {
                 emitDataChanged();
             }

General Comments 4

trabillard

|

Pull request updated. Auto status change to "Under Review"

Changed commits:
  * 1 added
  * 0 removed

Changed files:
  * M app/src/Main.cpp
  * M core/include/Catalogue/CatalogueController.h
  * M core/src/Catalogue/CatalogueController.cpp
  * M core/src/Plugin/PluginManager.cpp
  * M core/tests/Data/TestDataSeriesUtils.cpp
  * M gui/include/Catalogue/CatalogueEventsModel.h
  * M gui/include/Catalogue/CatalogueEventsWidget.h
  * M gui/include/Catalogue/CatalogueTreeWidgetItem.h
  * M gui/meson.build
  * M gui/src/Catalogue/CatalogueEventsModel.cpp
  * M gui/src/Catalogue/CatalogueEventsWidget.cpp
  * M gui/src/Catalogue/CatalogueExplorer.cpp
  * M gui/src/Catalogue/CatalogueSideBarWidget.cpp
  * M gui/src/Catalogue/CatalogueTreeWidgetItem.cpp
  * M gui/src/Visualization/VisualizationActionManager.cpp
  * M gui/src/Visualization/VisualizationGraphWidget.cpp
  * M gui/src/Visualization/VisualizationSelectionZoneItem.cpp
  * M plugins/amda/tests/TestAmdaResultParser.cpp
  * R cmake/FindCatalogueAPI.cmake
  * R core/include/Common/MimeTypesDef.h
  * R core/include/Data/DataSeriesUtils.h
  * R core/include/Data/OptionalAxis.h
  * R core/include/Data/SpectrogramSeries.h
  * R core/include/Data/Unit.h
  * R core/include/DataSource/DataSourceItemMergeHelper.h
  * R core/include/Variable/VariableCacheStrategyFactory.h
  * R core/include/Variable/VariableSingleThresholdCacheStrategy.h
  * R core/src/Common/MimeTypesDef.cpp
  * R core/src/Data/DataSeriesUtils.cpp
  * R core/src/Data/OptionalAxis.cpp
  * R core/src/Data/SpectrogramSeries.cpp
  * R core/src/DataSource/DataSourceItemMergeHelper.cpp
  * R core/tests-resources/TestDataSeriesUtils/TestThresholds.txt
  * R core/tests/Data/DataSeriesBuilders.cpp
  * R core/tests/Data/DataSeriesBuilders.h
  * R core/tests/Data/DataSeriesTestsUtils.cpp
  * R core/tests/Data/DataSeriesTestsUtils.h
  * R core/tests/Data/TestOptionalAxis.cpp
  * R core/tests/Data/TestScalarSeries.cpp
  * R core/tests/Data/TestSpectrogramSeries.cpp
  * R core/tests/Data/TestVectorSeries.cpp
  * R core/tests/DataSource/DataSourceItemBuilder.cpp
  * R core/tests/DataSource/DataSourceItemBuilder.h
  * R core/tests/DataSource/TestDataSourceItem.cpp
  * R core/tests/Variable/TestVariableSync.cpp
  * R extern/CatalogueAPI.cmake
  * R gui/include/Actions/ActionsGuiController.h
  * R gui/include/Actions/SelectionZoneAction.h
  * R gui/include/Catalogue/CatalogueExplorer.h
  * R gui/include/Catalogue/CatalogueInspectorWidget.h
  * R gui/include/Catalogue/CatalogueSideBarWidget.h
  * R gui/include/Common/VisualizationDef.h
  * R gui/include/DataSource/DataSourceTreeWidget.h
  * R gui/include/DragAndDrop/DragDropGuiController.h
  * R gui/include/DragAndDrop/DragDropScroller.h
  * R gui/include/DragAndDrop/DragDropTabSwitcher.h
  * R gui/include/Variable/VariableInspectorTableView.h
  * R gui/include/Visualization/AxisRenderingUtils.h
  * R gui/include/Visualization/ColorScaleEditor.h
  * R gui/include/Visualization/MacScrollBarStyle.h
  * R gui/include/Visualization/PlottablesRenderingUtils.h
  * R gui/include/Visualization/QCPColorMapIterator.h
  * R gui/include/Visualization/SqpColorScale.h
  * R gui/include/Visualization/VisualizationActionManager.h
  * R gui/include/Visualization/VisualizationCursorItem.h
  * R gui/include/Visualization/VisualizationDragDropContainer.h
  * R gui/include/Visualization/VisualizationDragWidget.h
  * R gui/include/Visualization/VisualizationMultiZoneSelectionDialog.h
  * R gui/include/Visualization/VisualizationSelectionZoneItem.h
  * R gui/include/Visualization/VisualizationSelectionZoneManager.h
  * R gui/resources/icones/add.png
  * R gui/resources/icones/allEvents.png
  * R gui/resources/icones/catalogue.png
  * R gui/resources/icones/chart.png
  * R gui/resources/icones/cursor.png
  * R gui/resources/icones/database.png
  * R gui/resources/icones/discard.png
  * R gui/resources/icones/drag.png
  * R gui/resources/icones/pointer.png
  * R gui/resources/icones/rectangle.png
  * R gui/resources/icones/remove.png
  * R gui/resources/icones/save.png
  * R gui/resources/icones/time.png
  * R gui/resources/icones/trash.png
  * R gui/resources/icones/zoom.png
  * R gui/src/Actions/ActionsGuiController.cpp
  * R gui/src/Actions/SelectionZoneAction.cpp
  * R gui/src/Catalogue/CatalogueInspectorWidget.cpp
  * R gui/src/Common/VisualizationDef.cpp
  * R gui/src/DataSource/DataSourceTreeWidget.cpp
  * R gui/src/DragAndDrop/DragDropGuiController.cpp
  * R gui/src/DragAndDrop/DragDropScroller.cpp
  * R gui/src/DragAndDrop/DragDropTabSwitcher.cpp
  * R gui/src/Variable/VariableInspectorTableView.cpp
  * R gui/src/Visualization/AxisRenderingUtils.cpp
  * R gui/src/Visualization/ColorScaleEditor.cpp
  * R gui/src/Visualization/MacScrollBarStyle.cpp
  * R gui/src/Visualization/PlottablesRenderingUtils.cpp
  * R gui/src/Visualization/QCPColorMapIterator.cpp
  * R gui/src/Visualization/SqpColorScale.cpp
  * R gui/src/Visualization/VisualizationCursorItem.cpp
  * R gui/src/Visualization/VisualizationDragDropContainer.cpp
  * R gui/src/Visualization/VisualizationDragWidget.cpp
  * R gui/src/Visualization/VisualizationMultiZoneSelectionDialog.cpp
  * R gui/src/Visualization/VisualizationSelectionZoneManager.cpp
  * R gui/ui/Catalogue/CatalogueEventsWidget.ui
  * R gui/ui/Catalogue/CatalogueExplorer.ui
  * R gui/ui/Catalogue/CatalogueInspectorWidget.ui
  * R gui/ui/Catalogue/CatalogueSideBarWidget.ui
  * R gui/ui/Visualization/ColorScaleEditor.ui
  * R gui/ui/Visualization/VisualizationMultiZoneSelectionDialog.ui
  * R plugins/amda/include/AmdaResultParserDefs.h
  * R plugins/amda/include/AmdaResultParserHelper.h
  * R plugins/amda/include/AmdaServer.h
  * R plugins/amda/resources/samples/AmdaSampleV3.json
  * R plugins/amda/src/AmdaResultParserDefs.cpp
  * R plugins/amda/src/AmdaResultParserHelper.cpp
  * R plugins/amda/src/AmdaServer.cpp
  * R plugins/amda/tests-resources/TestAmdaResultParser/amdaV2/FileNotFound.txt
  * R plugins/amda/tests-resources/TestAmdaResultParser/amdaV2/NaNValue.txt
  * R plugins/amda/tests-resources/TestAmdaResultParser/amdaV2/NaNX.txt
  * R plugins/amda/tests-resources/TestAmdaResultParser/amdaV2/NoUnit.txt
  * R plugins/amda/tests-resources/TestAmdaResultParser/amdaV2/TooManyValues.txt
  * R plugins/amda/tests-resources/TestAmdaResultParser/amdaV2/ValidScalar1.txt
  * R plugins/amda/tests-resources/TestAmdaResultParser/amdaV2/ValidVector1.txt
  * R plugins/amda/tests-resources/TestAmdaResultParser/amdaV2/WrongDate.txt
  * R plugins/amda/tests-resources/TestAmdaResultParser/amdaV2/WrongUnit.txt
  * R plugins/amda/tests-resources/TestAmdaResultParser/amdaV2/WrongValue.txt
  * R plugins/amda/tests-resources/TestAmdaResultParser/spectro/InvalidSpectrogramWrongBands.txt
  * R plugins/amda/tests-resources/TestAmdaResultParser/spectro/ValidSpectrogram1.txt
  * R plugins/amda/tests-resources/TestAmdaResultParser/spectro/ValidSpectrogram2.txt
  * R plugins/amda/tests-resources/TestAmdaResultParser/spectro/ValidSpectrogram3.txt
  * R plugins/amda/tests-resources/TestAmdaResultParser/spectro/ValidSpectrogramDataHoles.txt
  * R plugins/amda/tests-resources/TestAmdaResultParser/spectro/ValidSpectrogramDataHoles2.txt
  * R plugins/amda/tests-resources/TestAmdaResultParser/spectro/ValidSpectrogramFillValues.txt
  * R plugins/amda/tests-resources/TestAmdaResultParser/spectro/ValidSpectrogramNaNValues.txt
  * R plugins/amda/vera-exclusions/exclusions.txt
  * R plugins/mockplugin/include/MockDefs.h
  * R plugins/mockplugin/src/MockDefs.cpp
  * R subprojects/CatalogueAPI.wrap
  * R subprojects/QxOrm.wrap
  * R .gitignore
  * R CMakeLists.txt
  * R app/src/MainWindow.cpp
  * R app/ui/MainWindow.ui
  * R cmake/sciqlop_applications.cmake
  * R cmake/sciqlop_package_qt.cmake
  * R core/CMakeLists.txt
  * R core/cmake/Findsciqlop-core.cmake
  * R core/include/Common/SortUtils.h
  * R core/include/Data/ArrayData.h
  * R core/include/Data/DataSeries.h
  * R core/include/Data/DataSeriesIterator.h
  * R core/include/Data/IDataSeries.h
  * R core/include/Data/VariableRequest.h
  * R core/include/DataSource/DataSourceController.h
  * R core/include/DataSource/DataSourceItem.h
  * R core/include/DataSource/DataSourceItemAction.h
  * R core/include/Plugin/PluginManager.h
  * R core/include/Time/TimeController.h
  * R core/include/Variable/Variable.h
  * R core/include/Variable/VariableCacheStrategy.h
  * R core/include/Variable/VariableController.h
  * R core/include/Variable/VariableModel.h
  * R core/meson.build
  * R core/src/Data/DataSeriesIterator.cpp
  * R core/src/Data/VectorSeries.cpp
  * R core/src/DataSource/DataSourceController.cpp
  * R core/src/DataSource/DataSourceItem.cpp
  * R core/src/DataSource/DataSourceItemAction.cpp
  * R core/src/Time/TimeController.cpp
  * R core/src/Variable/Variable.cpp
  * R core/src/Variable/VariableAcquisitionWorker.cpp
  * R core/src/Variable/VariableController.cpp
  * R core/src/Variable/VariableModel.cpp
  * R core/tests/Data/TestTwoDimArrayData.cpp
  * R core/tests/Variable/TestVariable.cpp
  * R core/tests/meson.build
  * R gui/CMakeLists.txt
  * R gui/cmake/Findsciqlop-gui.cmake
  * R gui/include/DataSource/DataSourceWidget.h
  * R gui/include/SqpApplication.h
  * R gui/include/TimeWidget/TimeWidget.h
  * R gui/include/Visualization/VisualizationGraphHelper.h
  * R gui/include/Visualization/VisualizationGraphRenderingDelegate.h
  * R gui/include/Visualization/VisualizationGraphWidget.h
  * R gui/include/Visualization/VisualizationTabWidget.h
  * R gui/include/Visualization/VisualizationWidget.h
  * R gui/include/Visualization/VisualizationZoneWidget.h
  * R gui/resources/sqpguiresources.qrc
  * R gui/src/DataSource/DataSourceTreeWidgetItem.cpp
  * R gui/src/DataSource/DataSourceWidget.cpp
  * R gui/src/SqpApplication.cpp
  * R gui/src/TimeWidget/TimeWidget.cpp
  * R gui/src/Variable/VariableInspectorWidget.cpp
  * R gui/src/Visualization/VisualizationGraphHelper.cpp
  * R gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp
  * R gui/src/Visualization/VisualizationTabWidget.cpp
  * R gui/src/Visualization/VisualizationWidget.cpp
  * R gui/src/Visualization/VisualizationZoneWidget.cpp
  * R gui/src/Visualization/operations/GenerateVariableMenuOperation.cpp
  * R gui/src/Visualization/operations/RescaleAxeOperation.cpp
  * R gui/ui/DataSource/DataSourceWidget.ui
  * R gui/ui/TimeWidget/TimeWidget.ui
  * R gui/ui/Variable/VariableInspectorWidget.ui
  * R gui/ui/Visualization/VisualizationTabWidget.ui
  * R gui/ui/Visualization/VisualizationZoneWidget.ui
  * R gui/vera-exclusions/exclusions.txt
  * R meson.build
  * R plugins/amda/CMakeLists.txt
  * R plugins/amda/cmake/Findsciqlop-amda.cmake
  * R plugins/amda/include/AmdaDefs.h
  * R plugins/amda/include/AmdaPlugin.h
  * R plugins/amda/include/AmdaProvider.h
  * R plugins/amda/include/AmdaResultParser.h
  * R plugins/amda/meson.build
  * R plugins/amda/resources/amdaresources.qrc
  * R plugins/amda/src/AmdaDefs.cpp
  * R plugins/amda/src/AmdaPlugin.cpp
  * R plugins/amda/src/AmdaProvider.cpp
  * R plugins/amda/src/AmdaResultParser.cpp
  * R plugins/amda/tests/TestAmdaAcquisition.cpp
  * R plugins/mockplugin/cmake/Findsciqlop-mockplugin.cmake
  * R plugins/mockplugin/include/CosinusProvider.h
  * R plugins/mockplugin/meson.build
  * R plugins/mockplugin/src/CosinusProvider.cpp
  * R plugins/mockplugin/src/MockPlugin.cpp
  * R plugins/mockplugin/tests/TestCosinusAcquisition.cpp
  * R core/src/Variable/VariableCacheStrategy.cpp
  * R core/tests/Data/TestDataSeries.cpp

perrinel

|

Status change > Approved

Write
Preview

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

		Pull request merged and closed
		Status change > Approved
		Pull request updated. Auto status change to \|under_review\|...
		Auto status change to \|new_status\|...

	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