HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1149:c352dc0e2afa

Change the event model to a treeview model + update the last version of CatalogueAPI

trabillard -

r1149:c352dc0e2afa

parent child

Context file:

r1149:c352dc0e2afa

gui/include/Catalogue/CatalogueEventsModel.h ~~gui/include/Catalogue/CatalogueEventsTableModel.h~~ renamed +9 -7

-            #ifndef SCIQLOP_CATALOGUEEVENTSTABLEMODEL_H
+            #ifndef SCIQLOP_CATALOGUEEVENTSMODEL_H
-            #define SCIQLOP_CATALOGUEEVENTSTABLEMODEL_H
+            #define SCIQLOP_CATALOGUEEVENTSMODEL_H
             #include <Common/spimpl.h>
-            #include <QAbstractTableModel>
+            #include <QAbstractItemModel>
             class DBEvent;
-            class CatalogueEventsTableModel : public QAbstractTableModel {
+            class CatalogueEventsModel : public QAbstractItemModel {
             public:
-                CatalogueEventsTableModel(QObject *parent = nullptr);
+                CatalogueEventsModel(QObject *parent = nullptr);
                 void setEvents(const QVector<std::shared_ptr<DBEvent> > &events);
                 std::shared_ptr<DBEvent> getEvent(int row) const;
                 void addEvent(const std::shared_ptr<DBEvent> &event);
                 void removeEvent(const std::shared_ptr<DBEvent> &event);
                 void refreshEvent(const std::shared_ptr<DBEvent> &event);
                 // 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 CatalogueEventsTableModelPrivate;
                 spimpl::unique_impl_ptr<CatalogueEventsTableModelPrivate> impl;
             };
-            #endif // SCIQLOP_CATALOGUEEVENTSTABLEMODEL_H
+            #endif // SCIQLOP_CATALOGUEEVENTSMODEL_H

gui/meson.build +1 -1

             qxorm_dep = dependency('QxOrm', required : true, fallback:['QxOrm','qxorm_dep'])
             catalogueapi_dep = dependency('CatalogueAPI', required : true, fallback:['CatalogueAPI','CatalogueAPI_dep'])
             gui_moc_headers = [
               'include/DataSource/DataSourceWidget.h',
               'include/Settings/SqpSettingsDialog.h',
               'include/Settings/SqpSettingsGeneralWidget.h',
               'include/SidePane/SqpSidePane.h',
               'include/SqpApplication.h',
               'include/DragAndDrop/DragDropScroller.h',
               'include/DragAndDrop/DragDropTabSwitcher.h',
               'include/TimeWidget/TimeWidget.h',
               'include/Variable/VariableInspectorWidget.h',
               'include/Variable/RenameVariableDialog.h',
               'include/Visualization/qcustomplot.h',
               'include/Visualization/VisualizationGraphWidget.h',
               'include/Visualization/VisualizationTabWidget.h',
               'include/Visualization/VisualizationWidget.h',
               'include/Visualization/VisualizationZoneWidget.h',
               'include/Visualization/VisualizationDragDropContainer.h',
               'include/Visualization/VisualizationDragWidget.h',
               'include/Visualization/ColorScaleEditor.h',
               'include/Actions/SelectionZoneAction.h',
               'include/Visualization/VisualizationMultiZoneSelectionDialog.h',
               'include/Catalogue/CatalogueExplorer.h',
               'include/Catalogue/CatalogueEventsWidget.h',
               'include/Catalogue/CatalogueSideBarWidget.h',
               'include/Catalogue/CatalogueInspectorWidget.h'
             ]
             gui_ui_files = [
               'ui/DataSource/DataSourceWidget.ui',
               'ui/Settings/SqpSettingsDialog.ui',
               'ui/Settings/SqpSettingsGeneralWidget.ui',
               'ui/SidePane/SqpSidePane.ui',
               'ui/TimeWidget/TimeWidget.ui',
               'ui/Variable/VariableInspectorWidget.ui',
               'ui/Variable/RenameVariableDialog.ui',
               'ui/Variable/VariableMenuHeaderWidget.ui',
               'ui/Visualization/VisualizationGraphWidget.ui',
               'ui/Visualization/VisualizationTabWidget.ui',
               'ui/Visualization/VisualizationWidget.ui',
               'ui/Visualization/VisualizationZoneWidget.ui',
               'ui/Visualization/ColorScaleEditor.ui',
               'ui/Visualization/VisualizationMultiZoneSelectionDialog.ui',
               'ui/Catalogue/CatalogueExplorer.ui',
               'ui/Catalogue/CatalogueEventsWidget.ui',
               'ui/Catalogue/CatalogueSideBarWidget.ui',
               'ui/Catalogue/CatalogueInspectorWidget.ui'
             ]
             gui_qresources = ['resources/sqpguiresources.qrc']
             gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers,
                                            ui_files : gui_ui_files,
                                            qresources : gui_qresources)
             gui_sources = [
               'src/SqpApplication.cpp',
               'src/DragAndDrop/DragDropGuiController.cpp',
               'src/DragAndDrop/DragDropScroller.cpp',
               'src/DragAndDrop/DragDropTabSwitcher.cpp',
               'src/Common/ColorUtils.cpp',
               'src/Common/VisualizationDef.cpp',
               'src/DataSource/DataSourceTreeWidgetItem.cpp',
               'src/DataSource/DataSourceTreeWidgetHelper.cpp',
               'src/DataSource/DataSourceWidget.cpp',
               'src/DataSource/DataSourceTreeWidget.cpp',
               'src/Settings/SqpSettingsDialog.cpp',
               'src/Settings/SqpSettingsGeneralWidget.cpp',
               'src/SidePane/SqpSidePane.cpp',
               'src/TimeWidget/TimeWidget.cpp',
               'src/Variable/VariableInspectorWidget.cpp',
               'src/Variable/VariableInspectorTableView.cpp',
               'src/Variable/VariableMenuHeaderWidget.cpp',
               'src/Variable/RenameVariableDialog.cpp',
               'src/Visualization/VisualizationGraphHelper.cpp',
               'src/Visualization/VisualizationGraphRenderingDelegate.cpp',
               'src/Visualization/VisualizationGraphWidget.cpp',
               'src/Visualization/VisualizationTabWidget.cpp',
               'src/Visualization/VisualizationWidget.cpp',
               'src/Visualization/VisualizationZoneWidget.cpp',
               'src/Visualization/qcustomplot.cpp',
               'src/Visualization/QCustomPlotSynchronizer.cpp',
               'src/Visualization/operations/FindVariableOperation.cpp',
               'src/Visualization/operations/GenerateVariableMenuOperation.cpp',
               'src/Visualization/operations/MenuBuilder.cpp',
               'src/Visualization/operations/RemoveVariableOperation.cpp',
               'src/Visualization/operations/RescaleAxeOperation.cpp',
               'src/Visualization/VisualizationDragDropContainer.cpp',
               'src/Visualization/VisualizationDragWidget.cpp',
               'src/Visualization/AxisRenderingUtils.cpp',
               'src/Visualization/PlottablesRenderingUtils.cpp',
               'src/Visualization/MacScrollBarStyle.cpp',
               'src/Visualization/VisualizationCursorItem.cpp',
               'src/Visualization/ColorScaleEditor.cpp',
               'src/Visualization/SqpColorScale.cpp',
               'src/Visualization/QCPColorMapIterator.cpp',
               'src/Visualization/VisualizationSelectionZoneItem.cpp',
               'src/Visualization/VisualizationSelectionZoneManager.cpp',
               'src/Actions/SelectionZoneAction.cpp',
               'src/Actions/ActionsGuiController.cpp',
               'src/Visualization/VisualizationActionManager.cpp',
               'src/Visualization/VisualizationMultiZoneSelectionDialog.cpp',
               'src/Catalogue/CatalogueExplorer.cpp',
               'src/Catalogue/CatalogueEventsWidget.cpp',
               'src/Catalogue/CatalogueSideBarWidget.cpp',
               'src/Catalogue/CatalogueInspectorWidget.cpp',
               'src/Catalogue/CatalogueTreeWidgetItem.cpp',
-              'src/Catalogue/CatalogueEventsTableModel.cpp'
+              'src/Catalogue/CatalogueEventsModel.cpp'
             ]
             gui_inc = include_directories(['include'])
             sciqlop_gui_lib = library('sciqlopgui',
                                    gui_sources,
                                    gui_moc_files,
                                    include_directories : [gui_inc],
                                    dependencies : [ qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core, catalogueapi_dep],
                                    install : true
                                    )
             sciqlop_gui = declare_dependency(link_with : sciqlop_gui_lib,
                                             include_directories : gui_inc,
                                             dependencies : [qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core, catalogueapi_dep])

