HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r184:2e4df5890251

Fixes wrong shades zvalues

Michal Klocek -

r184:2e4df5890251

parent child

Context file:

r184:2e4df5890251

Collapse all files

example/axischart/main.cpp +1 -1

             #include <QApplication>
             #include <QMainWindow>
             #include <qchartview.h>
             #include <qlinechartseries.h>
             #include <qchart.h>
             #include <qchartaxis.h>
             #include <cmath>
             QTCOMMERCIALCHART_USE_NAMESPACE
             #define PI 3.14159265358979
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
                 QLineChartSeries* series0 = new QLineChartSeries();
                 QPen blue(Qt::blue);
                 blue.setWidth(3);
                 series0->setPen(blue);
                 QLineChartSeries* series1 = new QLineChartSeries();
                 QPen red(Qt::red);
                 red.setWidth(3);
                 series1->setPen(red);
                 int numPoints = 100;
                 for (int x = 0; x <= numPoints; ++x) {
                 	  series0->add(x, fabs(sin(PI/50*x)*100));
                 	  series1->add(x, fabs(cos(PI/50*x)*100));
                 }
                 QChartView* chartView =  new QChartView(&window);
                 chartView->setRenderHint(QPainter::Antialiasing);
                 chartView->setTitle("Basic line chart example");
                 chartView->addSeries(series0);
                 chartView->addSeries(series1);
                 chartView->setChartBackgroundBrush(Qt::white);
                 QChartAxis axis = chartView->defaultAxisX();
                 axis.setLabelsOrientation(QChartAxis::LabelsOrientationSlide);
                 axis.setGridPen(Qt::DashLine);
                 chartView->setDefaultAxisX(axis);
-                //axis.setShadesBrush(Qt::gray);
+                axis.setShadesBrush(Qt::gray);
                 chartView->setDefaultAxisY(axis);
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

src/axisitem.cpp +32 -3

             #include "axisitem_p.h"
             #include "qchartaxis.h"
             #include <QPainter>
             #include <QDebug>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AxisItem::AxisItem(AxisType type,QGraphicsItem* parent) :
             ChartItem(parent),
             m_ticks(4),
             m_type(type),
             m_labelsAngle(0),
             m_shadesEnabled(true),
