GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r443:0277630b5c10

Creates method that will display a tooltip and a tracer with data point information after a while

Alexandre Leroux -

r443:0277630b5c10

parent child

Context file:

r443:0277630b5c10

Collapse all files

gui/include/Visualization/VisualizationGraphRenderingDelegate.h +2 0

              #ifndef SCIQLOP_VISUALIZATIONGRAPHRENDERINGDELEGATE_H
              #define SCIQLOP_VISUALIZATIONGRAPHRENDERINGDELEGATE_H
              #include <Common/spimpl.h>
              class QCustomPlot;
              class QMouseEvent;
              class VisualizationGraphRenderingDelegate {
              public:
                  explicit VisualizationGraphRenderingDelegate(QCustomPlot &plot);
+                 void onMouseMove(QMouseEvent *event) noexcept;
              private:
                  class VisualizationGraphRenderingDelegatePrivate;
                  spimpl::unique_impl_ptr<VisualizationGraphRenderingDelegatePrivate> impl;
              };
              #endif // SCIQLOP_VISUALIZATIONGRAPHRENDERINGDELEGATE_H

gui/include/Visualization/VisualizationGraphWidget.h +2 0

              #ifndef SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
              #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
              #include "Visualization/IVisualizationWidget.h"
              #include <QLoggingCategory>
              #include <QWidget>
              #include <memory>
              #include <Common/spimpl.h>
              Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphWidget)
              class QCPRange;
              class SqpDateTime;
              class Variable;
              /**
               * Possible types of zoom operation
               */
              enum class VisualizationGraphWidgetZoomType { ZoomOut, ZoomIn, PanRight, PanLeft, Unknown };
              namespace Ui {
              class VisualizationGraphWidget;
              } // namespace Ui
              class VisualizationGraphWidget : public QWidget, public IVisualizationWidget {
                  Q_OBJECT
              public:
                  explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
                  virtual ~VisualizationGraphWidget();
                  void enableSynchronize(bool enable);
                  void addVariable(std::shared_ptr<Variable> variable);
                  void addVariableUsingGraph(std::shared_ptr<Variable> variable);
                  /// Removes a variable from the graph
                  void removeVariable(std::shared_ptr<Variable> variable) noexcept;
                  void setRange(std::shared_ptr<Variable> variable, const SqpDateTime &range);
                  SqpDateTime graphRange() const noexcept;
                  void setGraphRange(const SqpDateTime &range);
                  // IVisualizationWidget interface
                  void accept(IVisualizationWidgetVisitor *visitor) override;
                  bool canDrop(const Variable &variable) const override;
                  bool contains(const Variable &variable) const override;
                  QString name() const override;
              signals:
                  void requestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
                  void synchronize(const SqpDateTime &dateTime, const SqpDateTime &oldDateTime,
                                   VisualizationGraphWidgetZoomType zoomType);
              private:
                  Ui::VisualizationGraphWidget *ui;
                  class VisualizationGraphWidgetPrivate;
                  spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
              private slots:
                  /// Slot called when right clicking on the graph (displays a menu)
                  void onGraphMenuRequested(const QPoint &pos) noexcept;
                  /// Rescale the X axe to range parameter
                  void onRangeChanged(const QCPRange &t1, const QCPRange &t2);
+                 /// Slot called when a mouse move was made
+                 void onMouseMove(QMouseEvent *event) noexcept;
                  /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
                  void onMouseWheel(QWheelEvent *event) noexcept;
                  /// Slot called when a mouse press was made, to activate the calibration of a graph
                  void onMousePress(QMouseEvent *event) noexcept;
                  /// Slot called when a mouse release was made, to deactivate the calibration of a graph
                  void onMouseRelease(QMouseEvent *event) noexcept;
                  void onDataCacheVariableUpdated();
              };
              #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H

gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp +4 0

              #include "Visualization/VisualizationGraphRenderingDelegate.h"
              #include "Visualization/qcustomplot.h"
              struct VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegatePrivate {
                  explicit VisualizationGraphRenderingDelegatePrivate(QCustomPlot &plot) : m_Plot{plot} {}
                  QCustomPlot &m_Plot;
              };
              VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegate(QCustomPlot &plot)
                      : impl{spimpl::make_unique_impl<VisualizationGraphRenderingDelegatePrivate>(plot)}
              {
              }
+             void VisualizationGraphRenderingDelegate::onMouseMove(QMouseEvent *event) noexcept
+             {
+             }

