HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1245:f0b824bb0975

fix refresh of events after a discard

trabillard -

r1245:f0b824bb0975

parent child

Context file:

r1245:f0b824bb0975

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

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

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

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

gui/src/Catalogue/CatalogueEventsModel.cpp +25 -1

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

gui/src/Catalogue/CatalogueEventsWidget.cpp +22 -19

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

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