GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1176:20294bb49a24

Adaptation to the shared pointers of catalogue controller

trabillard -

r1176:20294bb49a24

parent child

Context file:

r1176:20294bb49a24

core/include/Catalogue/CatalogueController.h +1 -2

             #ifndef SCIQLOP_CATALOGUECONTROLLER_H
             #define SCIQLOP_CATALOGUECONTROLLER_H
             #include "CoreGlobal.h"
             #include <Data/SqpRange.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             #include <memory>
             class DBCatalogue;
             class DBEvent;
             Q_DECLARE_LOGGING_CATEGORY(LOG_CatalogueController)
             class DataSourceItem;
             class Variable;
             /**
              * @brief The CatalogueController class aims to handle catalogues and event using the CatalogueAPI
              * library.
              */
             class SCIQLOP_CORE_EXPORT CatalogueController : public QObject {
                 Q_OBJECT
             public:
                 explicit CatalogueController(QObject *parent = 0);
                 virtual ~CatalogueController();
                 // DB
                 //    QStringList getRepositories() const;
                 void addDB(const QString &dbPath);
                 void saveDB(const QString &destinationPath, const QString &repository);
                 // Event
                 //    bool createEvent(const QString &name);
                 std::list<std::shared_ptr<DBEvent> > retrieveEvents(const QString &repository) const;
                 std::list<std::shared_ptr<DBEvent> > retrieveAllEvents() const;
                 std::list<std::shared_ptr<DBEvent> >
-                retrieveEventsFromCatalogue(const QString &repository,
+                retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const;
-                                            std::shared_ptr<DBCatalogue> catalogue) const;
                 //    void updateEvent(std::shared_ptr<DBEvent> event);
                 //    void trashEvent(std::shared_ptr<DBEvent> event);
                 //    void removeEvent(std::shared_ptr<DBEvent> event);
                 //    void restore(QUuid eventId);
                 //    void saveEvent(std::shared_ptr<DBEvent> event);
                 // Catalogue
                 //    bool createCatalogue(const QString &name, QVector<QUuid> eventList);
                 std::list<std::shared_ptr<DBCatalogue> > getCatalogues(const QString &repository) const;
                 //    void removeEvent(QUuid catalogueId, const QString &repository);
                 //    void saveCatalogue(std::shared_ptr<DBEvent> event);
             public slots:
                 /// Manage init/end of the controller
                 void initialize();
                 void finalize();
             private:
                 void waitForFinish();
                 class CatalogueControllerPrivate;
                 spimpl::unique_impl_ptr<CatalogueControllerPrivate> impl;
             };
             #endif // SCIQLOP_CATALOGUECONTROLLER_H

