HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r697:fbb57e02c5e2

Change includes in public headers from #include "xxx" -> #include <xxx>

Jani Honkonen -

r697:fbb57e02c5e2

parent child

Context file:

r697:fbb57e02c5e2

Collapse all files

src/areachart/qareaseries.h +2 -2

             #ifndef QAREASERIES_H_
             #define QAREASERIES_H_
-            #include "qchartglobal.h"
+            #include <qchartglobal.h>
-            #include "qseries.h"
+            #include <qseries.h>
             #include <QDebug>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLineSeries;
             class QTCOMMERCIALCHART_EXPORT QAreaSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 QAreaSeries(QLineSeries* upperSeries,QLineSeries* lowerSeries=0);
                 virtual ~QAreaSeries();
             public: // from QChartSeries
                 virtual QSeriesType type() const { return QSeries::SeriesTypeArea;}
                 QLineSeries* upperSeries() const { return m_upperSeries;}
                 QLineSeries* lowerSeries() const { return m_lowerSeries;}
                 void setPen(const QPen& pen);
                 QPen pen() const { return m_pen;}
                 void setBrush(const QBrush& brush);
                 QBrush brush() const { return m_brush;}
                 void setPointsVisible(bool visible);
                 bool pointsVisible() const {return m_pointsVisible;}
             //    bool setModel(QAbstractItemModel* model);
             //    void setModelMappingUpper(int modelX, int modelY, Qt::Orientation orientation = Qt::Vertical);
             //    void setModelMappingLower(int modelX, int modelY, Qt::Orientation orientation = Qt::Vertical);
             signals:
                 void updated();
                 void clicked(const QPointF& point);
             private:
                 QBrush m_brush;
                 QPen m_pen;
                 QLineSeries* m_upperSeries;
                 QLineSeries* m_lowerSeries;
                 bool m_pointsVisible;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/axis/qchartaxis.h +2 -2

             #ifndef QCHARTAXIS_H_
             #define QCHARTAXIS_H_