gui/src/Catalogue/CatalogueEventsModel.cpp ~~gui/src/Catalogue/CatalogueEventsTableModel.cpp~~ renamed +184 -35

-            #include "Catalogue/CatalogueEventsTableModel.h"
+            #include "Catalogue/CatalogueEventsModel.h"
             #include <Common/DateUtils.h>
             #include <Common/MimeTypesDef.h>
             #include <DBEvent.h>
+            #include <DBEventProduct.h>
             #include <DBTag.h>
             #include <Data/SqpRange.h>
-            #include <QMimeData>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
-            struct CatalogueEventsTableModel::CatalogueEventsTableModelPrivate {
+            #include <list>
+            #include <unordered_map>
+            #include <QHash>
+            #include <QMimeData>
+            const auto EVENT_ITEM_TYPE = 1;
+            const auto EVENT_PRODUCT_ITEM_TYPE = 2;
+            struct CatalogueEventsModel::CatalogueEventsTableModelPrivate {
                 QVector<std::shared_ptr<DBEvent> > m_Events;
+                std::unordered_map<DBEvent *, QVector<std::shared_ptr<DBEventProduct> > > m_EventProducts;
-                enum class Column { Event, TStart, TEnd, Tags, Product, NbColumn };
+                enum class Column { Name, TStart, TEnd, Tags, Product, NbColumn };
                 QStringList columnNames()
                 {
                     return QStringList{tr("Event"), tr("TStart"), tr("TEnd"), tr("Tags"), tr("Product")};
                 }
                 QVariant eventData(int col, const std::shared_ptr<DBEvent> &event) const
                 {
                     switch (static_cast<Column>(col)) {
-                        case Column::Event:
+                        case Column::Name:
                             return event->getName();
                         case Column::TStart:
-                            return DateUtils::dateTime(event->getTStart());
+                            return "Oo"; // DateUtils::dateTime(event->getTStart());
                         case Column::TEnd:
-                            return DateUtils::dateTime(event->getTEnd());
+                            return "oO"; // DateUtils::dateTime(event->getTEnd());
-                        case Column::Product:
+                        case Column::Product: {
-                            return event->getProduct();
+                            auto eventProductsIt = m_EventProducts.find(event.get());
+                            if (eventProductsIt != m_EventProducts.cend()) {
+                                return QString::number(m_EventProducts.at(event.get()).count()) + " product(s)";
+                            }
+                            else {
+                                return "0 product";
+                            }
+                        }
                         case Column::Tags: {
                             QString tagList;
                             auto tags = event->getTags();
                             for (auto tag : tags) {
                                 tagList += tag.getName();
                                 tagList += ' ';
                             }
                             return tagList;
                         }
                         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));
+                    }
+                }
+                QVariant eventProductData(int col, const std::shared_ptr<DBEventProduct> &eventProduct) const
+                {
+                    switch (static_cast<Column>(col)) {
+                        case Column::Name:
+                            return eventProduct->getProductId();
+                        case Column::TStart:
+                            return DateUtils::dateTime(eventProduct->getTStart());
+                        case Column::TEnd:
+                            return DateUtils::dateTime(eventProduct->getTEnd());
+                        case Column::Product:
+                            return eventProduct->getProductId();
+                        case Column::Tags: {
+                            return QString();
+                        }
+                        default:
+                            break;
+                    }
+                    Q_ASSERT(false);
+                    return QStringLiteral("Unknown Data");
+                }
+                enum class ItemType { Root, Event, EventProduct };
+                ItemType indexItemType(const QModelIndex &index) const
+                {
+                    if (!index.isValid()) {
+                        return ItemType::Root;
+                    }
+                    else if (index.internalPointer() == nullptr) {
+                        return ItemType::Event;
+                    }
+                    else {
+                        return ItemType::EventProduct;
+                    }
+                }
+                std::shared_ptr<DBEventProduct> getEventProduct(const QModelIndex &index)
+                {
+                    auto event = static_cast<DBEvent *>(index.internalPointer());
+                    return m_EventProducts.at(event).value(index.row());
+                }
             };