core/src/Catalogue/CatalogueController.cpp +1 -2

             #include <Catalogue/CatalogueController.h>
             #include <Variable/Variable.h>
             #include <CatalogueDao.h>
             #include <ComparaisonPredicate.h>
             #include <CompoundPredicate.h>
             #include <DBCatalogue.h>
             #include <DBEvent.h>
             #include <DBTag.h>
             #include <IRequestPredicate.h>
             #include <QMutex>
             #include <QThread>
             #include <QDir>
             #include <QStandardPaths>
             Q_LOGGING_CATEGORY(LOG_CatalogueController, "CatalogueController")
             namespace {
             static QString REPOSITORY_WORK_SUFFIX = QString{"Work"};
             }
             class CatalogueController::CatalogueControllerPrivate {
             public:
                 QMutex m_WorkingMutex;
                 CatalogueDao m_CatalogueDao;
                 std::list<QString> m_RepositoryList;
             };
             CatalogueController::CatalogueController(QObject *parent)
                     : impl{spimpl::make_unique_impl<CatalogueControllerPrivate>()}
             {
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController construction")
                                                    << QThread::currentThread();
             }
             CatalogueController::~CatalogueController()
             {
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController destruction")
                                                    << QThread::currentThread();
                 this->waitForFinish();
             }
             void CatalogueController::addDB(const QString &dbPath)
             {
                 QDir dbDir(dbPath);
                 if (dbDir.exists()) {
                     auto dirName = dbDir.dirName();
                     if (std::find(impl->m_RepositoryList.cbegin(), impl->m_RepositoryList.cend(), dirName)
                         != impl->m_RepositoryList.cend()) {
                         qCCritical(LOG_CatalogueController())
                             << tr("Impossible to addDB that is already loaded");
                     }
                     if (!impl->m_CatalogueDao.addDB(dbPath, dirName)) {
                         qCCritical(LOG_CatalogueController())
                             << tr("Impossible to addDB %1 from %2 ").arg(dirName, dbPath);
                     }
                     else {
                         impl->m_RepositoryList.push_back(dirName);
                     }
                 }
                 else {
                     qCCritical(LOG_CatalogueController()) << tr("Impossible to addDB that not exists: ")
                                                           << dbPath;
                 }
             }
             void CatalogueController::saveDB(const QString &destinationPath, const QString &repository)
             {
                 if (!impl->m_CatalogueDao.saveDB(destinationPath, repository)) {
                     qCCritical(LOG_CatalogueController())
                         << tr("Impossible to saveDB %1 from %2 ").arg(repository, destinationPath);
                 }
             }
             std::list<std::shared_ptr<DBEvent> >
             CatalogueController::retrieveEvents(const QString &repository) const
             {
                 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
                 auto events = impl->m_CatalogueDao.getEvents(repository);
                 for (auto event : events) {
                     eventsShared.push_back(std::make_shared<DBEvent>(event));
                 }
                 return eventsShared;
             }
             std::list<std::shared_ptr<DBEvent> > CatalogueController::retrieveAllEvents() const
             {
                 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
                 for (auto repository : impl->m_RepositoryList) {
                     eventsShared.splice(eventsShared.end(), retrieveEvents(repository));
                 }
                 return eventsShared;
             }
             std::list<std::shared_ptr<DBEvent> >
-            CatalogueController::retrieveEventsFromCatalogue(const QString &repository,
+            CatalogueController::retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const
-                                                             std::shared_ptr<DBCatalogue> catalogue) const
             {
                 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
                 auto events = impl->m_CatalogueDao.getCatalogueEvents(*catalogue);
                 for (auto event : events) {
                     eventsShared.push_back(std::make_shared<DBEvent>(event));
                 }
                 return eventsShared;
             }
             std::list<std::shared_ptr<DBCatalogue> >
             CatalogueController::getCatalogues(const QString &repository) const
             {
                 auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};
                 auto catalogues = impl->m_CatalogueDao.getCatalogues(repository);
                 for (auto catalogue : catalogues) {
                     cataloguesShared.push_back(std::make_shared<DBCatalogue>(catalogue));
                 }
                 return cataloguesShared;
             }
             void CatalogueController::initialize()
             {
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController init")
                                                    << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 impl->m_CatalogueDao.initialize();
                 auto defaultRepositoryLocation
                     = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
                 QDir defaultRepositoryLocationDir;
                 if (defaultRepositoryLocationDir.mkpath(defaultRepositoryLocation)) {
                     defaultRepositoryLocationDir.cd(defaultRepositoryLocation);
                     auto defaultRepository = defaultRepositoryLocationDir.absoluteFilePath(REPOSITORY_DEFAULT);
                     qCInfo(LOG_CatalogueController())
                         << tr("Persistant data loading from: ") << defaultRepository;
                     this->addDB(defaultRepository);
                 }
                 else {
                     qCWarning(LOG_CatalogueController())
                         << tr("Cannot load the persistent default repository from ")
                         << defaultRepositoryLocation;
                 }
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController init END");
             }
             void CatalogueController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void CatalogueController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