-            m_grid(this),
+            m_grid(parent),
-            m_shades(this),
+            m_shades(parent),
-            m_labels(this)
+            m_labels(parent)
             {
                 //initial initialization
+                m_shades.setZValue(0);
+                m_grid.setZValue(2);
                 createItems();
             }
             AxisItem::~AxisItem()
             {
             }
             QRectF AxisItem::boundingRect() const
             {
                 return m_rect;
             }
             void AxisItem::createItems()
             {
                 for (int i = 0; i <= m_ticks; ++i) {
                        m_grid.addToGroup(new QGraphicsLineItem(this));
                        m_labels.addToGroup(new QGraphicsSimpleTextItem(this));
                        if(i%2) m_shades.addToGroup(new QGraphicsRectItem(this));
                    }
             }
             void AxisItem::clear()
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     delete item;
                 }
                 foreach(QGraphicsItem* item , m_grid.childItems()) {
                     delete item;
                 }
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     delete item;
                 }
             }
             void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
             }
             void AxisItem::updateDomain()
             {
                 QList<QGraphicsItem *> lines = m_grid.childItems();
                 QList<QGraphicsItem *> labels = m_labels.childItems();
                 QList<QGraphicsItem *> shades = m_shades.childItems();
                 switch (m_type)
                   {
                       case X_AXIS:
                       {
                           const qreal deltaX = m_rect.width() / m_ticks;
+                          m_axis.setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
                           for (int i = 0; i <= m_ticks; ++i) {
                               int x = i * deltaX + m_rect.left();
                               qreal label = m_domain.m_minX + (i * m_domain.spanX()/ m_ticks);
                               QGraphicsLineItem *lineItem =  static_cast<QGraphicsLineItem*>(lines.at(i));
                               lineItem->setLine(x, m_rect.top(), x, m_rect.bottom());
                               QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                               labelItem->setText(QString::number(label));
                               QPointF center = labelItem->boundingRect().center();
                               labelItem->setTransformOriginPoint(center.x(), center.y());
                               labelItem->setPos(x - center.x(), m_rect.bottom() + label_padding);
                               if(i%2){
                                   QGraphicsRectItem *rectItem =  static_cast<QGraphicsRectItem*>(shades.at(i/2));
                                   rectItem->setRect(x,m_rect.top(),deltaX,m_rect.height());
                               }
                           }
                       }
                       break;
                       case Y_AXIS:
                       {
                           const qreal deltaY = m_rect.height()/ m_ticks;
+                          m_axis.setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
                           for (int i = 0; i <= m_ticks; ++i) {
                               int y = i * -deltaY + m_rect.bottom();
                               qreal label = m_domain.m_minY + (i * m_domain.spanY()/ m_ticks);
                               QGraphicsLineItem *lineItem =  static_cast<QGraphicsLineItem*>(lines.at(i));
                               lineItem->setLine(m_rect.left() , y, m_rect.right(), y);
                               QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                               labelItem->setText(QString::number(label));
                               QPointF center = labelItem->boundingRect().center();
                               labelItem->setTransformOriginPoint(center.x(), center.y());
                               labelItem->setPos(m_rect.left() -  labelItem->boundingRect().width() - label_padding , y-center.y());
                               if(i%2){
                                   QGraphicsRectItem *rectItem =  static_cast<QGraphicsRectItem*>(shades.at(i/2));
                                   rectItem->setRect(m_rect.left(),y,m_rect.width(),deltaY);
                               }
                           }
                       }
                       break;
                       default:
                       qDebug()<<"Unknown axis type";
                       break;
                   }
             }
             void AxisItem::handleAxisChanged(const QChartAxis& axis)
             {
+                if(axis.isAxisVisible()) {
+                       setAxisOpacity(100);
+                   }
+                   else {
+                       setAxisOpacity(0);
+                }
                 if(axis.isGridVisible()) {
                     setGridOpacity(100);
                 }
                 else {
                     setGridOpacity(0);
                 }
                 if(axis.isLabelsVisible())
                 {
                     setLabelsOpacity(100);
                 }
                 else {
                     setLabelsOpacity(0);
                 }
                 if(axis.isShadesVisible()) {
                     setShadesOpacity(100);
                 }
                 else {
                     setShadesOpacity(0);
                 }
                 switch(axis.labelsOrientation())
                 {
                     case QChartAxis::LabelsOrientationHorizontal:
                         setLabelsAngle(0);
                         break;
                     case QChartAxis::LabelsOrientationVertical:
                         setLabelsAngle(90);
                         break;
                     case QChartAxis::LabelsOrientationSlide:
                         setLabelsAngle(-45);
                         break;
                     default:
                     break;
                 }
+                setAxisPen(axis.axisPen());
                 setLabelsPen(axis.labelsPen());
                 setLabelsBrush(axis.labelsBrush());
                 setLabelsFont(axis.labelFont());
                 setGridPen(axis.gridPen());
                 setShadesPen(axis.shadesPen());
                 setShadesBrush(axis.shadesBrush());
             }
             void AxisItem::handleDomainChanged(const Domain& domain)
             {
                 m_domain = domain;
                 updateDomain();
                 update();
             }
             void AxisItem::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect = rect;
                 updateDomain();
                 update();
             }
+            void AxisItem::setAxisOpacity(qreal opacity)
+            {
+                m_axis.setOpacity(opacity);
+            }
+            qreal AxisItem::axisOpacity() const
+            {
+                return m_axis.opacity();
+            }
             void AxisItem::setGridOpacity(qreal opacity)
             {
                 m_grid.setOpacity(opacity);
             }
             qreal AxisItem::gridOpacity() const
             {
                 return m_grid.opacity();
             }
             void AxisItem::setLabelsOpacity(qreal opacity)
             {
                 m_labels.setOpacity(opacity);
             }
             qreal AxisItem::labelsOpacity() const
             {
                 return m_labels.opacity();
             }
             void AxisItem::setShadesOpacity(qreal opacity)
             {
                 m_shades.setOpacity(opacity);
             }
             qreal AxisItem::shadesOpacity() const
             {
                 return m_shades.opacity();
             }
             void AxisItem::setLabelsAngle(int angle)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                       QPointF center = item->boundingRect().center();
                       item->setRotation(angle);
                 }
                 m_labelsAngle=angle;
             }
             void AxisItem::setLabelsPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
                 }
             }
             void AxisItem::setLabelsBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
                 }
             }
             void AxisItem::setLabelsFont(const QFont& font)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 }
             }
             void AxisItem::setShadesBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
                 }
             }
             void AxisItem::setShadesPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
                 }
             }