-            CatalogueEventsTableModel::CatalogueEventsTableModel(QObject *parent)
+            CatalogueEventsModel::CatalogueEventsModel(QObject *parent)
-                    : QAbstractTableModel(parent),
+                    : QAbstractItemModel(parent),
                       impl{spimpl::make_unique_impl<CatalogueEventsTableModelPrivate>()}
             {
             }
-            void CatalogueEventsTableModel::setEvents(const QVector<std::shared_ptr<DBEvent> > &events)
+            void CatalogueEventsModel::setEvents(const QVector<std::shared_ptr<DBEvent> > &events)
             {
                 beginResetModel();
                 impl->m_Events = events;
+                for (auto event : events) {
+                    impl->parseEventProduct(event);
+                }
                 endResetModel();
             }
-            std::shared_ptr<DBEvent> CatalogueEventsTableModel::getEvent(int row) const
+            std::shared_ptr<DBEvent> CatalogueEventsModel::getEvent(int row) const
             {
                 return impl->m_Events.value(row);
             }
-            void CatalogueEventsTableModel::addEvent(const std::shared_ptr<DBEvent> &event)
+            void CatalogueEventsModel::addEvent(const std::shared_ptr<DBEvent> &event)
             {
                 beginInsertRows(QModelIndex(), impl->m_Events.count() - 1, impl->m_Events.count() - 1);
                 impl->m_Events.append(event);
+                impl->parseEventProduct(event);
                 endInsertRows();
             }