gui/include/Catalogue/CatalogueEventsTableModel.h +5 -5

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

             #ifndef SCIQLOP_CATALOGUEEVENTSWIDGET_H
             #define SCIQLOP_CATALOGUEEVENTSWIDGET_H
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             #include <QWidget>
             class DBCatalogue;
             class DBEvent;
             class VisualizationWidget;
             namespace Ui {
             class CatalogueEventsWidget;
             }
             Q_DECLARE_LOGGING_CATEGORY(LOG_CatalogueEventsWidget)
             class CatalogueEventsWidget : public QWidget {
                 Q_OBJECT
             signals:
-                void eventsSelected(const QVector<DBEvent> &event);
+                void eventsSelected(const QVector<std::shared_ptr<DBEvent> > &event);
             public:
                 explicit CatalogueEventsWidget(QWidget *parent = 0);
                 virtual ~CatalogueEventsWidget();
                 void setVisualizationWidget(VisualizationWidget *visualization);
             public slots:
-                void populateWithCatalogues(const QVector<DBCatalogue> &catalogues);
+                void populateWithCatalogues(const QVector<std::shared_ptr<DBCatalogue> > &catalogues);
             private:
                 Ui::CatalogueEventsWidget *ui;
                 class CatalogueEventsWidgetPrivate;
                 spimpl::unique_impl_ptr<CatalogueEventsWidgetPrivate> impl;
             };
             #endif // SCIQLOP_CATALOGUEEVENTSWIDGET_H

gui/include/Catalogue/CatalogueInspectorWidget.h +3 -2

             #ifndef SCIQLOP_CATALOGUEINSPECTORWIDGET_H
             #define SCIQLOP_CATALOGUEINSPECTORWIDGET_H
             #include <QWidget>
+            #include <memory>
             namespace Ui {
             class CatalogueInspectorWidget;
             }
             class DBCatalogue;
             class DBEvent;
             class CatalogueInspectorWidget : public QWidget {
                 Q_OBJECT
             public:
                 explicit CatalogueInspectorWidget(QWidget *parent = 0);
                 virtual ~CatalogueInspectorWidget();
                 /// Enum matching the pages inside the stacked widget
                 enum class Page { Empty, CatalogueProperties, EventProperties };
                 Page currentPage() const;
-                void setEvent(const DBEvent &event);
+                void setEvent(const std::shared_ptr<DBEvent> &event);
-                void setCatalogue(const DBCatalogue &catalogue);
+                void setCatalogue(const std::shared_ptr<DBCatalogue> &catalogue);
             public slots:
                 void showPage(Page page);
             private:
                 Ui::CatalogueInspectorWidget *ui;
             };
             #endif // SCIQLOP_CATALOGUEINSPECTORWIDGET_H

gui/include/Catalogue/CatalogueSideBarWidget.h +2 -2

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

gui/include/Catalogue/CatalogueTreeWidgetItem.h +4 -3

             #ifndef SCIQLOP_CATALOGUETREEWIDGETITEM_H
             #define SCIQLOP_CATALOGUETREEWIDGETITEM_H
             #include <Common/spimpl.h>
             #include <QTreeWidgetItem>
-            #include <DBCatalogue.h>
+            class DBCatalogue;
             class CatalogueTreeWidgetItem : public QTreeWidgetItem {
             public:
-                CatalogueTreeWidgetItem(DBCatalogue catalogue, int type = QTreeWidgetItem::Type);
+                CatalogueTreeWidgetItem(std::shared_ptr<DBCatalogue> catalogue,
+                                        int type = QTreeWidgetItem::Type);
                 QVariant data(int column, int role) const override;
                 void setData(int column, int role, const QVariant &value) override;
                 /// Returns the catalogue represented by the item
-                DBCatalogue catalogue() const;
+                std::shared_ptr<DBCatalogue> catalogue() const;
                 void setHasChanges(bool value);
             private:
                 class CatalogueTreeWidgetItemPrivate;
                 spimpl::unique_impl_ptr<CatalogueTreeWidgetItemPrivate> impl;
             };
             #endif // SCIQLOP_CATALOGUETREEWIDGETITEM_H

gui/src/Catalogue/CatalogueEventsTableModel.cpp +14 -14

             #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;
