HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r406:d88edf82390f

Add drilldown example for piechart

Jani Honkonen -

r406:d88edf82390f

parent child

Context file:

r406:d88edf82390f

Collapse all files

example/piechartdrilldown/main.cpp created 644 +126 0

@@ -0,0 +1,126
	1	#include <QtGui/QApplication>
	2	#include <QMainWindow>
	3	#include <qchartglobal.h>
	4	#include <qchartview.h>
	5	#include <qpieseries.h>
	6	#include <qpieslice.h>
	7	#include <QTime>
	8
	9	QTCOMMERCIALCHART_USE_NAMESPACE
	10
	11	class DrilldownSlice : public QPieSlice
	12	{
	13	Q_OBJECT
	14
	15	public:
	16	DrilldownSlice(qreal value, QString prefix, QSeries* drilldownSeries)
	17	:m_drilldownSeries(drilldownSeries),
	18	m_prefix(prefix)
	19	{
	20	setValue(value);
	21	setLabelVisible(true);
	22	updateLabel();
	23	connect(this, SIGNAL(changed()), this, SLOT(updateLabel()));
	24	}
	25
	26	QSeries* drilldownSeries() const { return m_drilldownSeries; }
	27
	28	public Q_SLOTS:
	29	void updateLabel()
	30	{
	31	QString label = m_prefix;
	32	label += " - " + QString::number(this->value())+ "e (";
	33	label += QString::number(this->percentage()*100, 'f', 1) + "%)";
	34	qDebug() << "updateLabel" << label;
	35	setLabel(label);
	36	}
	37
	38	private:
	39	QSeries* m_drilldownSeries;
	40	QString m_prefix;
	41	};
	42
	43	class DrilldownChart : public QChartView
	44	{
	45	Q_OBJECT
	46	public:
	47	explicit DrilldownChart(QWidget *parent = 0):QChartView(parent), m_currentSeries(0) {}
	48
	49	void changeSeries(QSeries* series)
	50	{
	51	if (m_currentSeries)
	52	removeSeries(m_currentSeries);
	53	m_currentSeries = series;
	54	addSeries(series);
	55	setChartTitle(series->title());
	56	}
	57
	58	public Q_SLOTS:
	59	void handleSliceClicked(QPieSlice* slice)
	60	{
	61	DrilldownSlice* drilldownSlice = static_cast<DrilldownSlice*>(slice);
	62	changeSeries(drilldownSlice->drilldownSeries());
	63	}
	64
	65	private:
	66	QSeries* m_currentSeries;
	67	};
	68
	69	int main(int argc, char *argv[])
	70	{
	71	QApplication a(argc, argv);
	72
	73	qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
	74
	75	QMainWindow window;
	76
	77	DrilldownChart* drilldownChart = new DrilldownChart(&window);
	78	drilldownChart->setRenderHint(QPainter::Antialiasing);
	79	drilldownChart->setChartTheme(QChart::ChartThemeVanilla);
	80
	81	QPieSeries* yearSeries = new QPieSeries(drilldownChart);
	82	yearSeries->setTitle("Sales by year - All");
	83	yearSeries->setHoverHighlighting();
	84
	85	QList<QString> months;
	86	months << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
	87
	88	int max = 1000;
	89
	90	QPieSeries* monthSeriesJane = new QPieSeries(drilldownChart);
	91	monthSeriesJane->setTitle("Sales by month - Jane");
	92	monthSeriesJane->setHoverHighlighting();
	93	foreach (QString month, months)
	94	*monthSeriesJane << new DrilldownSlice(qrand() % max, month, yearSeries);
	95
	96	QPieSeries* monthSeriesJohn = new QPieSeries(drilldownChart);
	97	monthSeriesJohn->setTitle("Sales by month - John");
	98	monthSeriesJohn->setHoverHighlighting();
	99	foreach (QString month, months)
	100	*monthSeriesJohn << new DrilldownSlice(qrand() % max, month, yearSeries);
	101
	102	QPieSeries* monthSeriesAxel = new QPieSeries(drilldownChart);
	103	monthSeriesAxel->setTitle("Sales by month - Axel");
	104	monthSeriesAxel->setHoverHighlighting();
	105	foreach (QString month, months)
	106	*monthSeriesAxel << new DrilldownSlice(qrand() % max, month, yearSeries);
	107
	108	*yearSeries << new DrilldownSlice(monthSeriesJane->total(), "Jane", monthSeriesJane);
	109	*yearSeries << new DrilldownSlice(monthSeriesJohn->total(), "John", monthSeriesJohn);
	110	*yearSeries << new DrilldownSlice(monthSeriesAxel->total(), "Axel", monthSeriesAxel);
	111
	112	QObject::connect(monthSeriesJane, SIGNAL(clicked(QPieSlice)), drilldownChart, SLOT(handleSliceClicked(QPieSlice)));
	113	QObject::connect(monthSeriesJohn, SIGNAL(clicked(QPieSlice)), drilldownChart, SLOT(handleSliceClicked(QPieSlice)));
	114	QObject::connect(monthSeriesAxel, SIGNAL(clicked(QPieSlice)), drilldownChart, SLOT(handleSliceClicked(QPieSlice)));
	115	QObject::connect(yearSeries, SIGNAL(clicked(QPieSlice)), drilldownChart, SLOT(handleSliceClicked(QPieSlice)));
	116
	117	drilldownChart->changeSeries(yearSeries);
	118
	119	window.setCentralWidget(drilldownChart);
	120	window.resize(600, 600);
	121	window.show();
	122
	123	return a.exec();
	124	}
	125
	126	#include "main.moc"

