GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1262:99c1ba5e139b

Updates model after an event has been created through the colored zone

trabillard -

r1262:99c1ba5e139b

parent child

Context file:

r1262:99c1ba5e139b

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

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

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

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

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

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

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

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

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

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

gui/src/Catalogue/CatalogueActionManager.cpp +30 -4

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

gui/src/Catalogue/CatalogueEventsWidget.cpp +38 -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")
             /// Fixed size of the validation column
             const auto VALIDATION_COLUMN_SIZE = 35;
             struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
                 CatalogueEventsModel *m_Model = nullptr;
                 QStringList m_ZonesForTimeMode;
                 QString m_ZoneForGraphMode;
+                QVector<std::shared_ptr<DBCatalogue> > m_DisplayedCatalogues;
                 VisualizationWidget *m_VisualizationWidget = nullptr;
                 void setEvents(const QVector<std::shared_ptr<DBEvent> > &events, QTreeView *treeView)
                 {
                     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((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::addEvent(const std::shared_ptr<DBEvent> &event)
+            {
+                impl->addEvent(event, ui->treeView);
+            }
             void CatalogueEventsWidget::setEventChanges(const std::shared_ptr<DBEvent> &event, bool hasChanges)
             {
                 impl->m_Model->refreshEvent(event);
                 auto eventIndex = impl->m_Model->indexOf(event);
                 auto validationIndex
                     = eventIndex.sibling(eventIndex.row(), (int)CatalogueEventsModel::Column::Validation);
                 if (hasChanges) {
                     if (ui->treeView->indexWidget(validationIndex) == nullptr) {
                         auto widget = CatalogueExplorerHelper::buildValidationWidget(
                             ui->treeView,
                             [this, event]() {
                                 sqpApp->catalogueController().saveEvent(event);
                                 setEventChanges(event, false);
                             },
                             [this, event]() { setEventChanges(event, false); });
                         ui->treeView->setIndexWidget(validationIndex, widget);
                     }
+                    impl->m_Model->setEventHasChanges(event, hasChanges);
                 }
                 else {
-                    // Note: the widget is destroyed
+                    qCWarning(LOG_CatalogueEventsWidget())
-                    ui->treeView->setIndexWidget(validationIndex, nullptr);
+                        << "setEventChanges: the event is not displayed in the model.";
                 }
+            }
+            QVector<std::shared_ptr<DBCatalogue> > CatalogueEventsWidget::displayedCatalogues() const
+            {
+                return impl->m_DisplayedCatalogues;
+            }
+            bool CatalogueEventsWidget::isAllEventsDisplayed() const
+            {
+                return impl->m_DisplayedCatalogues.isEmpty();
+            }
-                impl->m_Model->setEventHasChanges(event, hasChanges);
+            bool CatalogueEventsWidget::isEventDisplayed(const std::shared_ptr<DBEvent> &event) const
+            {
+                return impl->m_Model->indexOf(event).isValid();
             }
             void CatalogueEventsWidget::populateWithCatalogues(
                 const QVector<std::shared_ptr<DBCatalogue> > &catalogues)
             {
+                impl->m_DisplayedCatalogues = catalogues;
                 QSet<QUuid> eventIds;
                 QVector<std::shared_ptr<DBEvent> > events;
                 for (auto catalogue : catalogues) {
                     auto catalogueEvents = sqpApp->catalogueController().retrieveEventsFromCatalogue(catalogue);
                     for (auto event : catalogueEvents) {
                         if (!eventIds.contains(event->getUniqId())) {
                             events << event;
                             eventIds.insert(event->getUniqId());
                         }
                     }
                 }
                 impl->setEvents(events, ui->treeView);
             }
             void CatalogueEventsWidget::populateWithAllEvents()
             {
+                impl->m_DisplayedCatalogues.clear();
                 auto allEvents = sqpApp->catalogueController().retrieveAllEvents();
                 QVector<std::shared_ptr<DBEvent> > events;
                 for (auto event : allEvents) {
                     events << event;
                 }
                 impl->setEvents(events, ui->treeView);
             }
+            void CatalogueEventsWidget::refresh()
+            {
+                if (impl->m_DisplayedCatalogues.isEmpty()) {
+                    populateWithAllEvents();
+                }
+                else {
+                    populateWithCatalogues(impl->m_DisplayedCatalogues);
+                }
+            }

gui/src/Catalogue/CatalogueExplorer.cpp +16 -1

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

gui/src/Catalogue/CatalogueSideBarWidget.cpp +25 0

             #include "Catalogue/CatalogueSideBarWidget.h"
             #include "ui_CatalogueSideBarWidget.h"
             #include <SqpApplication.h>
             #include <Catalogue/CatalogueController.h>
             #include <Catalogue/CatalogueExplorerHelper.h>
             #include <Catalogue/CatalogueTreeItems/CatalogueTextTreeItem.h>
             #include <Catalogue/CatalogueTreeItems/CatalogueTreeItem.h>
             #include <Catalogue/CatalogueTreeModel.h>
             #include <CatalogueDao.h>
             #include <ComparaisonPredicate.h>
             #include <DBCatalogue.h>
             #include <QMenu>
             Q_LOGGING_CATEGORY(LOG_CatalogueSideBarWidget, "CatalogueSideBarWidget")
             constexpr auto ALL_EVENT_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 1;
             constexpr auto TRASH_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 2;
             constexpr auto CATALOGUE_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 3;
             constexpr auto DATABASE_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 4;
             struct CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate {
                 CatalogueTreeModel *m_TreeModel = nullptr;
                 void configureTreeWidget(QTreeView *treeView);
                 QModelIndex addDatabaseItem(const QString &name);
                 CatalogueAbstractTreeItem *getDatabaseItem(const QString &name);
                 void addCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue,
                                       const QModelIndex &databaseIndex);
                 CatalogueTreeItem *getCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue) const;
                 void setHasChanges(bool value, const QModelIndex &index, QTreeView *treeView);
                 bool hasChanges(const QModelIndex &index, QTreeView *treeView);
                 int selectionType(QTreeView *treeView) const
                 {
                     auto selectedItems = treeView->selectionModel()->selectedRows();
                     if (selectedItems.isEmpty()) {
                         return CatalogueAbstractTreeItem::DEFAULT_TYPE;
                     }
                     else {
                         auto firstIndex = selectedItems.first();
                         auto firstItem = m_TreeModel->item(firstIndex);
                         if (!firstItem) {
                             Q_ASSERT(false);
                             return CatalogueAbstractTreeItem::DEFAULT_TYPE;
                         }
                         auto selectionType = firstItem->type();
                         for (auto itemIndex : selectedItems) {
                             auto item = m_TreeModel->item(itemIndex);
                             if (!item || item->type() != selectionType) {
                                 // Incoherent multi selection
                                 selectionType = CatalogueAbstractTreeItem::DEFAULT_TYPE;
                                 break;
                             }
                         }
                         return selectionType;
                     }
                 }
                 QVector<std::shared_ptr<DBCatalogue> > selectedCatalogues(QTreeView *treeView) const
                 {
                     QVector<std::shared_ptr<DBCatalogue> > catalogues;
                     auto selectedItems = treeView->selectionModel()->selectedRows();
                     for (auto itemIndex : selectedItems) {
                         auto item = m_TreeModel->item(itemIndex);
                         if (item && item->type() == CATALOGUE_ITEM_TYPE) {
                             catalogues.append(static_cast<CatalogueTreeItem *>(item)->catalogue());
                         }
                     }
                     return catalogues;
                 }
                 QStringList selectedRepositories(QTreeView *treeView) const
                 {
                     QStringList repositories;
                     auto selectedItems = treeView->selectionModel()->selectedRows();
                     for (auto itemIndex : selectedItems) {
                         auto item = m_TreeModel->item(itemIndex);
                         if (item && item->type() == DATABASE_ITEM_TYPE) {
                             repositories.append(item->text());
                         }
                     }
                     return repositories;
                 }
             };
             CatalogueSideBarWidget::CatalogueSideBarWidget(QWidget *parent)
                     : QWidget(parent),
                       ui(new Ui::CatalogueSideBarWidget),
                       impl{spimpl::make_unique_impl<CatalogueSideBarWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 impl->m_TreeModel = new CatalogueTreeModel(this);
                 ui->treeView->setModel(impl->m_TreeModel);
                 impl->configureTreeWidget(ui->treeView);
                 ui->treeView->header()->setStretchLastSection(false);
                 ui->treeView->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
                 ui->treeView->header()->setSectionResizeMode(0, QHeaderView::Stretch);
                 auto emitSelection = [this]() {
                     auto selectionType = impl->selectionType(ui->treeView);
                     switch (selectionType) {
                         case CATALOGUE_ITEM_TYPE:
                             emit this->catalogueSelected(impl->selectedCatalogues(ui->treeView));
                             break;
                         case DATABASE_ITEM_TYPE:
                             emit this->databaseSelected(impl->selectedRepositories(ui->treeView));
                             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->treeView, &QTreeView::clicked, emitSelection);
                 connect(ui->treeView->selectionModel(), &QItemSelectionModel::currentChanged, emitSelection);
                 connect(impl->m_TreeModel, &CatalogueTreeModel::itemRenamed, [emitSelection, this](auto index) {
                     auto selectedIndexes = ui->treeView->selectionModel()->selectedRows();
                     if (selectedIndexes.contains(index)) {
                         emitSelection();
                     }
                     auto item = impl->m_TreeModel->item(index);
                     impl->setHasChanges(true, index, ui->treeView);
                 });
                 ui->treeView->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->treeView, &QTreeView::customContextMenuRequested, this,
                         &CatalogueSideBarWidget::onContextMenuRequested);
             }
             CatalogueSideBarWidget::~CatalogueSideBarWidget()
             {
                 delete ui;
             }
+            void CatalogueSideBarWidget::addCatalogue(const std::shared_ptr<DBCatalogue> &catalogue,
+                                                      const QString &repository)
+            {
+                auto repositoryItem = impl->getDatabaseItem(repository);
+                impl->addCatalogueItem(catalogue, impl->m_TreeModel->indexOf(repositoryItem));
+            }
             void CatalogueSideBarWidget::setCatalogueChanges(const std::shared_ptr<DBCatalogue> &catalogue,
                                                              bool hasChanges)
             {
                 if (auto catalogueItem = impl->getCatalogueItem(catalogue)) {
                     auto index = impl->m_TreeModel->indexOf(catalogueItem);
                     impl->setHasChanges(hasChanges, index, ui->treeView);
                     // catalogueItem->refresh();
                 }
             }
+            QVector<std::shared_ptr<DBCatalogue> >
+            CatalogueSideBarWidget::getCatalogues(const QString &repository) const
+            {
+                QVector<std::shared_ptr<DBCatalogue> > result;
+                auto repositoryItem = impl->getDatabaseItem(repository);
+                for (auto child : repositoryItem->children()) {
+                    if (child->type() == CATALOGUE_ITEM_TYPE) {
+                        auto catalogueItem = static_cast<CatalogueTreeItem *>(child);
+                        result << catalogueItem->catalogue();
+                    }
+                    else {
+                        qCWarning(LOG_CatalogueSideBarWidget()) << "getCatalogues: invalid structure";
+                    }
+                }
+                return result;
+            }
             void CatalogueSideBarWidget::onContextMenuRequested(const QPoint &pos)
             {
                 QMenu menu{this};
                 auto currentIndex = ui->treeView->currentIndex();
                 auto currentItem = impl->m_TreeModel->item(currentIndex);
                 if (!currentItem) {
                     return;
                 }
                 switch (currentItem->type()) {
                     case CATALOGUE_ITEM_TYPE:
                         menu.addAction("Rename", [this, currentIndex]() { ui->treeView->edit(currentIndex); });
                         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->treeView->mapToGlobal(pos));
                 }
             }
             void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::configureTreeWidget(QTreeView *treeView)
             {
                 auto allEventsItem = new CatalogueTextTreeItem{QIcon{":/icones/allEvents.png"}, "All Events",
                                                                ALL_EVENT_ITEM_TYPE};
                 m_TreeModel->addTopLevelItem(allEventsItem);
                 auto trashItem
                     = new CatalogueTextTreeItem{QIcon{":/icones/trash.png"}, "Trash", TRASH_ITEM_TYPE};
                 m_TreeModel->addTopLevelItem(trashItem);
                 auto separator = new QFrame{treeView};
                 separator->setFrameShape(QFrame::HLine);
                 auto separatorItem
                     = new CatalogueTextTreeItem{QIcon{}, QString{}, CatalogueAbstractTreeItem::DEFAULT_TYPE};
                 separatorItem->setEnabled(false);
                 auto separatorIndex = m_TreeModel->addTopLevelItem(separatorItem);
                 treeView->setIndexWidget(separatorIndex, separator);
                 auto repositories = sqpApp->catalogueController().getRepositories();
                 for (auto dbname : repositories) {
                     auto dbIndex = addDatabaseItem(dbname);
                     auto catalogues = sqpApp->catalogueController().retrieveCatalogues(dbname);
                     for (auto catalogue : catalogues) {
                         addCatalogueItem(catalogue, dbIndex);
                     }
                 }
                 treeView->expandAll();
             }
             QModelIndex
             CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addDatabaseItem(const QString &name)
             {
                 auto databaseItem
                     = new CatalogueTextTreeItem{QIcon{":/icones/database.png"}, {name}, DATABASE_ITEM_TYPE};
                 auto databaseIndex = m_TreeModel->addTopLevelItem(databaseItem);
                 return databaseIndex;
             }
             CatalogueAbstractTreeItem *
             CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getDatabaseItem(const QString &name)
             {
                 for (auto item : m_TreeModel->topLevelItems()) {
                     if (item->type() == DATABASE_ITEM_TYPE && item->text() == name) {
                         return item;
                     }
                 }
                 return nullptr;
             }
             void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addCatalogueItem(
                 const std::shared_ptr<DBCatalogue> &catalogue, const QModelIndex &databaseIndex)
             {
                 auto catalogueItem
                     = new CatalogueTreeItem{catalogue, QIcon{":/icones/catalogue.png"}, CATALOGUE_ITEM_TYPE};
                 m_TreeModel->addChildItem(catalogueItem, databaseIndex);
             }
             CatalogueTreeItem *CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getCatalogueItem(
                 const std::shared_ptr<DBCatalogue> &catalogue) const
             {
                 for (auto item : m_TreeModel->topLevelItems()) {
                     if (item->type() == DATABASE_ITEM_TYPE) {
                         for (auto childItem : item->children()) {
                             if (childItem->type() == CATALOGUE_ITEM_TYPE) {
                                 auto catalogueItem = static_cast<CatalogueTreeItem *>(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;
             }
             void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::setHasChanges(bool value,
                                                                                       const QModelIndex &index,
                                                                                       QTreeView *treeView)
             {
                 auto validationIndex = index.sibling(index.row(), (int)CatalogueTreeModel::Column::Validation);
                 if (value) {
                     if (!hasChanges(validationIndex, treeView)) {
                         auto widget = CatalogueExplorerHelper::buildValidationWidget(
                             treeView,
                             [this, validationIndex, treeView]() {
                                 setHasChanges(false, validationIndex, treeView);
                             },
                             [this, validationIndex, treeView]() {
                                 setHasChanges(false, validationIndex, treeView);
                             });
                         treeView->setIndexWidget(validationIndex, widget);
                     }
                 }
                 else {
                     // Note: the widget is destroyed
                     treeView->setIndexWidget(validationIndex, nullptr);
                 }
             }
             bool CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::hasChanges(const QModelIndex &index,
                                                                                    QTreeView *treeView)
             {
                 auto validationIndex = index.sibling(index.row(), (int)CatalogueTreeModel::Column::Validation);
                 return treeView->indexWidget(validationIndex) != nullptr;
             }

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

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

General Comments 0

Write
Preview

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

No TODOs yet

	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