gui/src/Visualization/VisualizationGraphWidget.cpp +8 0

              #include "Visualization/VisualizationGraphWidget.h"
              #include "Visualization/IVisualizationWidgetVisitor.h"
              #include "Visualization/VisualizationGraphHelper.h"
              #include "Visualization/VisualizationGraphRenderingDelegate.h"
              #include "ui_VisualizationGraphWidget.h"
              #include <Data/ArrayData.h>
              #include <Data/IDataSeries.h>
              #include <Settings/SqpSettingsDefs.h>
              #include <SqpApplication.h>
              #include <Variable/Variable.h>
              #include <Variable/VariableController.h>
              #include <unordered_map>
              Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
              namespace {
              /// Key pressed to enable zoom on horizontal axis
              const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
              /// Key pressed to enable zoom on vertical axis
              const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
              /// Gets a tolerance value from application settings. If the setting can't be found, the default
              /// value passed in parameter is returned
              double toleranceValue(const QString &key, double defaultValue) noexcept
              {
                  return QSettings{}.value(key, defaultValue).toDouble();
              }
              } // namespace
              struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                  explicit VisualizationGraphWidgetPrivate()
                          : m_DoSynchronize{true}, m_IsCalibration{false}, m_RenderingDelegate{nullptr}
                  {
                  }
                  // Return the operation when range changed
                  VisualizationGraphWidgetZoomType getZoomType(const QCPRange &t1, const QCPRange &t2);
                  // 1 variable -> n qcpplot
                  std::multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMultiMap;
                  bool m_DoSynchronize;
                  bool m_IsCalibration;
                  QCPItemTracer *m_TextTracer;
                  /// Delegate used to attach rendering features to the plot
                  std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
              };
              VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                      : QWidget{parent},
                        ui{new Ui::VisualizationGraphWidget},
                        impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
              {
                  ui->setupUi(this);
                  // The delegate must be initialized after the ui as it uses the plot
                  impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*ui->widget);
                  ui->graphNameLabel->setText(name);
                  // 'Close' options : widget is deleted when closed
                  setAttribute(Qt::WA_DeleteOnClose);
                  connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationGraphWidget::close);
                  ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                  // Set qcpplot properties :
                  // - Drag (on x-axis) and zoom are enabled
                  // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                  ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
                  ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
                  connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
                  connect(ui->widget, &QCustomPlot::mouseRelease, this,
                          &VisualizationGraphWidget::onMouseRelease);