-            #include "qchartglobal.h"
+            #include <qchartglobal.h>
-            #include "qchartaxiscategories.h"
+            #include <qchartaxiscategories.h>
             #include <QPen>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QChartAxis : public QObject
             {
             	Q_OBJECT
             public:
                 QChartAxis(QObject* parent =0);
                 ~QChartAxis();
                 //axis handling
                 bool isAxisVisible() const { return m_axisVisible;};
                 void setAxisVisible(bool visible);
                 void setAxisPen(const QPen& pen);
                 QPen axisPen() const { return m_axisPen;};
                 //grid handling
                 bool isGridLineVisible() const { return m_gridLineVisible;};
                 void setGridLineVisible(bool visible);
                 void setGridLinePen(const QPen& pen);
                 QPen gridLinePen() const {return m_gridLinePen;}
                 //labels handling
                 bool labelsVisible() const { return m_labelsVisible;};
                 void setLabelsVisible(bool visible);
                 void setLabelsPen(const QPen& pen);
                 QPen labelsPen() const { return m_labelsPen;}
                 void setLabelsBrush(const QBrush& brush);
                 QBrush labelsBrush() const { return m_labelsBrush;}
                 void setLabelsFont(const QFont& font);
                 QFont labelsFont() const { return m_labelsFont;}
                 void setLabelsAngle(int angle);
                 int labelsAngle() const { return m_labelsAngle;};
                 //shades handling
                 bool shadesVisible() const { return m_shadesVisible;};
                 void setShadesVisible(bool visible);
                 void setShadesPen(const QPen& pen);
                 QPen shadesPen() const { return m_shadesPen;}
                 void setShadesBrush(const QBrush& brush);
                 QBrush shadesBrush() const { return m_shadesBrush;}
                 void setShadesOpacity(qreal opacity);
                 qreal shadesOpacity() const { return m_shadesOpacity;}
                 //range handling
                 void setMin(qreal min);
                 qreal min() const { return m_min;};
                 void setMax(qreal max);
                 qreal max() const { return m_max;};
                 void setRange(qreal min, qreal max);
                 //ticks handling
                 void setTicksCount(int count);
                 int ticksCount() const { return m_ticksCount;}
                 void setNiceNumbers(bool enabled);
                 bool niceNumbers() const { return m_niceNumbers;}
                 QChartAxisCategories* categories() { return &m_category; }
                 void show();
                 void hide();
             signals:
             	void minChanged(qreal min);
             	void maxChanged(qreal max);
             	void rangeChanged(qreal min, qreal max);
             	void ticksCountChanged(int count);
             //interal signal
             	void updated();
             	void changed(qreal min, qreal max, int tickCount,bool niceNumbers);
             //internal slot
             public slots:
             	void handleAxisRangeChanged(qreal min, qreal max,int count);
             private:
                 bool m_axisVisible;
                 QPen m_axisPen;
                 QBrush m_axisBrush;
                 bool m_gridLineVisible;
                 QPen m_gridLinePen;
                 bool m_labelsVisible;
                 QPen m_labelsPen;
                 QBrush m_labelsBrush;
                 QFont m_labelsFont;
                 int m_labelsAngle;
                 bool m_shadesVisible;
                 QPen m_shadesPen;
                 QBrush m_shadesBrush;
                 qreal m_shadesOpacity;
                 qreal m_min;
                 qreal m_max;
                 int m_ticksCount;
                 QChartAxisCategories m_category;
                 bool m_niceNumbers;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* QCHARTAXIS_H_ */

src/axis/qchartaxiscategories.h +1 -1

             #ifndef QCHARTAXISCATEGORIES_H_
             #define QCHARTAXISCATEGORIES_H_
-            #include "qchartglobal.h"
+            #include <qchartglobal.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QChartAxisCategories : public QObject
             {
                 Q_OBJECT
             private:
                 QChartAxisCategories();
             public:
                 ~QChartAxisCategories();
                 void insert(qreal value,QString label);
                 void remove(qreal value);
                 QString label(qreal value) const;
                 void clear();
                 int count();
             //internal signal
             signals:
                 void updated();
             private:
                 QMap<qreal,QString> m_map;
             friend class QChartAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* QCHARTAXISCATEGORIES_H_ */

src/barchart/qbarseries.h +1 -1

             #ifndef BARSERIES_H
             #define BARSERIES_H
-            #include "qseries.h"
+            #include <qseries.h>
             #include <QStringList>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSet;
             class BarChartModel;
             class BarCategory;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT QBarSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 QBarSeries(QStringList categories, QObject* parent=0);
                 virtual QSeriesType type() const { return QSeries::SeriesTypeBar; }
                 void addBarSet(QBarSet *set);               // Takes ownership of set
                 void removeBarSet(QBarSet *set);            // Releases ownership, doesn't delete set
                 void insertBarSet(int i, QBarSet *set);
                 void insertCategory(int i, QString category);
                 void removeCategory(int i);
                 int barsetCount();
                 int categoryCount();
                 QList<QBarSet*> barSets();
                 bool setModel(QAbstractItemModel* model);
                 QAbstractItemModel* modelExt() {return m_model;}
                 void setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation = Qt::Vertical);
             public:
                 // TODO: Functions below this are not part of api and will be moved
                 // to private implementation, when we start using it
                 // TODO: TO PIMPL --->
                 QBarSet* barsetAt(int index);
                 QString categoryName(int category);
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
                 qreal percentageAt(int set, int category);
                 qreal categorySum(int category);
                 qreal maxCategorySum();
                 BarChartModel& model();
                 // <--- TO PIMPL
             signals:
                 //void changed(int index);
                 void clicked(QBarSet* barset, QString category);        // Up to user of api, what to do with these signals
                 void rightClicked(QBarSet* barset, QString category);
                 //
                 void updatedBars();
                 void restructuredBar(int);
                 // TODO: internal signals, these to private implementation.
                 // TODO: TO PIMPL --->
                 void showToolTip(QPoint pos, QString tip);
                 // <--- TO PIMPL
             public Q_SLOTS:
                 void setToolTipEnabled(bool enabled=true);           // enables tooltips
                 // TODO: TO PIMPL --->
                 void barsetClicked(QString category);
                 void barsetRightClicked(QString category);
                 // <--- TO PIMPL
             private Q_SLOTS:
                 // slots for updating bars when data in model changes
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelDataAdded(QModelIndex parent, int start, int end);
                 void modelDataRemoved(QModelIndex parent, int start, int end);
                 void barsetChanged();
             protected:
                 BarChartModel* mModel;
             //    QAbstractItemModel* m_model;
                 int m_mapCategories;
                 int m_mapBarBottom;
                 int m_mapBarTop;
                 Qt::Orientation m_mapOrientation;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

src/barchart/qpercentbarseries.h +1 -1

             #ifndef PERCENTBARSERIES_H
             #define PERCENTBARSERIES_H
             #include <QStringList>
-            #include "qbarseries.h"
+            #include <qbarseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QPercentBarSeries : public QBarSeries
             {
                 Q_OBJECT
             public:
                 QPercentBarSeries(QStringList categories, QObject* parent=0);
                 virtual QSeriesType type() const { return QSeries::SeriesTypePercentBar; }
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PERCENTBARSERIES_H

src/barchart/qstackedbarseries.h +1 -1

             #ifndef STACKEDBARSERIES_H
             #define STACKEDBARSERIES_H
             #include <QStringList>
-            #include "qbarseries.h"
+            #include <qbarseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QStackedBarSeries : public QBarSeries
             {
                 Q_OBJECT
             public:
                 QStackedBarSeries(QStringList categories, QObject* parent=0);
                 virtual QSeriesType type() const { return QSeries::SeriesTypeStackedBar; }
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // STACKEDBARSERIES_H

src/linechart/qlineseries.h +2 -2

             #ifndef QLINESERIES_H_
             #define QLINESERIES_H_
-            #include "qchartglobal.h"
+            #include <qchartglobal.h>
-            #include "qxyseries.h"
+            #include <qxyseries.h>
             #include <QDebug>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QLineSeries : public QXYSeries
             {
             public:
             	QLineSeries(QObject* parent=0);
             	virtual ~QLineSeries();
             	void setLinePen(const QPen& pen);
             	QPen linePen() const {return m_pen;}
             	void setPointsVisible(bool visible);
             	bool pointsVisible() const {return m_pointsVisible;}
             public: // from QChartSeries
             	virtual QSeriesType type() const {return QSeries::SeriesTypeLine;}
                 friend QDebug operator<< (QDebug d, const QLineSeries series);
             private:
                 QPen m_pen;
                 bool m_pointsVisible;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchartview.h +4 -4

             #ifndef QCHARTWIDGET_H
             #define QCHARTWIDGET_H
-            #include "qchartglobal.h"
+            #include <qchartglobal.h>
-            #include "qchartaxis.h"
+            #include <qchartaxis.h>
-            #include "qseries.h"
+            #include <qseries.h>
-            #include "qchart.h"
+            #include <qchart.h>
             #include <QGraphicsView>
             class QGraphicsScene;
             class QRubberBand;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             class QTCOMMERCIALCHART_EXPORT QChartView : public QGraphicsView
             {
                 Q_OBJECT
             public:
                 enum  RubberBandPolicy { NoRubberBand, VerticalRubberBand, HorizonalRubberBand, RectangleRubberBand };
                 explicit QChartView(QWidget *parent = 0);
                 ~QChartView();
                 //implement from QWidget
                 void resizeEvent(QResizeEvent *event);
                 void addSeries(QSeries* series,QChartAxis* axisY=0);// takes series ownership , takes axis ownership
                 void removeSeries(QSeries* series); //returns ownership , deletes axis if no series attached
                 void removeAllSeries(); // deletes series and axis
                 void setChartTitle(const QString& title);
                 QString chartTitle() const;
                 void setChartTitleFont(const QFont& font);
                 void setChartTitleBrush(const QBrush &brush);
                 QBrush chartTitleBrush();
                 void setChartBackgroundBrush(const QBrush& brush);
                 void setChartBackgroundPen(const QPen& pen);
                 void zoomIn();
                 void zoomIn(const QRect& rect);
                 void zoomOut();
                 void scrollLeft();
                 void scrollRight();
                 void scrollUp();
                 void scrollDown();
                 void setRubberBandPolicy(const RubberBandPolicy );
                 RubberBandPolicy rubberBandPolicy() const;
                 void setChartTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme chartTheme() const;
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 QChartAxis* axisX() const;
                 QChartAxis* axisY() const;
                 QLegend* legend() const;
             protected:
                 void mousePressEvent(QMouseEvent *event);
                 void mouseMoveEvent(QMouseEvent *event);
                 void mouseReleaseEvent(QMouseEvent *event);
                 void keyPressEvent(QKeyEvent *event);
             private:
                 QGraphicsScene *m_scene;
                 QChart* m_chart;
                 QPoint m_rubberBandOrigin;
                 QRubberBand* m_rubberBand;
                 bool m_verticalRubberBand;
                 bool m_horizonalRubberBand;
                 Q_DISABLE_COPY(QChartView)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCHARTWIDGET_H

src/qlegend.h +2 -2

             #ifndef QLEGEND_H
             #define QLEGEND_H
-            #include "qchartglobal.h"
+            #include <qchartglobal.h>
-            #include "qseries.h"
+            #include <qseries.h>
             #include <QGraphicsObject>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Domain;
             class LegendMarker;
             class QPieSlice;
             class QXYSeries;
             class QBarSet;
             class QBarSeries;
             class QPieSeries;
             class QTCOMMERCIALCHART_EXPORT QLegend : public QGraphicsObject
             {
                 Q_OBJECT
             public:
                 enum PreferredLayout {
                     PreferredLayoutHorizontal,
                     PreferredLayoutVertical
                 };
                 explicit QLegend(QGraphicsItem *parent = 0);
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
                 void setBrush(const QBrush& brush);
                 QBrush brush() const;
                 void setPen(const QPen& pen);
                 QPen pen() const;
                 void setPreferredLayout(QLegend::PreferredLayout preferred);
                 QSizeF maximumSize() const;
                 void setMaximumSize(const QSizeF size);
                 void setSize(const QSizeF size);
                 void setPos(const QPointF &pos);
             signals:
                 // for interactions.
                 void clicked(QSeries* series, Qt::MouseButton button);
                 void clicked(QBarSet* barset, Qt::MouseButton button);
                 void clicked(QPieSlice* slice, Qt::MouseButton button);
             public slots:
                 void handleSeriesAdded(QSeries* series,Domain* domain);
                 void handleSeriesRemoved(QSeries* series);
                 void handleAdded(QList<QPieSlice*> slices);
                 void handleRemoved(QList<QPieSlice*> slices);
                 void handleMarkerDestroyed();
             private:
                 // PIMPL --->
                 void connectSeries(QSeries* series);
                 void disconnectSeries(QSeries* series);
                 void createMarkers(QSeries* series);
                 void appendMarkers(QXYSeries* series);      // All line series are derived from QXYSeries, so this works for now
                 void appendMarkers(QBarSeries* series);
                 void appendMarkers(QPieSeries* series);
                 void deleteMarkers(QSeries* series);
                 void layoutChanged();
                 // <--- PIMPL
                 QPointF mPos;
                 QSizeF mSize;
                 QSizeF mMinimumSize;
                 QSizeF mMaximumSize;
                 QList<LegendMarker*> mMarkers;
                 QBrush m_brush;
                 QPen m_pen;
                 QLegend::PreferredLayout mPreferredLayout;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QLEGEND_H

src/qseries.h +1 -1

             #ifndef QSERIES_H
             #define QSERIES_H
-            #include "qchartglobal.h"
+            #include <qchartglobal.h>
             #include <QObject>
             #include <QAbstractItemModel>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QSeries : public QObject
             {
                 Q_OBJECT
             public:
                 enum QSeriesType {
                     SeriesTypeLine,
                     SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypeStackedBar,
                     SeriesTypePercentBar,
                     SeriesTypePie,
                     SeriesTypeScatter,
                     SeriesTypeSpline
                 };
             protected:
                 QSeries(QObject *parent = 0) : QObject(parent) {m_model = NULL;}
             public:
                 virtual ~QSeries() {}
                 virtual QSeriesType type() const = 0;
                 QString name() { return QString("TODO: Name QSeries"); }
                 // TODO
                 virtual bool setModel(QAbstractItemModel* /*model*/) { return false; }
                 void setTitle(QString title) { m_title = title; }
                 QString title() { return m_title; }
             protected:
                 QAbstractItemModel* m_model;
             private:
                 QString m_title;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/scatterseries/qscatterseries.h +2 -2

             #ifndef QSCATTERSERIES_H
             #define QSCATTERSERIES_H
-            #include "qchartglobal.h"
+            #include <qchartglobal.h>
-            #include "qxyseries.h"
+            #include <qxyseries.h>
             #include <QRectF>
             #include <QColor>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QScatterSeries : public QXYSeries
             {
             public:
                 enum MarkerShape {
                     MarkerShapeCircle,
                     MarkerShapeRectangle
                 };
             public:
                 QScatterSeries(QObject *parent = 0);
                 ~QScatterSeries();
             public: // from QChartSeries
                 QSeriesType type() const { return QSeries::SeriesTypeScatter; }
             public:
                 MarkerShape shape() const;
                 void setShape(MarkerShape shape);
                 qreal size() const;
                 void setSize(qreal size);
             private:
                 MarkerShape m_shape;
                 qreal m_size;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIES_H

src/splinechart/qsplineseries.h +2 -2

             #ifndef QSPLINESERIES_H
             #define QSPLINESERIES_H
-            #include "qchartglobal.h"
+            #include <qchartglobal.h>
             #include <QtGlobal>
-            #include "qlineseries.h"
+            #include <qlineseries.h>
             #include <QList>
             #include <QPointF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QSplineSeries : public QLineSeries
             {
                 Q_OBJECT
             public:
                 QSplineSeries(QObject *parent = 0);
                 QSeriesType type() const {return QSeries::SeriesTypeSpline;}
             //    int count() const { return m_x.size(); }
                 QPointF controlPoint(int index) const {return m_controlPoints[index];}
                 bool setModel(QAbstractItemModel* model);
                 void setModelMapping(int modelX, int modelY, Qt::Orientation orientation = Qt::Vertical);
                 // TODO: allow the user to set custom control points
             //    void setCustomControlPoints(QList<QPointsF> controlPoints);
             //    bool calculateControlPointsAutomatically();
             //    void setCalculateControlPointsAutomatically();
             private:
                 void calculateControlPoints();
                 QList<qreal> getFirstControlPoints(QList<qreal> rhs);
             private slots:
                 void updateControlPoints();
             private:
                 QList<QPointF> m_controlPoints;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSPLINESERIES_H

src/xychart/qxyseries.h +2 -2

             #ifndef QXYSERIES_H_
             #define QXYSERIES_H_
-            #include "qchartglobal.h"
+            #include <qchartglobal.h>
-            #include "qseries.h"
+            #include <qseries.h>
             #include <QDebug>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QXYSeries : public QSeries
             {
                 Q_OBJECT
             protected:
                 QXYSeries(QObject* parent=0);
                 virtual ~QXYSeries();
             public:
                 void add(qreal x, qreal y);
                 void add(const QPointF& point);
                 void add(const QList<QPointF> points);
                 void replace(qreal x,qreal y);
                 void replace(const QPointF& point);
                 void remove(qreal x);
                 void remove(qreal x, qreal y);
                 void remove(const QPointF& point);
                 void removeAll();
                 int count() const;
                 qreal x(int pos) const;
                 qreal y(int pos) const;
                 QList<QPointF> data();
                 QXYSeries& operator << (const QPointF &point);
                 QXYSeries& operator << (const QList<QPointF> points);
                 void setPen(const QPen& pen);
                 QPen pen() const {return m_pen;}
                 void setBrush(const QBrush& pen);
                 QBrush brush() const {return m_brush;}
                 bool setModel(QAbstractItemModel* model);
                 QAbstractItemModel* model() {return m_model;}
                 virtual void setModelMapping(int modelX, int modelY, Qt::Orientation orientation = Qt::Vertical);
             //    void setModelMappingY(int modelLineIndex, Qt::Orientation orientation = Qt::Vertical);
                 private slots:
                     void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                     void modelDataAdded(QModelIndex parent, int start, int end);
                     void modelDataRemoved(QModelIndex parent, int start, int end);
             signals:
                 void clicked(const QPointF& point);
                 void updated();
                 void pointReplaced(int index);
                 void pointRemoved(int index);
                 void pointAdded(int index);
             protected:
                 QVector<qreal> m_x;
                 QVector<qreal> m_y;
                 QPen m_pen;
                 QBrush m_brush;
             //    QAbstractItemModel* m_model;
                 int m_mapX;
                 Qt::Orientation m_mapOrientation;
                 int m_mapY;
             //    Qt::Orientation m_mapYOrientation;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

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