example/piechartdrilldown/piechartdrilldown.pro created 644 +9 0

@@ -0,0 +1,9
	1	!include( ../example.pri ) {
	2	error( "Couldn't find the example.pri file!" )
	3	}
	4	TARGET = piechartdrilldown
	5	SOURCES += main.cpp
	6	HEADERS +=
	7
	8
	9	MOC_DIR = $$PWD/moc

example/example.pro +1 0

             TEMPLATE = subdirs
             SUBDIRS += linechart \
                        zoomlinechart \
                        colorlinechart \
                        barchart \
                        stackedbarchart \
                        percentbarchart \
                        scatter \
                        piechart \
+                       piechartdrilldown \
                        dynamiclinechart \
                        axischart \
                        multichart \
                        gdpbarchart \
                        presenterchart \
                        chartview \
                        scatterinteractions

src/piechart/qpieseries.cpp +20 -6

             #include "qpieseries.h"
             #include "qpieslice.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries::ChangeSet
                 \brief Defines the changes in the series.
                 Contains the changes that have occurred in the series. Lists of added, changed and removed slices.
                 \sa QPieSeries::changed()
             */
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendAdded(QPieSlice* slice)
             {
                 if (!m_added.contains(slice))
                     m_added << slice;
             }
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendAdded(QList<QPieSlice*> slices)
             {
                 foreach (QPieSlice* s, slices)
                     appendAdded(s);
             }
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendChanged(QPieSlice* slice)
             {
                 if (!m_changed.contains(slice))
                     m_changed << slice;
             }
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendRemoved(QPieSlice* slice)
             {
                 if (!m_removed.contains(slice))
                     m_removed << slice;
             }
             /*!
                 Returns a list of slices that have been added to the series.
                 \sa QPieSeries::changed()
             */
             QList<QPieSlice*> QPieSeries::ChangeSet::added() const
             {
                 return m_added;
             }
             /*!
                 Returns a list of slices that have been changed in the series.
                 \sa QPieSeries::changed()
             */
             QList<QPieSlice*> QPieSeries::ChangeSet::changed() const
             {
                 return m_changed;
             }
             /*!
                 Returns a list of slices that have been removed from the series.
                 \sa QPieSeries::changed()
             */
             QList<QPieSlice*> QPieSeries::ChangeSet::removed() const
             {
                 return m_removed;
             }
             /*!
                 Returns true if there are no added/changed or removed slices in the change set.
             */
             bool QPieSeries::ChangeSet::isEmpty() const
             {
                 if (m_added.count() || m_changed.count() || m_removed.count())
                     return false;
                 return true;
             }
             /*!
                 \enum QPieSeries::PiePosition
                 This enum describes pie position within its bounding rectangle
                 \value PiePositionMaximized
                 \value PiePositionTopLeft
                 \value PiePositionTopRight
                 \value PiePositionBottomLeft
                 \value PiePositionBottomRight
             */
             /*!
                 \class QPieSeries
                 \brief Pie series API for QtCommercial Charts
                 The pie series defines a pie chart which consists of pie slices which are QPieSlice objects.
                 The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
                 The actual slice size is determined by that relative value.
                 By default the pie is defined as a full pie but it can be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
                 To help with the most common user interaction scenarions there some convenience functions.
                 Like exploding a slice when clicked and higlighting when user hovers over a slice.
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent) :
                 QSeries(parent),
                 m_sizeFactor(1.0),
                 m_position(PiePositionMaximized),
                 m_pieStartAngle(0),
                 m_pieAngleSpan(360)
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QPieSeries::~QPieSeries()
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
             QSeries::QSeriesType QPieSeries::type() const
             {
                 return QSeries::SeriesTypePie;
             }
             /*!
                 Sets an array of \a slices to the series replacing the existing slices.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::replace(QList<QPieSlice*> slices)
             {
                 clear();
                 add(slices);
             }
             /*!
                 Adds an array of \a slices to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::add(QList<QPieSlice*> slices)
             {
                 ChangeSet changeSet;
                 foreach (QPieSlice* s, slices) {
                     s->setParent(this);
                     m_slices << s;
                     changeSet.appendAdded(s);
                 }
                 updateDerivativeData();
                 foreach (QPieSlice* s, slices) {
                     connect(s, SIGNAL(changed()), this, SLOT(sliceChanged()));
                     connect(s, SIGNAL(clicked()), this, SLOT(sliceClicked()));
                     connect(s, SIGNAL(hoverEnter()), this, SLOT(sliceHoverEnter()));
                     connect(s, SIGNAL(hoverLeave()), this, SLOT(sliceHoverLeave()));
                 }
                 emit changed(changeSet);
             }
             /*!
                 Adds a single \a slice to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::add(QPieSlice* slice)
             {
                 add(QList<QPieSlice*>() << slice);
             }
+            QPieSeries& QPieSeries::operator << (QPieSlice* slice)
+            {
+                add(slice);
+                return *this;
+            }
             /*!
                 Adds a single slice to the series with give \a value and \a name.
                 Slice ownership is passed to the series.
             */
             QPieSlice* QPieSeries::add(qreal value, QString name)
             {
                 QPieSlice* slice = new QPieSlice(value, name);
                 add(slice);
                 return slice;
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference this pointer after this call.
             */
             void QPieSeries::remove(QPieSlice* slice)
             {
                 if (!m_slices.removeOne(slice)) {
                     Q_ASSERT(0); // TODO: how should this be reported?
                     return;
                 }
                 ChangeSet changeSet;
                 changeSet.appendRemoved(slice);
                 emit changed(changeSet);
                 delete slice;
                 slice = NULL;
                 updateDerivativeData();
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 if (m_slices.count() == 0)
                     return;
                 ChangeSet changeSet;
                 foreach (QPieSlice* s, m_slices) {
                     changeSet.appendRemoved(s);
                     m_slices.removeOne(s);
                     delete s;
                 }
                 emit changed(changeSet);
                 updateDerivativeData();
             }
             /*!
                 Counts the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 return m_slices.count();
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice*> QPieSeries::slices() const
             {
                 return m_slices;
             }
             /*!
                 Sets the size \a factor of the pie. 1.0 is the default value.
                 Note that the pie will not grow beyond its absolute maximum size.
                 In practice its use is to make the pie appear smaller.
                 \sa sizeFactor()
             */
             void QPieSeries::setSizeFactor(qreal factor)
             {
                 if (factor < 0.0)
                     return;
                 if (m_sizeFactor != factor) {
                     m_sizeFactor = factor;
                     emit sizeFactorChanged();
                 }
             }
             /*!
                 Gets the size factor of the pie.
                 \sa setSizeFactor()
             */
             qreal QPieSeries::sizeFactor() const
             {
                 return m_sizeFactor;
             }
             /*!
                 Sets the \a position of the pie within its bounding rectangle.
                 \sa PiePosition, position()
             */
             void QPieSeries::setPosition(PiePosition position)
             {
                 if (m_position != position) {
                     m_position = position;
                     emit positionChanged();
                 }
             }
             /*!
                 Gets the position of the pie within its bounding rectangle.
                 \sa PiePosition, setPosition()
             */
             QPieSeries::PiePosition QPieSeries::position() const
             {
                 return m_position;
             }
             /*!
                 Sets the \a startAngle and \a angleSpan of this series.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
             */
             void QPieSeries::setSpan(qreal startAngle, qreal angleSpan)
             {
                 if (startAngle >= 0 && startAngle < 360 &&
                     angleSpan > 0 && angleSpan <= 360) {
                     m_pieStartAngle = startAngle;
                     m_pieAngleSpan = angleSpan;
                     updateDerivativeData();
                 }
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 foreach (QPieSlice* s, m_slices)
                     s->setLabelVisible(visible);
             }
             /*!
                 Convenience method for exploding a slice when user clicks the pie. Set \a enable to true to
                 explode slices by clicking.
                 \sa QPieSlice::isExploded(), QPieSlice::setExploded(), QPieSlice::setExplodeDistance()
             */
             void QPieSeries::setClickExplodes(bool enable)
             {
                 if (enable)
                     connect(this, SIGNAL(clicked(QPieSlice*)), this, SLOT(toggleExploded(QPieSlice*)));
                 else
                     disconnect(this, SLOT(toggleExploded(QPieSlice*)));
             }
             /*!
                 Convenience method for highlighting a slice when user hovers over the slice.
                 It changes the slice color to be lighter and shows the label of the slice.
                 Set \a enable to true to highlight a slice when user hovers on top of it.
-                \sa QPieSlice::isExploded(), QPieSlice::setExploded()
             */
             void QPieSeries::setHoverHighlighting(bool enable)
             {
                 if (enable) {
                     connect(this, SIGNAL(hoverEnter(QPieSlice*)), this, SLOT(highlightOn(QPieSlice*)));
                     connect(this, SIGNAL(hoverLeave(QPieSlice*)), this, SLOT(highlightOff(QPieSlice*)));
                 } else {
                     disconnect(this, SLOT(hoverEnter(QPieSlice*)));
                     disconnect(this, SLOT(hoverLeave(QPieSlice*)));
                 }
             }
             /*!
+                Returns the sum of all slice values in this series.
+                \sa QPieSlice::value(), QPieSlice::setValue()
+            */
+            qreal QPieSeries::total() const
+            {
+                return m_total;
+            }
+            /*!
                 \fn void QPieSeries::changed(const QPieSeries::ChangeSet& changeSet)
                 This signal emitted when something has changed in the series.
                 The \a changeSet contains the details of which slices have been added, changed or removed.
                 \sa QPieSeries::ChangeSet, QPieSlice::changed()
             */
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice)
                 This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
             /*!
                 \fn void QPieSeries::hoverEnter(QPieSlice* slice)
                 This signal is emitted when user has hovered over a \a slice.
                 \sa QPieSlice::hoverEnter()
             */
             /*!
                 \fn void QPieSeries::hoverLeave(QPieSlice* slice)
                 This signal is emitted when user has hovered away from a \a slice.
                 \sa QPieSlice::hoverLeave()
             */
             /*!
                 \fn void QPieSeries::sizeFactorChanged()
                 This signal is emitted when size factor has been changed.
                 \sa sizeFactor(), setSizeFactor()
             */
             /*!
                 \fn void QPieSeries::positionChanged()
                 This signal is emitted when position of the pie has been changed.
                 \sa position(), setPosition()
             */
             void QPieSeries::sliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 ChangeSet changeSet;
                 changeSet.appendChanged(slice);
                 emit changed(changeSet);
                 updateDerivativeData();
             }
             void QPieSeries::sliceClicked()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit clicked(slice);
             }
             void QPieSeries::sliceHoverEnter()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit hoverEnter(slice);
             }
             void QPieSeries::sliceHoverLeave()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit hoverLeave(slice);
             }
             void QPieSeries::toggleExploded(QPieSlice* slice)
             {
                 Q_ASSERT(slice);
                 slice->setExploded(!slice->isExploded());
             }
             void QPieSeries::highlightOn(QPieSlice* slice)
             {
                 Q_ASSERT(slice);
                 QColor c = slice->brush().color().lighter();
                 slice->setBrush(c);
-                slice->setLabelVisible(true);
             }
             void QPieSeries::highlightOff(QPieSlice* slice)
             {
                 Q_ASSERT(slice);
                 QColor c = slice->brush().color().darker(150);
                 slice->setBrush(c);
-                slice->setLabelVisible(false);
             }
             void QPieSeries::updateDerivativeData()
             {
                 m_total = 0;
                 // nothing to do?
                 if (m_slices.count() == 0)
                     return;
                 // calculate total
                 foreach (QPieSlice* s, m_slices)
                     m_total += s->value();
                 // we must have some values
-                Q_ASSERT(m_total > 0); // TODO: is this the correct way to handle this?
+                if (m_total == 0) {
+                    qDebug() << "QPieSeries::updateDerivativeData() total == 0";
+                    Q_ASSERT(m_total > 0); // TODO: is this the correct way to handle this?
+                }
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 foreach (QPieSlice* s, m_slices) {
                     bool changed = false;
                     qreal percentage = s->value() / m_total;
                     if (s->m_percentage != percentage) {
                         s->m_percentage = percentage;
                         changed = true;
                     }
                     qreal sliceSpan = m_pieAngleSpan * percentage;
                     if (s->m_angleSpan != sliceSpan) {
                         s->m_angleSpan = sliceSpan;
                         changed = true;
                     }
                     if (s->m_startAngle != sliceAngle) {
                         s->m_startAngle = sliceAngle;
                         changed = true;
                     }
                     sliceAngle += sliceSpan;
                     if (changed)
                         emit s->changed();
                 }
             }
             #include "moc_qpieseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.h +3 0

             #ifndef PIESERIES_H
             #define PIESERIES_H
             #include "qseries.h"
             #include <QObject>
             #include <QRectF>
             #include <QColor>
             #include <QPen>
             #include <QBrush>
             #include <QSignalMapper>
             class QGraphicsObject;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PiePresenter;
             class PieSlice;
             class QPieSlice;
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 enum PiePosition {
                     PiePositionMaximized = 0,
                     PiePositionTopLeft,
                     PiePositionTopRight,
                     PiePositionBottomLeft,
                     PiePositionBottomRight
                 };
                 class ChangeSet
                 {
                 public:
                     // TODO: these should not really be exposed to the public API
                     void appendAdded(QPieSlice* slice);
                     void appendAdded(QList<QPieSlice*> slices);
                     void appendChanged(QPieSlice* slice);
                     void appendRemoved(QPieSlice* slice);
                     QList<QPieSlice*> added() const;
                     QList<QPieSlice*> changed() const;
                     QList<QPieSlice*> removed() const;
                     bool isEmpty() const;
                 private:
                     QList<QPieSlice*> m_added;
                     QList<QPieSlice*> m_changed;
                     QList<QPieSlice*> m_removed;
                 };
             public:
                 QPieSeries(QObject *parent = 0);
                 virtual ~QPieSeries();
             public: // from QChartSeries
                 QSeriesType type() const;
             public:
                 void replace(QList<QPieSlice*> slices);
                 void add(QList<QPieSlice*> slices);
                 void add(QPieSlice* slice);
                 QPieSlice* add(qreal value, QString name);