+                QVector<std::shared_ptr<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
+                QVariant eventData(int col, const std::shared_ptr<DBEvent> &event) const
                 {
                     switch (static_cast<Column>(col)) {
                         case Column::Event:
-                            return event.getName();
+                            return event->getName();
                         case Column::TStart:
-                            return DateUtils::dateTime(event.getTStart());
+                            return DateUtils::dateTime(event->getTStart());
                         case Column::TEnd:
-                            return DateUtils::dateTime(event.getTEnd());
+                            return DateUtils::dateTime(event->getTEnd());
                         case Column::Product:
-                            return event.getProduct();
+                            return event->getProduct();
                         case Column::Tags: {
                             QString tagList;
-                            auto tags = const_cast<DBEvent *>(&event)->getTags();
+                            auto tags = 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)
+            void CatalogueEventsTableModel::setEvents(const QVector<std::shared_ptr<DBEvent> > &events)
             {
                 beginResetModel();
                 impl->m_Events = events;
                 endResetModel();
             }
-            DBEvent CatalogueEventsTableModel::getEvent(int row) const
+            std::shared_ptr<DBEvent> CatalogueEventsTableModel::getEvent(int row) const
             {
                 return impl->m_Events.value(row);
             }
-            void CatalogueEventsTableModel::addEvent(const DBEvent &events)
+            void CatalogueEventsTableModel::addEvent(const std::shared_ptr<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)
+            void CatalogueEventsTableModel::removeEvent(const std::shared_ptr<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;
+                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 +12 -13

             #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>
             #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;
                 QStringList m_ZonesForTimeMode;
                 QString m_ZoneForGraphMode;
                 VisualizationWidget *m_VisualizationWidget = nullptr;
-                void setEvents(const QVector<DBEvent> &events, QTableView *tableView)
+                void setEvents(const QVector<std::shared_ptr<DBEvent> > &events, QTableView *tableView)
                 {
                     tableView->setSortingEnabled(false);
                     m_Model->setEvents(events);
                     tableView->setSortingEnabled(true);
                 }
-                void addEvent(const DBEvent &event, QTableView *tableView)
+                void addEvent(const std::shared_ptr<DBEvent> &event, QTableView *tableView)
                 {
                     tableView->setSortingEnabled(false);
                     m_Model->addEvent(event);
                     tableView->setSortingEnabled(true);
                 }
-                void removeEvent(const DBEvent &event, QTableView *tableView)
+                void removeEvent(const std::shared_ptr<DBEvent> &event, QTableView *tableView)
                 {
                     tableView->setSortingEnabled(false);
                     m_Model->removeEvent(event);
                     tableView->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)
                 {
                     auto selectedRows = tableView->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)
                 {
                     auto selectedRows = tableView->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};
                 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);
                         impl->m_ZonesForTimeMode
                             = impl->selectZone(this, impl->m_ZonesForTimeMode, true,
                                                this->mapToGlobal(ui->btnTime->frameGeometry().center()));
                         impl->updateForTimeMode(ui->tableView);
                     }
                 });
                 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);
                     }
                 });
                 auto emitSelection = [this]() {
-                    QVector<DBEvent> events;
+                    QVector<std::shared_ptr<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);
                     if (isNotMultiSelection && ui->btnTime->isChecked()) {
                         impl->updateForTimeMode(ui->tableView);
                     }
                     else if (isNotMultiSelection && ui->btnChart->isChecked()) {
                         impl->updateForGraphMode(ui->tableView);
                     }
                 });
                 ui->tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
                 ui->tableView->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
                 ui->tableView->horizontalHeader()->setSortIndicatorShown(true);
             }
             CatalogueEventsWidget::~CatalogueEventsWidget()
             {
                 delete ui;
             }
             void CatalogueEventsWidget::setVisualizationWidget(VisualizationWidget *visualization)
             {
                 impl->m_VisualizationWidget = visualization;
             }