-            void CatalogueEventsTableModel::removeEvent(const std::shared_ptr<DBEvent> &event)
+            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();
                 }
             }
-            void CatalogueEventsTableModel::refreshEvent(const std::shared_ptr<DBEvent> &event)
+            void CatalogueEventsModel::refreshEvent(const std::shared_ptr<DBEvent> &event)
             {
                 auto eventIndex = impl->m_Events.indexOf(event);
                 if (eventIndex >= 0) {
                     emit dataChanged(index(eventIndex, 0), index(eventIndex, columnCount()));
                 }
             }
-            int CatalogueEventsTableModel::rowCount(const QModelIndex &parent) const
+            QModelIndex CatalogueEventsModel::index(int row, int column, const QModelIndex &parent) const
             {
-                int r = impl->m_Events.count();
+                if (!hasIndex(row, column, parent)) {
-                return r;
+                    return QModelIndex();
+                }
+                switch (impl->indexItemType(parent)) {
+                    case CatalogueEventsTableModelPrivate::ItemType::Root:
+                        return createIndex(row, column);
+                    case CatalogueEventsTableModelPrivate::ItemType::Event: {
+                        auto event = getEvent(parent.row());
+                        return createIndex(row, column, event.get());
+                    }
+                    case CatalogueEventsTableModelPrivate::ItemType::EventProduct:
+                        break;
+                    default:
+                        break;
+                }
+                return QModelIndex();
             }
-            int CatalogueEventsTableModel::columnCount(const QModelIndex &parent) const
+            QModelIndex CatalogueEventsModel::parent(const QModelIndex &index) const
+            {
+                switch (impl->indexItemType(index)) {
+                    case CatalogueEventsTableModelPrivate::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 CatalogueEventsTableModelPrivate::ItemType::Root:
+                        break;
+                    case CatalogueEventsTableModelPrivate::ItemType::Event:
+                        break;
+                    default:
+                        break;
+                }
+                return QModelIndex();
+            }
+            int CatalogueEventsModel::rowCount(const QModelIndex &parent) const
+            {
+                if (parent.column() > 0) {
+                    return 0;
+                }
+                switch (impl->indexItemType(parent)) {
+                    case CatalogueEventsTableModelPrivate::ItemType::Root:
+                        return impl->m_Events.count();
+                    case CatalogueEventsTableModelPrivate::ItemType::Event: {
+                        auto event = getEvent(parent.row());
+                        return impl->m_EventProducts[event.get()].count();
+                    }
+                    case CatalogueEventsTableModelPrivate::ItemType::EventProduct:
+                        break;
+                    default:
+                        break;
+                }
+                return 0;
+            }
+            int CatalogueEventsModel::columnCount(const QModelIndex &parent) const
             {
                 return static_cast<int>(CatalogueEventsTableModelPrivate::Column::NbColumn);
             }
-            Qt::ItemFlags CatalogueEventsTableModel::flags(const QModelIndex &index) const
+            Qt::ItemFlags CatalogueEventsModel::flags(const QModelIndex &index) const
             {
                 return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
             }