+                 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
                  connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
                  connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
                                                 &QCPAxis::rangeChanged),
                          this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
                  // Activates menu when right clicking on the graph
                  ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
                  connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
                          &VisualizationGraphWidget::onGraphMenuRequested);
                  connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
                          &VariableController::onRequestDataLoading);
              }
              VisualizationGraphWidget::~VisualizationGraphWidget()
              {
                  delete ui;
              }
              void VisualizationGraphWidget::enableSynchronize(bool enable)
              {
                  impl->m_DoSynchronize = enable;
              }
              void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
              {
                  // Uses delegate to create the qcpplot components according to the variable
                  auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
                  for (auto createdPlottable : qAsConst(createdPlottables)) {
                      impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
                  }
                  connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
              }
              void VisualizationGraphWidget::addVariableUsingGraph(std::shared_ptr<Variable> variable)
              {
                  // when adding a variable, we need to set its time range to the current graph range
                  auto grapheRange = ui->widget->xAxis->range();
                  auto dateTime = SqpDateTime{grapheRange.lower, grapheRange.upper};
                  variable->setDateTime(dateTime);
                  auto variableDateTimeWithTolerance = dateTime;
                  // add tolerance for each side
                  auto toleranceFactor
                      = toleranceValue(GENERAL_TOLERANCE_AT_INIT_KEY, GENERAL_TOLERANCE_AT_INIT_DEFAULT_VALUE);
                  auto tolerance = toleranceFactor * (dateTime.m_TEnd - dateTime.m_TStart);
                  variableDateTimeWithTolerance.m_TStart -= tolerance;
                  variableDateTimeWithTolerance.m_TEnd += tolerance;
                  // Uses delegate to create the qcpplot components according to the variable
                  auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
                  for (auto createdPlottable : qAsConst(createdPlottables)) {
                      impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
                  }
                  connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
                  // CHangement detected, we need to ask controller to request data loading
                  emit requestDataLoading(variable, variableDateTimeWithTolerance);
              }
              void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
              {
                  // Each component associated to the variable :
                  // - is removed from qcpplot (which deletes it)
                  // - is no longer referenced in the map
                  auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
                  for (auto it = componentsIt.first; it != componentsIt.second;) {
                      ui->widget->removePlottable(it->second);
                      it = impl->m_VariableToPlotMultiMap.erase(it);
                  }
                  // Updates graph
                  ui->widget->replot();
              }
              void VisualizationGraphWidget::setRange(std::shared_ptr<Variable> variable,
                                                      const SqpDateTime &range)
              {
                  // Note: in case of different axes that depends on variable, we could start with a code like
                  // that:
                  //    auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
                  //    for (auto it = componentsIt.first; it != componentsIt.second;) {
                  //    }
                  ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                  ui->widget->replot();
              }
              SqpDateTime VisualizationGraphWidget::graphRange() const noexcept
              {
                  auto grapheRange = ui->widget->xAxis->range();
                  return SqpDateTime{grapheRange.lower, grapheRange.upper};
              }
              void VisualizationGraphWidget::setGraphRange(const SqpDateTime &range)
              {
                  qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
                  ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                  ui->widget->replot();
                  qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
              }
              void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
              {
                  if (visitor) {
                      visitor->visit(this);
                  }
                  else {
                      qCCritical(LOG_VisualizationGraphWidget())
                          << tr("Can't visit widget : the visitor is null");
                  }
              }
              bool VisualizationGraphWidget::canDrop(const Variable &variable) const
              {
                  /// @todo : for the moment, a graph can always accomodate a variable
                  Q_UNUSED(variable);
                  return true;
              }
              bool VisualizationGraphWidget::contains(const Variable &variable) const
              {
                  // Finds the variable among the keys of the map
                  auto variablePtr = &variable;
                  auto findVariable
                      = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
                  auto end = impl->m_VariableToPlotMultiMap.cend();
                  auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
                  return it != end;
              }
              QString VisualizationGraphWidget::name() const
              {
                  return ui->graphNameLabel->text();
              }
              void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
              {
                  QMenu graphMenu{};
                  // Iterates on variables (unique keys)
                  for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
                            end = impl->m_VariableToPlotMultiMap.cend();
                       it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                      // 'Remove variable' action
                      graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
                                          [ this, var = it->first ]() { removeVariable(var); });
                  }
                  if (!graphMenu.isEmpty()) {
                      graphMenu.exec(mapToGlobal(pos));
                  }
              }
              void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
              {
                  qCInfo(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::onRangeChanged")
                                                         << QThread::currentThread()->objectName();
                  auto dateTimeRange = SqpDateTime{t1.lower, t1.upper};
                  auto zoomType = impl->getZoomType(t1, t2);
                  for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                       it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                      auto variable = it->first;
                      auto currentDateTime = dateTimeRange;
                      auto toleranceFactor = toleranceValue(GENERAL_TOLERANCE_AT_UPDATE_KEY,
                                                            GENERAL_TOLERANCE_AT_UPDATE_DEFAULT_VALUE);
                      auto tolerance = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
                      auto variableDateTimeWithTolerance = currentDateTime;
                      variableDateTimeWithTolerance.m_TStart -= tolerance;
                      variableDateTimeWithTolerance.m_TEnd += tolerance;
                      qCDebug(LOG_VisualizationGraphWidget()) << "r" << currentDateTime;
                      qCDebug(LOG_VisualizationGraphWidget()) << "t" << variableDateTimeWithTolerance;
                      qCDebug(LOG_VisualizationGraphWidget()) << "v" << variable->dateTime();
                      // If new range with tol is upper than variable datetime parameters. we need to request new
                      // data
                      if (!variable->contains(variableDateTimeWithTolerance)) {
                          auto variableDateTimeWithTolerance = currentDateTime;
                          if (!variable->isInside(currentDateTime)) {
                              auto variableDateTime = variable->dateTime();
                              if (variable->contains(variableDateTimeWithTolerance)) {
                                  qCDebug(LOG_VisualizationGraphWidget())
                                      << tr("TORM: Detection zoom in that need request:");
                                  // add tolerance for each side
                                  tolerance
                                      = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
                                  variableDateTimeWithTolerance.m_TStart -= tolerance;
                                  variableDateTimeWithTolerance.m_TEnd += tolerance;
                              }
                              else if (variableDateTime.m_TStart < currentDateTime.m_TStart) {
                                  qCInfo(LOG_VisualizationGraphWidget()) << tr("TORM: Detection pan to right:");
                                  auto diffEndToKeepDelta = currentDateTime.m_TEnd - variableDateTime.m_TEnd;
                                  currentDateTime.m_TStart = variableDateTime.m_TStart + diffEndToKeepDelta;
                                  // Tolerance have to be added to the right
                                  // add tolerance for right (end) side
                                  tolerance
                                      = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
                                  variableDateTimeWithTolerance.m_TEnd += tolerance;
                              }
                              else if (variableDateTime.m_TEnd > currentDateTime.m_TEnd) {
                                  qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: Detection pan to left: ");
                                  auto diffStartToKeepDelta
                                      = variableDateTime.m_TStart - currentDateTime.m_TStart;
                                  currentDateTime.m_TEnd = variableDateTime.m_TEnd - diffStartToKeepDelta;
                                  // Tolerance have to be added to the left
                                  // add tolerance for left (start) side
                                  tolerance
                                      = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
                                  variableDateTimeWithTolerance.m_TStart -= tolerance;
                              }
                              else {
                                  qCCritical(LOG_VisualizationGraphWidget())
                                      << tr("Detection anormal zoom detection: ");
                              }
                          }
                          else {
                              qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: Detection zoom out: ");
                              // add tolerance for each side
                              tolerance = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
                              variableDateTimeWithTolerance.m_TStart -= tolerance;
                              variableDateTimeWithTolerance.m_TEnd += tolerance;
                              zoomType = VisualizationGraphWidgetZoomType::ZoomOut;
                          }
                          if (!variable->contains(dateTimeRange)) {
                              qCDebug(LOG_VisualizationGraphWidget())
                                  << "TORM: Modif on variable datetime detected" << currentDateTime;
                              variable->setDateTime(currentDateTime);
                          }
                          qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: Request data detection: ");
                          // CHangement detected, we need to ask controller to request data loading
                          emit requestDataLoading(variable, variableDateTimeWithTolerance);
                      }
                      else {
                          qCInfo(LOG_VisualizationGraphWidget())
                              << tr("TORM: Detection zoom in that doesn't need request: ");
                          zoomType = VisualizationGraphWidgetZoomType::ZoomIn;
                      }
                  }
                  if (impl->m_DoSynchronize && !impl->m_IsCalibration) {
                      auto oldDateTime = SqpDateTime{t2.lower, t2.upper};
                      qCDebug(LOG_VisualizationGraphWidget())
                          << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
                          << QThread::currentThread()->objectName();
                      emit synchronize(dateTimeRange, oldDateTime, zoomType);
                  }
              }
