GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1196:b6390f556418

Adaptation to last version of catalogue controller

trabillard -

r1196:b6390f556418

parent child

Context file:

r1196:b6390f556418

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/src/Catalogue/CatalogueActionManager.cpp +3 -3

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

gui/src/Catalogue/CatalogueExplorer.cpp +10 -4

             #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, [this]() {
                     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 +4 0

             #include "Catalogue/CatalogueTreeWidgetItem.h"
             #include <Catalogue/CatalogueExplorerHelper.h>
+            #include <Catalogue/CatalogueController.h>
+            #include <SqpApplication.h>
             #include <memory>
             #include <DBCatalogue.h>
             /// 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 (!hasChanges()) {
                         auto widget = CatalogueExplorerHelper::buildValidationWidget(
                             treeWidget(), [this]() { setHasChanges(false); },
                             [this]() { setHasChanges(false); });
                         treeWidget()->setItemWidget(this, APPLY_CANCEL_BUTTONS_COLUMN, widget);
                     }
                 }
                 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();
             }

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

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

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