GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1293:7c4b1f434cd6

small gui improvements

trabillard -

r1293:7c4b1f434cd6

parent child

Context file:

r1293:7c4b1f434cd6

gui/src/Catalogue/CatalogueEventsWidget.cpp +3 -1

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

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

             #include "Catalogue/CatalogueInspectorWidget.h"
             #include "ui_CatalogueInspectorWidget.h"
             #include <Common/DateUtils.h>
             #include <DBCatalogue.h>
             #include <DBEvent.h>
             #include <DBEventProduct.h>
             #include <DBTag.h>
             struct CatalogueInspectorWidget::CatalogueInspectorWidgetPrivate {
                 std::shared_ptr<DBCatalogue> m_DisplayedCatalogue = nullptr;
                 std::shared_ptr<DBEvent> m_DisplayedEvent = nullptr;
                 std::shared_ptr<DBEventProduct> m_DisplayedEventProduct = 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->leEventTags, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     auto tags = ui->leEventTags->text().split(QRegExp("\\s+"));
                     std::list<QString> tagNames;
                     for (auto tag : tags) {
                         tagNames.push_back(tag);
                     }
                     if (m_DisplayedEvent->getTagsNames() != tagNames) {
                         m_DisplayedEvent->setTagsNames(tagNames);
                         emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
                 connect(ui->leEventProduct, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     if (ui->leEventProduct->text() != m_DisplayedEventProduct->getProductId()) {
                         auto oldProductId = m_DisplayedEventProduct->getProductId();
                         m_DisplayedEventProduct->setProductId(ui->leEventProduct->text());
                         auto eventProducts = m_DisplayedEvent->getEventProducts();
                         for (auto &eventProduct : eventProducts) {
                             if (eventProduct.getProductId() == oldProductId) {
                                 eventProduct.setProductId(m_DisplayedEventProduct->getProductId());
                             }
                         }
                         m_DisplayedEvent->setEventProducts(eventProducts);
                         emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
                 connect(ui->dateTimeEventTStart, &QDateTimeEdit::editingFinished, [ui, inspector, this]() {
                     auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTStart->dateTime());
                     if (time != m_DisplayedEventProduct->getTStart()) {
                         m_DisplayedEventProduct->setTStart(time);
                         auto eventProducts = m_DisplayedEvent->getEventProducts();
                         for (auto &eventProduct : eventProducts) {
                             if (eventProduct.getProductId() == m_DisplayedEventProduct->getProductId()) {
                                 eventProduct.setTStart(m_DisplayedEventProduct->getTStart());
                             }
                         }
                         m_DisplayedEvent->setEventProducts(eventProducts);
                         emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
                 connect(ui->dateTimeEventTEnd, &QDateTimeEdit::editingFinished, [ui, inspector, this]() {
                     auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTEnd->dateTime());
                     if (time != m_DisplayedEventProduct->getTEnd()) {
                         m_DisplayedEventProduct->setTEnd(time);
                         auto eventProducts = m_DisplayedEvent->getEventProducts();
                         for (auto &eventProduct : eventProducts) {
                             if (eventProduct.getProductId() == m_DisplayedEventProduct->getProductId()) {
                                 eventProduct.setTEnd(m_DisplayedEventProduct->getTEnd());
                             }
                         }
                         m_DisplayedEvent->setEventProducts(eventProducts);
                         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->setEnabled(true);
                 ui->leEventName->setText(event->getName());
                 ui->leEventProduct->setEnabled(false);
                 ui->leEventProduct->setText(
                     QString::number(event->getEventProducts().size()).append(" product(s)"));
                 QString tagList;
                 auto tags = event->getTagsNames();
                 for (auto tag : tags) {
                     tagList += tag;
                     tagList += ' ';
                 }
                 ui->leEventTags->setEnabled(true);
                 ui->leEventTags->setText(tagList);
                 ui->dateTimeEventTStart->setEnabled(false);
                 ui->dateTimeEventTEnd->setEnabled(false);
                 ui->dateTimeEventTStart->setDateTime(DateUtils::dateTime(event->getTStart()));
                 ui->dateTimeEventTEnd->setDateTime(DateUtils::dateTime(event->getTEnd()));
                 blockSignals(false);
             }
             void CatalogueInspectorWidget::setEventProduct(const std::shared_ptr<DBEvent> &event,
                                                            const std::shared_ptr<DBEventProduct> &eventProduct)
             {
                 impl->m_DisplayedEvent = event;
                 impl->m_DisplayedEventProduct = eventProduct;
                 blockSignals(true);
                 showPage(Page::EventProperties);
                 ui->leEventName->setEnabled(false);
                 ui->leEventName->setText(event->getName());
-                ui->leEventProduct->setEnabled(true);
+                ui->leEventProduct->setEnabled(false);
                 ui->leEventProduct->setText(eventProduct->getProductId());
                 ui->leEventTags->setEnabled(false);
                 ui->leEventTags->clear();
                 ui->dateTimeEventTStart->setEnabled(true);
                 ui->dateTimeEventTEnd->setEnabled(true);
                 ui->dateTimeEventTStart->setDateTime(DateUtils::dateTime(eventProduct->getTStart()));
                 ui->dateTimeEventTEnd->setDateTime(DateUtils::dateTime(eventProduct->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);
             }

General Comments 3

perrinel

|

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