+             void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
+             {
+                 // Handles plot rendering when mouse is moving
+                 impl->m_RenderingDelegate->onMouseMove(event);
+             }
              void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
              {
                  auto zoomOrientations = QFlags<Qt::Orientation>{};
                  // Lambda that enables a zoom orientation if the key modifier related to this orientation
                  // has
                  // been pressed
                  auto enableOrientation
                      = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
                            auto orientationEnabled = event->modifiers().testFlag(modifier);
                            zoomOrientations.setFlag(orientation, orientationEnabled);
                        };
                  enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
                  enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
                  ui->widget->axisRect()->setRangeZoom(zoomOrientations);
              }
              void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
              {
                  impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
              }
              void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
              {
                  impl->m_IsCalibration = false;
              }
              void VisualizationGraphWidget::onDataCacheVariableUpdated()
              {
                  // NOTE:
                  //    We don't want to call the method for each component of a variable unitarily, but for
                  //    all
                  //    its components at once (eg its three components in the case of a vector).
                  //    The unordered_multimap does not do this easily, so the question is whether to:
                  //    - use an ordered_multimap and the algos of std to group the values by key
                  //    - use a map (unique keys) and store as values directly the list of components
                  auto grapheRange = ui->widget->xAxis->range();
                  auto dateTime = SqpDateTime{grapheRange.lower, grapheRange.upper};
                  for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                       it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                      auto variable = it->first;
                      qCDebug(LOG_VisualizationGraphWidget())
                          << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S"
                          << variable->dateTime();
                      qCDebug(LOG_VisualizationGraphWidget())
                          << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
                      if (dateTime.contains(variable->dateTime()) || dateTime.intersect(variable->dateTime())) {
                          VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
                                                               variable->dataSeries(), variable->dateTime());
                      }
                  }
              }
              VisualizationGraphWidgetZoomType
              VisualizationGraphWidget::VisualizationGraphWidgetPrivate::getZoomType(const QCPRange &t1,
                                                                                     const QCPRange &t2)
              {
                  // t1.lower <= t2.lower && t2.upper <= t1.upper
                  auto zoomType = VisualizationGraphWidgetZoomType::Unknown;
                  if (t1.lower <= t2.lower && t2.upper <= t1.upper) {
                      zoomType = VisualizationGraphWidgetZoomType::ZoomOut;
                  }
                  else if (t1.lower > t2.lower && t1.upper > t2.upper) {
                      zoomType = VisualizationGraphWidgetZoomType::PanRight;
                  }
                  else if (t1.lower < t2.lower && t1.upper < t2.upper) {
                      zoomType = VisualizationGraphWidgetZoomType::PanLeft;
                  }
                  else if (t1.lower > t2.lower && t2.upper > t1.upper) {
                      zoomType = VisualizationGraphWidgetZoomType::ZoomIn;
                  }
                  else {
                      qCCritical(LOG_VisualizationGraphWidget()) << "getZoomType: Unknown type detected";
                  }
                  return zoomType;
              }

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