HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1134:9ee6cd254cb4

Methods to facilitate add/remove operations

trabillard -

r1134:9ee6cd254cb4

parent child

Context file:

r1134:9ee6cd254cb4

gui/include/Catalogue/CatalogueEventsTableModel.h +2 0

             #ifndef SCIQLOP_CATALOGUEEVENTSTABLEMODEL_H
             #define SCIQLOP_CATALOGUEEVENTSTABLEMODEL_H
             #include <Common/spimpl.h>
             #include <QAbstractTableModel>
             #include <DBEvent.h>
             class CatalogueEventsTableModel : public QAbstractTableModel {
             public:
                 CatalogueEventsTableModel(QObject *parent = nullptr);
                 void setEvents(const QVector<DBEvent> &events);
                 DBEvent getEvent(int row) const;
+                void addEvent(const DBEvent &events);
+                void removeEvent(const DBEvent &events);
                 // Model
                 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

gui/src/Catalogue/CatalogueEventsTableModel.cpp +18 0

             #include "Catalogue/CatalogueEventsTableModel.h"
             #include <Common/DateUtils.h>
             #include <Common/MimeTypesDef.h>
             #include <DBEvent.h>
             #include <DBTag.h>
             #include <Data/SqpRange.h>
             #include <QMimeData>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             struct CatalogueEventsTableModel::CatalogueEventsTableModelPrivate {
                 QVector<DBEvent> m_Events;
                 enum class Column { Event, TStart, TEnd, Tags, Product, NbColumn };
                 QStringList columnNames()
                 {
                     return QStringList{tr("Event"), tr("TStart"), tr("TEnd"), tr("Tags"), tr("Product")};
                 }
                 QVariant eventData(int col, const DBEvent &event) const
                 {
                     switch (static_cast<Column>(col)) {
                         case Column::Event:
                             return event.getName();
                         case Column::TStart:
                             return DateUtils::dateTime(event.getTStart());
                         case Column::TEnd:
                             return DateUtils::dateTime(event.getTEnd());
                         case Column::Product:
                             return event.getProduct();
                         case Column::Tags: {
                             QString tagList;
                             auto tags = const_cast<DBEvent *>(&event)->getTags();
                             for (auto tag : tags) {
                                 tagList += tag.getName();
                                 tagList += ' ';
                             }
                             return tagList;
                         }
                         default:
                             break;
                     }
                     Q_ASSERT(false);
                     return QStringLiteral("Unknown Data");
                 }
             };
             CatalogueEventsTableModel::CatalogueEventsTableModel(QObject *parent)
                     : QAbstractTableModel(parent),
                       impl{spimpl::make_unique_impl<CatalogueEventsTableModelPrivate>()}
             {
             }
             void CatalogueEventsTableModel::setEvents(const QVector<DBEvent> &events)
             {
                 beginResetModel();
                 impl->m_Events = events;
                 endResetModel();
             }
             DBEvent CatalogueEventsTableModel::getEvent(int row) const
             {
                 return impl->m_Events.value(row);
             }