-            QVariant CatalogueEventsTableModel::data(const QModelIndex &index, int role) const
+            QVariant CatalogueEventsModel::data(const QModelIndex &index, int role) const
             {
                 if (index.isValid()) {
-                    auto event = getEvent(index.row());
-                    switch (role) {
+                    auto type = impl->indexItemType(index);
-                        case Qt::DisplayRole:
+                    if (type == CatalogueEventsTableModelPrivate::ItemType::Event) {
-                            return impl->eventData(index.column(), event);
+                        auto event = getEvent(index.row());
-                            break;
+                        switch (role) {
+                            case Qt::DisplayRole:
+                                return impl->eventData(index.column(), event);
+                                break;
+                        }
+                    }
+                    else if (type == CatalogueEventsTableModelPrivate::ItemType::EventProduct) {
+                        auto product = impl->getEventProduct(index);
+                        switch (role) {
+                            case Qt::DisplayRole:
+                                return impl->eventProductData(index.column(), product);
+                                break;
+                        }
                     }
                 }
                 return QVariant{};
             }
-            QVariant CatalogueEventsTableModel::headerData(int section, Qt::Orientation orientation,
+            QVariant CatalogueEventsModel::headerData(int section, Qt::Orientation orientation, int role) const
-                                                           int role) const
             {
                 if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
                     return impl->columnNames().value(section);
                 }
                 return QVariant();
             }
-            void CatalogueEventsTableModel::sort(int column, Qt::SortOrder order)
+            void CatalogueEventsModel::sort(int column, Qt::SortOrder order)
             {
                 std::sort(impl->m_Events.begin(), impl->m_Events.end(),
                           [this, column, order](auto e1, auto e2) {
                               auto data1 = impl->eventData(column, e1);
                               auto data2 = impl->eventData(column, e2);
                               auto result = data1.toString() < data2.toString();
                               return order == Qt::AscendingOrder ? result : !result;
                           });
                 emit dataChanged(QModelIndex(), QModelIndex());
             }
-            Qt::DropActions CatalogueEventsTableModel::supportedDragActions() const
+            Qt::DropActions CatalogueEventsModel::supportedDragActions() const
             {
                 return Qt::CopyAction | Qt::MoveAction;
             }
-            QStringList CatalogueEventsTableModel::mimeTypes() const
+            QStringList CatalogueEventsModel::mimeTypes() const
             {
                 return {MIME_TYPE_EVENT_LIST, MIME_TYPE_TIME_RANGE};
             }