-            void CatalogueEventsWidget::populateWithCatalogues(const QVector<DBCatalogue> &catalogues)
+            void CatalogueEventsWidget::populateWithCatalogues(
+                const QVector<std::shared_ptr<DBCatalogue> > &catalogues)
             {
-                auto &dao = sqpApp->catalogueController().getDao();
                 QSet<QUuid> eventIds;
-                QVector<DBEvent> events;
+                QVector<std::shared_ptr<DBEvent> > events;
                 for (auto catalogue : catalogues) {
-                    auto catalogueEvents = dao.getCatalogueEvents(catalogue);
+                    auto catalogueEvents = sqpApp->catalogueController().retrieveEventsFromCatalogue(catalogue);
                     for (auto event : catalogueEvents) {
-                        if (!eventIds.contains(event.getUniqId())) {
+                        if (!eventIds.contains(event->getUniqId())) {
                             events << event;
-                            eventIds.insert(event.getUniqId());
+                            eventIds.insert(event->getUniqId());
                         }
                     }
                 }
                 impl->setEvents(events, ui->tableView);
             }

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

             #include "Catalogue/CatalogueInspectorWidget.h"
             #include "ui_CatalogueInspectorWidget.h"
             #include <Common/DateUtils.h>
             #include <DBCatalogue.h>
             #include <DBEvent.h>
             #include <DBTag.h>
             CatalogueInspectorWidget::CatalogueInspectorWidget(QWidget *parent)
                     : QWidget(parent), ui(new Ui::CatalogueInspectorWidget)
             {
                 ui->setupUi(this);
                 showPage(Page::Empty);
             }
             CatalogueInspectorWidget::~CatalogueInspectorWidget()
             {
                 delete ui;
             }
             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 DBEvent &event)
+            void CatalogueInspectorWidget::setEvent(const std::shared_ptr<DBEvent> &event)
             {
                 showPage(Page::EventProperties);
-                ui->leEventName->setText(event.getName());
+                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 = const_cast<DBEvent *>(&event)->getTags();
+                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()));
             }
-            void CatalogueInspectorWidget::setCatalogue(const DBCatalogue &catalogue)
+            void CatalogueInspectorWidget::setCatalogue(const std::shared_ptr<DBCatalogue> &catalogue)
             {
                 showPage(Page::CatalogueProperties);
-                ui->leCatalogueName->setText(catalogue.getName());
+                ui->leCatalogueName->setText(catalogue->getName());
-                ui->leCatalogueAuthor->setText(catalogue.getAuthor());
+                ui->leCatalogueAuthor->setText(catalogue->getAuthor());
             }

gui/src/Catalogue/CatalogueSideBarWidget.cpp +5 -10

             #include "Catalogue/CatalogueSideBarWidget.h"
             #include "ui_CatalogueSideBarWidget.h"
             #include <SqpApplication.h>
             #include <Catalogue/CatalogueController.h>
             #include <Catalogue/CatalogueTreeWidgetItem.h>
             #include <CatalogueDao.h>
             #include <ComparaisonPredicate.h>
             #include <DBCatalogue.h>
             #include <QMenu>
             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);