+            void CatalogueEventsTableModel::addEvent(const DBEvent &events)
+            {
+                beginInsertRows(QModelIndex(), impl->m_Events.count() - 1, impl->m_Events.count() - 1);
+                // impl->m_Events.append(event); TODO
+                endInsertRows();
+            }
+            void CatalogueEventsTableModel::removeEvent(const DBEvent &events)
+            {
+                // TODO
+                auto index = -1; // impl->m_Events.indexOf(event);
+                if (index >= 0) {
+                    beginRemoveRows(QModelIndex(), index, index);
+                    impl->m_Events.removeAt(index);
+                    endRemoveRows();
+                }
+            }
             int CatalogueEventsTableModel::rowCount(const QModelIndex &parent) const
             {
                 int r = impl->m_Events.count();
                 return r;
             }
             int CatalogueEventsTableModel::columnCount(const QModelIndex &parent) const
             {
                 int c = static_cast<int>(CatalogueEventsTableModelPrivate::Column::NbColumn);
                 return c;
             }
             Qt::ItemFlags CatalogueEventsTableModel::flags(const QModelIndex &index) const
             {
                 return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
             }
             QVariant CatalogueEventsTableModel::data(const QModelIndex &index, int role) const
             {
                 if (index.isValid()) {
                     auto event = getEvent(index.row());
                     switch (role) {
                         case Qt::DisplayRole:
                             return impl->eventData(index.column(), event);
                             break;
                     }
                 }
                 return QVariant{};
             }
             QVariant CatalogueEventsTableModel::headerData(int section, Qt::Orientation orientation,
                                                            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)
             {
                 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
             {
                 return Qt::CopyAction | Qt::MoveAction;
             }
             QStringList CatalogueEventsTableModel::mimeTypes() const
             {
                 return {MIME_TYPE_EVENT_LIST, MIME_TYPE_TIME_RANGE};
             }
             QMimeData *CatalogueEventsTableModel::mimeData(const QModelIndexList &indexes) const
             {
                 auto mimeData = new QMimeData;
                 QVector<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_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 +24 -6

             #include "Catalogue/CatalogueEventsWidget.h"
             #include "ui_CatalogueEventsWidget.h"
             #include <Catalogue/CatalogueController.h>
             #include <Catalogue/CatalogueEventsTableModel.h>
             #include <CatalogueDao.h>
             #include <DBCatalogue.h>
             #include <SqpApplication.h>
             /// 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;
+                void setEvents(const QVector<DBEvent> &events, QTableView *tableView)
+                {
+                    tableView->setSortingEnabled(false);
+                    m_Model->setEvents(events);
+                    tableView->setSortingEnabled(true);
+                }
+                void addEvent(const DBEvent &event, QTableView *tableView)
+                {
+                    tableView->setSortingEnabled(false);
+                    m_Model->addEvent(event);
+                    tableView->setSortingEnabled(true);
+                }
+                void removeEvent(const DBEvent &event, QTableView *tableView)
+                {
+                    tableView->setSortingEnabled(false);
+                    m_Model->removeEvent(event);
+                    tableView->setSortingEnabled(true);
+                }
             };
             CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
                     : QWidget(parent),
                       ui(new Ui::CatalogueEventsWidget),
                       impl{spimpl::make_unique_impl<CatalogueEventsWidgetPrivate>()}
             {
                 ui->setupUi(this);
-                ui->tableView->setDragDropMode(QAbstractItemView::DragDrop);
-                ui->tableView->setDragEnabled(true);
                 impl->m_Model = new CatalogueEventsTableModel{this};
                 ui->tableView->setModel(impl->m_Model);
                 ui->tableView->setSortingEnabled(true);
+                ui->tableView->setDragDropMode(QAbstractItemView::DragDrop);
+                ui->tableView->setDragEnabled(true);
                 connect(ui->btnTime, &QToolButton::clicked, [this](auto checked) {
                     if (checked) {
                         ui->btnChart->setChecked(false);
                     }
                 });
                 connect(ui->btnChart, &QToolButton::clicked, [this](auto checked) {
                     if (checked) {
                         ui->btnTime->setChecked(false);
                     }
                 });
                 auto emitSelection = [this]() {
                     QVector<DBEvent> events;
                     for (auto rowIndex : ui->tableView->selectionModel()->selectedRows()) {
                         events << impl->m_Model->getEvent(rowIndex.row());
                     }
                     emit this->eventsSelected(events);
                 };
                 connect(ui->tableView, &QTableView::clicked, emitSelection);
                 connect(ui->tableView->selectionModel(), &QItemSelectionModel::selectionChanged, emitSelection);
                 connect(ui->tableView->selectionModel(), &QItemSelectionModel::selectionChanged, [this]() {
                     auto isNotMultiSelection = ui->tableView->selectionModel()->selectedRows().count() <= 1;
                     ui->btnChart->setEnabled(isNotMultiSelection);
                     ui->btnTime->setEnabled(isNotMultiSelection);
                 });
                 ui->tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
                 ui->tableView->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
                 ui->tableView->horizontalHeader()->setSortIndicatorShown(true);
             }
             CatalogueEventsWidget::~CatalogueEventsWidget()
             {
                 delete ui;
             }
             void CatalogueEventsWidget::populateWithCatalogues(const QVector<DBCatalogue> &catalogues)
             {
                 auto &dao = sqpApp->catalogueController().getDao();
                 QSet<QUuid> eventIds;
                 QVector<DBEvent> events;
                 for (auto catalogue : catalogues) {
                     auto catalogueEvents = dao.getCatalogueEvents(catalogue);
                     for (auto event : catalogueEvents) {
                         if (!eventIds.contains(event.getUniqId())) {
                             events << event;
                             eventIds.insert(event.getUniqId());
                         }
                     }
                 }
-                ui->tableView->setSortingEnabled(false);
+                impl->setEvents(events, ui->tableView);
-                impl->m_Model->setEvents(events);
-                ui->tableView->setSortingEnabled(true);
             }

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

             #include "Catalogue/CatalogueSideBarWidget.h"
             #include "ui_CatalogueSideBarWidget.h"
             #include <SqpApplication.h>
             #include <Catalogue/CatalogueController.h>
             #include <Catalogue/CatalogueTreeWidgetItem.h>
             #include <CatalogueDao.h>
             #include <ComparaisonPredicate.h>
             #include <DBCatalogue.h>
             constexpr auto ALL_EVENT_ITEM_TYPE = QTreeWidgetItem::UserType;
             constexpr auto TRASH_ITEM_TYPE = QTreeWidgetItem::UserType + 1;
             constexpr auto CATALOGUE_ITEM_TYPE = QTreeWidgetItem::UserType + 2;
             constexpr auto DATABASE_ITEM_TYPE = QTreeWidgetItem::UserType + 3;
             struct CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate {
                 QHash<QTreeWidgetItem *, DBCatalogue> m_CatalogueMap;
                 void configureTreeWidget(QTreeWidget *treeWidget);
                 QTreeWidgetItem *addDatabaseItem(const QString &name, QTreeWidget *treeWidget);
+                QTreeWidgetItem *getDatabaseItem(const QString &name, QTreeWidget *treeWidget);
                 void addCatalogueItem(const DBCatalogue &catalogue, QTreeWidgetItem *parentDatabaseItem);
             };
             CatalogueSideBarWidget::CatalogueSideBarWidget(QWidget *parent)
                     : QWidget(parent),
                       ui(new Ui::CatalogueSideBarWidget),
                       impl{spimpl::make_unique_impl<CatalogueSideBarWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 impl->configureTreeWidget(ui->treeWidget);
                 auto emitSelection = [this]() {
                     auto selectedItems = ui->treeWidget->selectedItems();
                     if (selectedItems.isEmpty()) {
                         emit this->selectionCleared();
                     }
                     else {
                         QVector<DBCatalogue> catalogues;
                         QStringList databases;
                         int selectionType = selectedItems.first()->type();
                         for (auto item : ui->treeWidget->selectedItems()) {
                             if (item->type() == selectionType) {
                                 switch (selectionType) {
                                     case CATALOGUE_ITEM_TYPE:
                                         catalogues.append(
                                             static_cast<CatalogueTreeWidgetItem *>(item)->catalogue());
                                         break;
                                     case DATABASE_ITEM_TYPE:
                                         selectionType = DATABASE_ITEM_TYPE;
                                         databases.append(item->text(0));
                                     case ALL_EVENT_ITEM_TYPE: // fallthrough
                                     case TRASH_ITEM_TYPE:     // fallthrough
                                     default:
                                         break;
                                 }
                             }
                             else {
                                 // Incoherent multi selection
                                 selectionType = -1;
                                 break;
                             }
                         }
                         switch (selectionType) {
                             case CATALOGUE_ITEM_TYPE:
                                 emit this->catalogueSelected(catalogues);
                                 break;
                             case DATABASE_ITEM_TYPE:
                                 emit this->databaseSelected(databases);
                                 break;
                             case ALL_EVENT_ITEM_TYPE:
                                 emit this->allEventsSelected();
                                 break;
                             case TRASH_ITEM_TYPE:
                                 emit this->trashSelected();
                                 break;
                             default:
                                 emit this->selectionCleared();
                                 break;
                         }
                     }
                 };
                 connect(ui->treeWidget, &QTreeWidget::itemClicked, emitSelection);
                 connect(ui->treeWidget, &QTreeWidget::currentItemChanged, emitSelection);
             }
             CatalogueSideBarWidget::~CatalogueSideBarWidget()
             {
                 delete ui;
             }
             void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::configureTreeWidget(
                 QTreeWidget *treeWidget)
             {
                 auto allEventsItem = new QTreeWidgetItem{{"All Events"}, ALL_EVENT_ITEM_TYPE};
                 allEventsItem->setIcon(0, QIcon(":/icones/allEvents.png"));
                 treeWidget->addTopLevelItem(allEventsItem);
                 auto trashItem = new QTreeWidgetItem{{"Trash"}, TRASH_ITEM_TYPE};
                 trashItem->setIcon(0, QIcon(":/icones/trash.png"));
                 treeWidget->addTopLevelItem(trashItem);
                 auto separator = new QFrame{treeWidget};
                 separator->setFrameShape(QFrame::HLine);
                 auto separatorItem = new QTreeWidgetItem{};
                 separatorItem->setFlags(Qt::NoItemFlags);
                 treeWidget->addTopLevelItem(separatorItem);
                 treeWidget->setItemWidget(separatorItem, 0, separator);
                 // Test
                 auto &dao = sqpApp->catalogueController().getDao();
                 auto allPredicate = std::make_shared<ComparaisonPredicate>(QString{"uniqId"}, "-1",
                                                                            ComparaisonOperation::DIFFERENT);
                 auto db = addDatabaseItem("Default", treeWidget);
                 auto catalogues = dao.getCatalogues(allPredicate);
                 for (auto catalogue : catalogues) {
                     addCatalogueItem(catalogue, db);
                 }
                 treeWidget->expandAll();
             }
             QTreeWidgetItem *
             CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addDatabaseItem(const QString &name,
                                                                                    QTreeWidget *treeWidget)
             {
                 auto databaseItem = new QTreeWidgetItem{{name}, DATABASE_ITEM_TYPE};
                 databaseItem->setIcon(0, QIcon{":/icones/database.png"});
                 treeWidget->addTopLevelItem(databaseItem);
                 return databaseItem;
             }
+            QTreeWidgetItem *
+            CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getDatabaseItem(const QString &name,
+                                                                                   QTreeWidget *treeWidget)
+            {
+                for (auto i = 0; i < treeWidget->topLevelItemCount(); ++i) {
+                    auto item = treeWidget->topLevelItem(i);
+                    if (item->type() == DATABASE_ITEM_TYPE && item->text(0) == name) {
+                        return item;
+                    }
+                }
+                return nullptr;
+            }
             void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addCatalogueItem(
                 const DBCatalogue &catalogue, QTreeWidgetItem *parentDatabaseItem)
             {
                 auto catalogueItem = new CatalogueTreeWidgetItem{catalogue, CATALOGUE_ITEM_TYPE};
                 catalogueItem->setIcon(0, QIcon{":/icones/catalogue.png"});
                 parentDatabaseItem->addChild(catalogueItem);
             }

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