+            void AxisItem::setAxisPen(const QPen& pen)
+            {
+                m_axis.setPen(pen);
+            }
             void AxisItem::setGridPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_grid.childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             void AxisItem::setTicks(int count)
             {
                 if(count!=m_ticks){
                 clear();
                 m_ticks=count;
                 createItems();
                 }
             }
             //TODO "nice numbers algorithm"
             #include "moc_axisitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axisitem_p.h +5 0

             #ifndef AXISITEM_H_
             #define AXISITEM_H_
             #include "domain_p.h"
             #include "chartitem_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartAxis;
             class AxisItem : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
                 enum AxisType{X_AXIS,Y_AXIS};
                 AxisItem(AxisType type = X_AXIS,QGraphicsItem* parent = 0);
                 ~AxisItem();
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 AxisType axisType() const {return m_type;};
+                void setAxisOpacity(qreal opacity);
+                qreal axisOpacity() const;
                 void setGridOpacity(qreal opacity);
                 qreal gridOpacity() const;
                 void setLabelsOpacity(qreal opacity);
                 qreal labelsOpacity() const;
                 void setShadesOpacity(qreal opacity);
                 qreal shadesOpacity() const;
                 void setLabelsAngle(int angle);
                 int labelsAngle()const { return m_labelsAngle; }
                 void setTicks(int count);
                 int ticks() const { return m_ticks;}
                 void setShadesBrush(const QBrush& brush);
                 void setShadesPen(const QPen& pen);
+                void setAxisPen(const QPen& pen);
                 void setGridPen(const QPen& pen);
                 void setLabelsPen(const QPen& pen);
                 void setLabelsBrush(const QBrush& brush);
                 void setLabelsFont(const QFont& font);
             public slots:
                 void handleAxisChanged(const QChartAxis& axis);
                 void handleDomainChanged(const Domain& domain);
                 void handleGeometryChanged(const QRectF& size);
             protected:
                 void updateDomain();
             private:
                 void clear();
                 void createItems();
             private:
                 AxisType m_type;
                 int m_ticks;
                 Domain m_domain;
                 QRectF m_rect;
                 int m_labelsAngle;
                 bool m_shadesEnabled;
                 QGraphicsItemGroup m_grid;
                 QGraphicsItemGroup m_shades;
                 QGraphicsItemGroup m_labels;
+                QGraphicsLineItem m_axis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXISITEM_H_ */