-            QMimeData *CatalogueEventsTableModel::mimeData(const QModelIndexList &indexes) const
+            QMimeData *CatalogueEventsModel::mimeData(const QModelIndexList &indexes) const
             {
                 auto mimeData = new QMimeData;
                 QVector<std::shared_ptr<DBEvent> > eventList;
                 SqpRange firstTimeRange;
                 for (const auto &index : indexes) {
                     if (index.column() == 0) { // only the first column
                         auto event = getEvent(index.row());
                         if (eventList.isEmpty()) {
                             // Gets the range of the first variable
-                            firstTimeRange.m_TStart = event->getTStart();
+                            // firstTimeRange.m_TStart = event->getTStart();
-                            firstTimeRange.m_TEnd = event->getTEnd();
+                            // firstTimeRange.m_TEnd = event->getTEnd();
                         }
                         eventList << event;
                     }
                 }
                 auto eventsEncodedData
                     = QByteArray{}; // sqpApp->catalogueController().->mimeDataForEvents(eventList); //TODO
                 mimeData->setData(MIME_TYPE_EVENT_LIST, eventsEncodedData);
                 if (eventList.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;
             }

gui/src/Catalogue/CatalogueEventsWidget.cpp +35 -35

             #include "Catalogue/CatalogueEventsWidget.h"
             #include "ui_CatalogueEventsWidget.h"
             #include <Catalogue/CatalogueController.h>
-            #include <Catalogue/CatalogueEventsTableModel.h>
+            #include <Catalogue/CatalogueEventsModel.h>
             #include <CatalogueDao.h>
             #include <DBCatalogue.h>
             #include <SqpApplication.h>
             #include <Visualization/VisualizationTabWidget.h>
             #include <Visualization/VisualizationWidget.h>
             #include <Visualization/VisualizationZoneWidget.h>
             #include <QDialog>
             #include <QDialogButtonBox>
             #include <QListWidget>
             Q_LOGGING_CATEGORY(LOG_CatalogueEventsWidget, "CatalogueEventsWidget")
             /// Format of the dates appearing in the label of a cursor
             const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss");
             struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
-                CatalogueEventsTableModel *m_Model = nullptr;
+                CatalogueEventsModel *m_Model = nullptr;
                 QStringList m_ZonesForTimeMode;
                 QString m_ZoneForGraphMode;
                 VisualizationWidget *m_VisualizationWidget = nullptr;
-                void setEvents(const QVector<std::shared_ptr<DBEvent> > &events, QTableView *tableView)
+                void setEvents(const QVector<std::shared_ptr<DBEvent> > &events, QTreeView *treeView)
                 {
-                    tableView->setSortingEnabled(false);
+                    treeView->setSortingEnabled(false);
                     m_Model->setEvents(events);
-                    tableView->setSortingEnabled(true);
+                    treeView->setSortingEnabled(true);
                 }
-                void addEvent(const std::shared_ptr<DBEvent> &event, QTableView *tableView)
+                void addEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
                 {
-                    tableView->setSortingEnabled(false);
+                    treeView->setSortingEnabled(false);
                     m_Model->addEvent(event);
-                    tableView->setSortingEnabled(true);
+                    treeView->setSortingEnabled(true);
                 }
-                void removeEvent(const std::shared_ptr<DBEvent> &event, QTableView *tableView)
+                void removeEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
                 {
-                    tableView->setSortingEnabled(false);
+                    treeView->setSortingEnabled(false);
                     m_Model->removeEvent(event);
-                    tableView->setSortingEnabled(true);
+                    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(QTableView *tableView)
+                void updateForTimeMode(QTreeView *treeView)
                 {
-                    auto selectedRows = tableView->selectionModel()->selectedRows();
+                    auto selectedRows = treeView->selectionModel()->selectedRows();
                     if (selectedRows.count() == 1) {
                         auto event = m_Model->getEvent(selectedRows.first().row());
                         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_TStart = event->getTStart();
-                                        eventRange.m_TEnd = event->getTEnd();
+                                        // 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(QTableView *tableView)
+                void updateForGraphMode(QTreeView *treeView)
                 {
-                    auto selectedRows = tableView->selectionModel()->selectedRows();
+                    auto selectedRows = treeView->selectionModel()->selectedRows();
                     if (selectedRows.count() == 1) {
                         auto event = m_Model->getEvent(selectedRows.first().row());
                         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 CatalogueEventsTableModel{this};
+                impl->m_Model = new CatalogueEventsModel{this};
-                ui->tableView->setModel(impl->m_Model);
+                ui->treeView->setModel(impl->m_Model);
-                ui->tableView->setSortingEnabled(true);
+                ui->treeView->setSortingEnabled(true);
-                ui->tableView->setDragDropMode(QAbstractItemView::DragDrop);
+                ui->treeView->setDragDropMode(QAbstractItemView::DragDrop);
-                ui->tableView->setDragEnabled(true);
+                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->tableView);
+                        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->tableView);
+                        impl->updateForGraphMode(ui->treeView);
                     }
                 });
                 auto emitSelection = [this]() {
                     QVector<std::shared_ptr<DBEvent> > events;
-                    for (auto rowIndex : ui->tableView->selectionModel()->selectedRows()) {
+                    for (auto rowIndex : ui->treeView->selectionModel()->selectedRows()) {
                         events << impl->m_Model->getEvent(rowIndex.row());
                     }
                     emit this->eventsSelected(events);
                 };
-                connect(ui->tableView, &QTableView::clicked, emitSelection);
+                connect(ui->treeView, &QTreeView::clicked, emitSelection);
-                connect(ui->tableView->selectionModel(), &QItemSelectionModel::selectionChanged, emitSelection);
+                connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, emitSelection);
-                connect(ui->tableView->selectionModel(), &QItemSelectionModel::selectionChanged, [this]() {
+                connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, [this]() {
-                    auto isNotMultiSelection = ui->tableView->selectionModel()->selectedRows().count() <= 1;
+                    auto isNotMultiSelection = ui->treeView->selectionModel()->selectedRows().count() <= 1;
                     ui->btnChart->setEnabled(isNotMultiSelection);
                     ui->btnTime->setEnabled(isNotMultiSelection);
                     if (isNotMultiSelection && ui->btnTime->isChecked()) {
-                        impl->updateForTimeMode(ui->tableView);
+                        impl->updateForTimeMode(ui->treeView);
                     }
                     else if (isNotMultiSelection && ui->btnChart->isChecked()) {
-                        impl->updateForGraphMode(ui->tableView);
+                        impl->updateForGraphMode(ui->treeView);
                     }
                 });
-                ui->tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
+                ui->treeView->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
-                ui->tableView->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
+                ui->treeView->header()->setSectionResizeMode(0, QHeaderView::Stretch);
-                ui->tableView->horizontalHeader()->setSortIndicatorShown(true);
+                ui->treeView->header()->setSortIndicatorShown(true);
             }
             CatalogueEventsWidget::~CatalogueEventsWidget()
             {
                 delete ui;
             }
             void CatalogueEventsWidget::setVisualizationWidget(VisualizationWidget *visualization)
             {
                 impl->m_VisualizationWidget = visualization;
             }
             void CatalogueEventsWidget::setEventChanges(const std::shared_ptr<DBEvent> &event, bool hasChanges)
             {
                 impl->m_Model->refreshEvent(event);
             }
             void CatalogueEventsWidget::populateWithCatalogues(
                 const QVector<std::shared_ptr<DBCatalogue> > &catalogues)
             {
                 QSet<QUuid> eventIds;
                 QVector<std::shared_ptr<DBEvent> > events;
                 for (auto catalogue : catalogues) {
                     auto catalogueEvents = sqpApp->catalogueController().retrieveEventsFromCatalogue(catalogue);
                     for (auto event : catalogueEvents) {
                         if (!eventIds.contains(event->getUniqId())) {
                             events << event;
                             eventIds.insert(event->getUniqId());
                         }
                     }
                 }
-                impl->setEvents(events, ui->tableView);
+                impl->setEvents(events, ui->treeView);
             }

gui/src/Catalogue/CatalogueInspectorWidget.cpp +22 -22

             #include "Catalogue/CatalogueInspectorWidget.h"
             #include "ui_CatalogueInspectorWidget.h"
             #include <Common/DateUtils.h>
             #include <DBCatalogue.h>
             #include <DBEvent.h>
             #include <DBTag.h>
             struct CatalogueInspectorWidget::CatalogueInspectorWidgetPrivate {
                 std::shared_ptr<DBCatalogue> m_DisplayedCatalogue = nullptr;
                 std::shared_ptr<DBEvent> m_DisplayedEvent = nullptr;
                 void connectCatalogueUpdateSignals(CatalogueInspectorWidget *inspector,
                                                    Ui::CatalogueInspectorWidget *ui);
                 void connectEventUpdateSignals(CatalogueInspectorWidget *inspector,
                                                Ui::CatalogueInspectorWidget *ui);
             };
             CatalogueInspectorWidget::CatalogueInspectorWidget(QWidget *parent)
                     : QWidget(parent),
                       ui(new Ui::CatalogueInspectorWidget),
                       impl{spimpl::make_unique_impl<CatalogueInspectorWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 showPage(Page::Empty);
                 impl->connectCatalogueUpdateSignals(this, ui);
                 impl->connectEventUpdateSignals(this, ui);
             }
             CatalogueInspectorWidget::~CatalogueInspectorWidget()
             {
                 delete ui;
             }
             void CatalogueInspectorWidget::CatalogueInspectorWidgetPrivate::connectCatalogueUpdateSignals(
                 CatalogueInspectorWidget *inspector, Ui::CatalogueInspectorWidget *ui)
             {
                 connect(ui->leCatalogueName, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     if (ui->leCatalogueName->text() != m_DisplayedCatalogue->getName()) {
                         m_DisplayedCatalogue->setName(ui->leCatalogueName->text());
                         emit inspector->catalogueUpdated(m_DisplayedCatalogue);
                     }
                 });
                 connect(ui->leCatalogueAuthor, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     if (ui->leCatalogueAuthor->text() != m_DisplayedCatalogue->getAuthor()) {
                         m_DisplayedCatalogue->setAuthor(ui->leCatalogueAuthor->text());
                         emit inspector->catalogueUpdated(m_DisplayedCatalogue);
                     }
                 });
             }
             void CatalogueInspectorWidget::CatalogueInspectorWidgetPrivate::connectEventUpdateSignals(
                 CatalogueInspectorWidget *inspector, Ui::CatalogueInspectorWidget *ui)
             {
                 connect(ui->leEventName, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     if (ui->leEventName->text() != m_DisplayedEvent->getName()) {
                         m_DisplayedEvent->setName(ui->leEventName->text());
                         emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
                 connect(ui->leEventMission, &QLineEdit::editingFinished, [ui, inspector, this]() {
-                    if (ui->leEventMission->text() != m_DisplayedEvent->getMission()) {
+                    //        if (ui->leEventMission->text() != m_DisplayedEvent->getMission()) {
-                        m_DisplayedEvent->setMission(ui->leEventMission->text());
+                    //            m_DisplayedEvent->setMission(ui->leEventMission->text());
-                        emit inspector->eventUpdated(m_DisplayedEvent);
+                    //            emit inspector->eventUpdated(m_DisplayedEvent);
+                    //        }
                 });
                 connect(ui->leEventProduct, &QLineEdit::editingFinished, [ui, inspector, this]() {
-                    if (ui->leEventProduct->text() != m_DisplayedEvent->getProduct()) {
+                    //        if (ui->leEventProduct->text() != m_DisplayedEvent->getProduct()) {
-                        m_DisplayedEvent->setProduct(ui->leEventProduct->text());
+                    //            m_DisplayedEvent->setProduct(ui->leEventProduct->text());
-                        emit inspector->eventUpdated(m_DisplayedEvent);
+                    //            emit inspector->eventUpdated(m_DisplayedEvent);
+                    //        }
                 });
                 connect(ui->leEventTags, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     // TODO
                 });
                 connect(ui->dateTimeEventTStart, &QDateTimeEdit::editingFinished, [ui, inspector, this]() {
-                    auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTStart->dateTime());
+                    //        auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTStart->dateTime());
-                    if (time != m_DisplayedEvent->getTStart()) {
+                    //        if (time != m_DisplayedEvent->getTStart()) {
-                        m_DisplayedEvent->setTStart(time);
+                    //            m_DisplayedEvent->setTStart(time);
-                        emit inspector->eventUpdated(m_DisplayedEvent);
+                    //            emit inspector->eventUpdated(m_DisplayedEvent);
+                    //        }
                 });
                 connect(ui->dateTimeEventTEnd, &QDateTimeEdit::editingFinished, [ui, inspector, this]() {
-                    auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTEnd->dateTime());
+                    //        auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTEnd->dateTime());
-                    if (time != m_DisplayedEvent->getTEnd()) {
+                    //        if (time != m_DisplayedEvent->getTEnd()) {
-                        m_DisplayedEvent->setTEnd(time);
+                    //            m_DisplayedEvent->setTEnd(time);
-                        emit inspector->eventUpdated(m_DisplayedEvent);
+                    //            emit inspector->eventUpdated(m_DisplayedEvent);
+                    //        }
                 });
             }
             void CatalogueInspectorWidget::showPage(CatalogueInspectorWidget::Page page)
             {
                 ui->stackedWidget->setCurrentIndex(static_cast<int>(page));
             }
             CatalogueInspectorWidget::Page CatalogueInspectorWidget::currentPage() const
             {
                 return static_cast<Page>(ui->stackedWidget->currentIndex());
             }
             void CatalogueInspectorWidget::setEvent(const std::shared_ptr<DBEvent> &event)
             {
                 impl->m_DisplayedEvent = event;
                 blockSignals(true);
                 showPage(Page::EventProperties);
                 ui->leEventName->setText(event->getName());
-                ui->leEventMission->setText(event->getMission());
+                //    ui->leEventMission->setText(event->getMission());
-                ui->leEventProduct->setText(event->getProduct());
+                //    ui->leEventProduct->setText(event->getProduct());
                 QString tagList;
                 auto tags = event->getTags();
                 for (auto tag : tags) {
                     tagList += tag.getName();
                     tagList += ' ';
                 }
                 ui->leEventTags->setText(tagList);
-                ui->dateTimeEventTStart->setDateTime(DateUtils::dateTime(event->getTStart()));
+                //    ui->dateTimeEventTStart->setDateTime(DateUtils::dateTime(event->getTStart()));
-                ui->dateTimeEventTEnd->setDateTime(DateUtils::dateTime(event->getTEnd()));
+                //    ui->dateTimeEventTEnd->setDateTime(DateUtils::dateTime(event->getTEnd()));
                 blockSignals(false);
             }
             void CatalogueInspectorWidget::setCatalogue(const std::shared_ptr<DBCatalogue> &catalogue)
             {
                 impl->m_DisplayedCatalogue = catalogue;
                 blockSignals(true);
                 showPage(Page::CatalogueProperties);
                 ui->leCatalogueName->setText(catalogue->getName());
                 ui->leCatalogueAuthor->setText(catalogue->getAuthor());
                 blockSignals(false);
             }

gui/ui/Catalogue/CatalogueEventsWidget.ui +2 -17

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

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