+                void addCatalogueItem(const std::shared_ptr<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);
                 ui->treeWidget->setColumnCount(2);
                 ui->treeWidget->header()->setStretchLastSection(false);
                 ui->treeWidget->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
                 ui->treeWidget->header()->setSectionResizeMode(0, QHeaderView::Stretch);
                 auto emitSelection = [this]() {
                     auto selectedItems = ui->treeWidget->selectedItems();
                     if (selectedItems.isEmpty()) {
                         emit this->selectionCleared();
                     }
                     else {
-                        QVector<DBCatalogue> catalogues;
+                        QVector<std::shared_ptr<DBCatalogue> > catalogues;
                         QStringList databases;
                         int selectionType = selectedItems.first()->type();
                         for (auto item : ui->treeWidget->selectedItems()) {
                             if (item->type() == selectionType) {
                                 switch (selectionType) {
                                     case CATALOGUE_ITEM_TYPE:
                                         catalogues.append(
                                             static_cast<CatalogueTreeWidgetItem *>(item)->catalogue());
                                         break;
                                     case DATABASE_ITEM_TYPE:
                                         selectionType = DATABASE_ITEM_TYPE;
                                         databases.append(item->text(0));
                                     case ALL_EVENT_ITEM_TYPE: // fallthrough
                                     case TRASH_ITEM_TYPE:     // fallthrough
                                     default:
                                         break;
                                 }
                             }
                             else {
                                 // Incoherent multi selection
                                 selectionType = -1;
                                 break;
                             }
                         }
                         switch (selectionType) {
                             case CATALOGUE_ITEM_TYPE:
                                 emit this->catalogueSelected(catalogues);
                                 break;
                             case DATABASE_ITEM_TYPE:
                                 emit this->databaseSelected(databases);
                                 break;
                             case ALL_EVENT_ITEM_TYPE:
                                 emit this->allEventsSelected();
                                 break;
                             case TRASH_ITEM_TYPE:
                                 emit this->trashSelected();
                                 break;
                             default:
                                 emit this->selectionCleared();
                                 break;
                         }
                     }
                 };
                 connect(ui->treeWidget, &QTreeWidget::itemClicked, emitSelection);
                 connect(ui->treeWidget, &QTreeWidget::currentItemChanged, emitSelection);
                 ui->treeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->treeWidget, &QTreeWidget::customContextMenuRequested, this,
                         &CatalogueSideBarWidget::onContextMenuRequested);
             }
             CatalogueSideBarWidget::~CatalogueSideBarWidget()
             {
                 delete ui;
             }
             void CatalogueSideBarWidget::onContextMenuRequested(const QPoint &pos)
             {
                 QMenu menu{this};
                 auto currentItem = ui->treeWidget->currentItem();
                 switch (currentItem->type()) {
                     case CATALOGUE_ITEM_TYPE:
                         menu.addAction("Rename",
                                        [this, currentItem]() { ui->treeWidget->editItem(currentItem); });
                         break;
                     case DATABASE_ITEM_TYPE:
                         break;
                     case ALL_EVENT_ITEM_TYPE:
                         break;
                     case TRASH_ITEM_TYPE:
                         menu.addAction("Empty Trash", []() {
                             // TODO
                         });
                         break;
                     default:
                         break;
                 }
                 if (!menu.isEmpty()) {
                     menu.exec(ui->treeWidget->mapToGlobal(pos));
                 }
             }
             void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::configureTreeWidget(
                 QTreeWidget *treeWidget)
             {
                 auto allEventsItem = new QTreeWidgetItem{{"All Events"}, ALL_EVENT_ITEM_TYPE};
                 allEventsItem->setIcon(0, QIcon(":/icones/allEvents.png"));
                 treeWidget->addTopLevelItem(allEventsItem);
                 auto trashItem = new QTreeWidgetItem{{"Trash"}, TRASH_ITEM_TYPE};
                 trashItem->setIcon(0, QIcon(":/icones/trash.png"));
                 treeWidget->addTopLevelItem(trashItem);
                 auto separator = new QFrame{treeWidget};
                 separator->setFrameShape(QFrame::HLine);
                 auto separatorItem = new QTreeWidgetItem{};
                 separatorItem->setFlags(Qt::NoItemFlags);
                 treeWidget->addTopLevelItem(separatorItem);
                 treeWidget->setItemWidget(separatorItem, 0, separator);
-                auto &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);
+                auto catalogues = sqpApp->catalogueController().getCatalogues("Default");
                 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)
+                const std::shared_ptr<DBCatalogue> &catalogue, QTreeWidgetItem *parentDatabaseItem)
             {
                 auto catalogueItem = new CatalogueTreeWidgetItem{catalogue, CATALOGUE_ITEM_TYPE};
                 catalogueItem->setIcon(0, QIcon{":/icones/catalogue.png"});
                 parentDatabaseItem->addChild(catalogueItem);
             }

gui/src/Catalogue/CatalogueTreeWidgetItem.cpp +10 -7

             #include "Catalogue/CatalogueTreeWidgetItem.h"
             #include <memory>