src/charttheme.cpp +1 0

             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             //series
             #include "barchartseries.h"
             #include "stackedbarchartseries.h"
             #include "percentbarchartseries.h"
             #include "qlinechartseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             //items
             #include "axisitem_p.h"
             #include "bargroup.h"
             #include "stackedbargroup.h"
             #include "linechartitem_p.h"
             #include "percentbargroup.h"
             #include "scatterpresenter.h"
             #include "piepresenter.h"
             //themes
             #include "chartthemevanilla_p.h"
             #include "chartthemeicy_p.h"
             #include "chartthemegrayscale_p.h"
             #include "chartthemescientific_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /* TODO
                 case QChart::ChartThemeUnnamed1:
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff3fa9f5)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff7AC943)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF931E)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF1D25)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF7BAC)), 2));
                     m_gradientStartColor = QColor(QRgb(0xfff3dc9e));
                     m_gradientEndColor = QColor(QRgb(0xffafafaf));
             */
             ChartTheme::ChartTheme(QChart::ChartTheme id)
             {
                 m_id = id;
                 m_seriesColor.append(QRgb(0xff000000));
                 m_seriesColor.append(QRgb(0xff707070));
                 m_gradientStartColor = QColor(QRgb(0xffffffff));
                 m_gradientEndColor = QColor(QRgb(0xffafafaf));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeDefault:
                         return new ChartTheme();
                     case QChart::ChartThemeVanilla:
                         return new ChartThemeVanilla();
                     case QChart::ChartThemeIcy:
                         return new ChartThemeIcy();
                     case QChart::ChartThemeGrayscale:
                         return new ChartThemeGrayscale();
                     case QChart::ChartThemeScientific:
                         return new ChartThemeScientific();
                 }
             }
             void ChartTheme::decorate(QChart* chart)
             {
                 QLinearGradient backgroundGradient;
                 backgroundGradient.setColorAt(0.0, m_gradientStartColor);
                 backgroundGradient.setColorAt(1.0, m_gradientEndColor);
                 backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                 chart->setChartBackgroundBrush(backgroundGradient);
             }
             //TODO helper to by removed later
             void ChartTheme::decorate(ChartItem* item, QChartSeries* series,int count)
             {
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QLineChartSeries* s = static_cast<QLineChartSeries*>(series);
                         LineChartItem* i = static_cast<LineChartItem*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         BarChartSeries* b = static_cast<BarChartSeries*>(series);
                         BarGroup* i = static_cast<BarGroup*>(item);
                         decorate(i,b,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         StackedBarChartSeries* s = static_cast<StackedBarChartSeries*>(series);
                         StackedBarGroup* i = static_cast<StackedBarGroup*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         PercentBarChartSeries* s = static_cast<PercentBarChartSeries*>(series);
                         PercentBarGroup* i = static_cast<PercentBarGroup*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypePie: {
                         QPieSeries* s = static_cast<QPieSeries*>(series);
                         PiePresenter* i = static_cast<PiePresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     default:
                     qDebug()<<"Wrong item to be decorated by theme";
                     break;
                 }
             }
             void ChartTheme::decorate(LineChartItem* item, QLineChartSeries* series,int count)
             {
                 QPen pen;
                 if(pen != series->pen()){
                     item->setPen(series->pen());
                     return;
                 }
                 pen.setColor(m_seriesColor.at(count%m_seriesColor.size()));
                 pen.setWidthF(2);
                 item->setPen(pen);
             }
             void ChartTheme::decorate(BarGroup* item, BarChartSeries* series,int count)
             {
                 // TODO: better way to descide series color and remove hard coded colors.
                 item->resetBrushes();
                 for (int i=0; i<m_seriesColor.count(); i++) {
                     QBrush brush(m_seriesColor.at(i));
                     item->addBrush(brush);
                 }
                 item->addBrush(QBrush(QColor(255,0,0,128)));
                 item->addBrush(QBrush(QColor(255,255,0,128)));
                 item->addBrush(QBrush(QColor(0,255,0,128)));
                 item->addBrush(QBrush(QColor(0,0,255,128)));
                 item->addBrush(QBrush(QColor(255,128,0,128)));
             }
             void ChartTheme::decorate(StackedBarGroup* item, StackedBarChartSeries* series,int count)
             {
                 // TODO: better way to descide series color and remove hard coded colors.
                 item->resetBrushes();
                 for (int i=0; i<m_seriesColor.count(); i++) {
                     QBrush brush(m_seriesColor.at(i));
                     item->addBrush(brush);
                 }
                 item->addBrush(QBrush(QColor(255,0,0,128)));
                 item->addBrush(QBrush(QColor(255,255,0,128)));
                 item->addBrush(QBrush(QColor(0,255,0,128)));
                 item->addBrush(QBrush(QColor(0,0,255,128)));
                 item->addBrush(QBrush(QColor(255,128,0,128)));
             }
             void ChartTheme::decorate(PercentBarGroup* item, PercentBarChartSeries* series,int count)
             {
                 // TODO: better way to descide series color and remove hard coded colors.
                 item->resetBrushes();
                 for (int i=0; i<m_seriesColor.count(); i++) {
                     QBrush brush(m_seriesColor.at(i));
                     item->addBrush(brush);
                 }
                 item->addBrush(QBrush(QColor(255,0,0,128)));
                 item->addBrush(QBrush(QColor(255,255,0,128)));
                 item->addBrush(QBrush(QColor(0,255,0,128)));
                 item->addBrush(QBrush(QColor(0,0,255,128)));
                 item->addBrush(QBrush(QColor(255,128,0,128)));
             }
             void ChartTheme::decorate(ScatterPresenter* presenter, QScatterSeries* series, int count)
             {
                 Q_ASSERT(presenter);
                 Q_ASSERT(series);
                 presenter->m_markerPen.setColor(m_seriesColor.at(count % m_seriesColor.size()));
             //    QPen pen;
             //    if(pen != series->pen()){
             //        item->setPen(series->pen());
             //        return;
             //    }
             //    pen.setColor(m_seriesColor.at(count%m_seriesColor.size()));
             //    pen.setWidthF(2);
             //    item->setPen(pen);
             }
             void ChartTheme::decorate(PiePresenter* item, QPieSeries* series, int /*count*/)
             {
                 // create a list of slice colors based on current theme
                 int i = 0;
                 QList<QColor> colors;
                 while (colors.count() < series->count()) {
                     // get base color
                     QColor c = m_seriesColor[i++];
                     i = i % m_seriesColor.count();
                     // -1 means achromatic color -> cannot manipulate lightness
                     // TODO: find a better way to randomize lightness
                     if (c.toHsv().hue() == -1)
                         qWarning() << "ChartTheme::decorate() warning: achromatic theme color";
                     // randomize lightness
                     qreal f = 50 + (qrand() % 100); // 50 is 50% darker, 100 is the same, 150 is 50% lighter
                     c = c.lighter(f);
                     // find duplicates
                     bool isUnique = true;
                     foreach (QColor color, colors) {
                         if (c == color)
                             isUnique = false;
                     }
                     // add to array if unique
                     //if (isUnique)
                         colors << c;
                 }
                 // finally update colors
                 foreach (QPieSliceId id, series->ids()) {
                     QPieSlice s = series->slice(id);
                     s.setPen(QPen(Qt::black)); // TODO: get from theme
                     s.setBrush(colors.takeFirst());
                     series->update(s);
                 }
             }
             void ChartTheme::decorate(QChartAxis& axis,AxisItem* item)
             {
                 //TODO: dummy defults for now
                 axis.setLabelsBrush(Qt::black);
                 axis.setLabelsPen(Qt::NoPen);
+                axis.setShadesPen(Qt::NoPen);
                 item->handleAxisChanged(axis);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartaxis.cpp 0 -5

             #include "qchartaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChartAxis::QChartAxis():
             m_axisVisible(true),
             m_gridVisible(true),
             m_labelsVisible(true),
             m_shadesVisible(true)
             {
                 // TODO Auto-generated constructor stub
             }
             QChartAxis::~QChartAxis()
             {
                 // TODO Auto-generated destructor stub
             }
             void QChartAxis::setAxisPen(const QPen& pen)
             {
                 m_axisPen=pen;
             }
-            void QChartAxis::setAxisBrush(const QBrush& brush)
-                m_axisBrush=brush;
             void QChartAxis::setAxisVisible(bool visible)
             {
                 m_axisVisible=visible;
             }
             void QChartAxis::setGridVisible(bool visible)
             {
                 m_gridVisible=visible;
             }
             void QChartAxis::setGridPen(const QPen& pen)
             {
                 m_gridPen=pen;
             }
             void QChartAxis::setLabelsVisible(bool visible)
             {
                 m_labelsVisible=visible;
             }
             void QChartAxis::setLabelsPen(const QPen& pen)
             {
                 m_labelsPen=pen;
             }
             void QChartAxis::setLabelsBrush(const QBrush& brush)
             {
                 m_labelsBrush=brush;
             }
             void QChartAxis::setLabelsFont(const QFont& font)
             {
                 m_labelsFont=font;
             }
             void QChartAxis::setLabelsOrientation(LabelsOrientation orientation)
             {
                 m_labelsOrientation=orientation;
             }
             void QChartAxis::setShadesVisible(bool visible)
             {
                 m_shadesVisible=visible;
             }
             void QChartAxis::setShadesPen(const QPen& pen)
             {
                 m_shadesPen=pen;
             }
             void QChartAxis::setShadesBrush(const QBrush& brush)
             {
                 m_shadesBrush=brush;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

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