+                QPieSeries& operator << (QPieSlice* slice);
                 void remove(QPieSlice* slice);
                 void clear();
                 int count() const;
                 QList<QPieSlice*> slices() const;
                 void setSizeFactor(qreal sizeFactor);
                 qreal sizeFactor() const;
                 void setPosition(PiePosition position);
                 PiePosition position() const;
                 void setSpan(qreal startAngle, qreal angleSpan);
                 void setLabelsVisible(bool visible = true);
                 void setClickExplodes(bool enable = true);
                 void setHoverHighlighting(bool enable = true);
+                qreal total() const;
                 // TODO: find slices?
                 // QList<QPieSlice*> findByValue(qreal value);
                 // ...
                 // TODO: sorting slices?
                 // void sort(QPieSeries::SortByValue|label|??)
                 // TODO: general graphics customization
                 // setDrawStyle(2d|3d)
                 // setDropShadows(bool)
             Q_SIGNALS:
                 void changed(const QPieSeries::ChangeSet& changeSet);
                 void clicked(QPieSlice* slice);
                 void hoverEnter(QPieSlice* slice);
                 void hoverLeave(QPieSlice* slice);
                 void sizeFactorChanged();
                 void positionChanged();
             private Q_SLOTS: // TODO: should be private and not visible in the interface at all
                 void sliceChanged();
                 void sliceClicked();
                 void sliceHoverEnter();
                 void sliceHoverLeave();
                 void toggleExploded(QPieSlice* slice);
                 void highlightOn(QPieSlice* slice);
                 void highlightOff(QPieSlice* slice);
             private:
                 void updateDerivativeData();
             private:
                 Q_DISABLE_COPY(QPieSeries)
                 // TODO: use PIML
                 friend class PiePresenter;
                 friend class PieSlice;
                 QList<QPieSlice*> m_slices;
                 qreal m_sizeFactor;
                 PiePosition m_position;
                 qreal m_total;
                 qreal m_pieStartAngle;
                 qreal m_pieAngleSpan;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

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