+            #include <DBCatalogue.h>
             #include <QBoxLayout>
             #include <QToolButton>
             const auto VALIDATION_BUTTON_ICON_SIZE = 12;
             struct CatalogueTreeWidgetItem::CatalogueTreeWidgetItemPrivate {
-                DBCatalogue m_Catalogue;
+                std::shared_ptr<DBCatalogue> m_Catalogue;
-                CatalogueTreeWidgetItemPrivate(DBCatalogue catalogue) : m_Catalogue(catalogue) {}
+                CatalogueTreeWidgetItemPrivate(std::shared_ptr<DBCatalogue> catalogue) : m_Catalogue(catalogue)
+                {
+                }
             };
-            CatalogueTreeWidgetItem::CatalogueTreeWidgetItem(DBCatalogue catalogue, int type)
+            CatalogueTreeWidgetItem::CatalogueTreeWidgetItem(std::shared_ptr<DBCatalogue> catalogue, int type)
                     : QTreeWidgetItem(type),
                       impl{spimpl::make_unique_impl<CatalogueTreeWidgetItemPrivate>(catalogue)}
             {
                 setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable);
             }
             QVariant CatalogueTreeWidgetItem::data(int column, int role) const
             {
                 if (column == 0) {
                     switch (role) {
                         case Qt::EditRole: // fallthrough
                         case Qt::DisplayRole:
-                            return impl->m_Catalogue.getName();
+                            return impl->m_Catalogue->getName();
                         default:
                             break;
                     }
                 }
                 return QTreeWidgetItem::data(column, role);
             }
             void CatalogueTreeWidgetItem::setData(int column, int role, const QVariant &value)
             {
                 if (role == Qt::EditRole && column == 0) {
                     auto newName = value.toString();
-                    if (newName != impl->m_Catalogue.getName()) {
+                    if (newName != impl->m_Catalogue->getName()) {
                         setText(0, newName);
-                        impl->m_Catalogue.setName(newName);
+                        impl->m_Catalogue->setName(newName);
                         setHasChanges(true);
                     }
                 }
                 else {
                     QTreeWidgetItem::setData(column, role, value);
                 }
             }
-            DBCatalogue CatalogueTreeWidgetItem::catalogue() const
+            std::shared_ptr<DBCatalogue> CatalogueTreeWidgetItem::catalogue() const
             {
                 return impl->m_Catalogue;
             }
             void CatalogueTreeWidgetItem::setHasChanges(bool value)
             {
                 if (value) {
                     auto widet = new QWidget{treeWidget()};
                     auto layout = new QHBoxLayout{widet};
                     layout->setContentsMargins(0, 0, 0, 0);
                     layout->setSpacing(0);
                     auto btnValid = new QToolButton{widet};
                     btnValid->setIcon(QIcon{":/icones/save"});
                     btnValid->setIconSize(QSize{VALIDATION_BUTTON_ICON_SIZE, VALIDATION_BUTTON_ICON_SIZE});
                     btnValid->setAutoRaise(true);
                     QObject::connect(btnValid, &QToolButton::clicked, [this]() { setHasChanges(false); });
                     layout->addWidget(btnValid);
                     auto btnDiscard = new QToolButton{widet};
                     btnDiscard->setIcon(QIcon{":/icones/discard"});
                     btnDiscard->setIconSize(QSize{VALIDATION_BUTTON_ICON_SIZE, VALIDATION_BUTTON_ICON_SIZE});
                     btnDiscard->setAutoRaise(true);
                     QObject::connect(btnDiscard, &QToolButton::clicked, [this]() { setHasChanges(false); });
                     layout->addWidget(btnDiscard);
                     treeWidget()->setItemWidget(this, 1, {widet});
                     treeWidget()->resizeColumnToContents(1);
                 }
                 else {
                     // Note: the widget is destroyed
                     treeWidget()->setItemWidget(this, 1, nullptr);
                 }
             }

General Comments 3

trabillard

|

Auto status change to "Under Review"

perrinel

|

Status change > Approved

Write
Preview

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

	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