HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r737:e81beeb51921

Code review: Fixed simple issues in Bar and Legend

Tero Ahola -

r737:e81beeb51921

parent child

Context file:

r737:e81beeb51921

Collapse all files

src/barchart/bar.cpp +5 -4

                 : QGraphicsRectItem(parent),
                 mCategory(category)
             {
-                setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
+                setAcceptedMouseButtons(Qt::LeftButton | Qt::RightButton);
                 setAcceptHoverEvents(true);
             }
-            void Bar::mousePressEvent(QGraphicsSceneMouseEvent* event)
+            void Bar::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 if (event->button() == Qt::LeftButton) {
                     emit clicked(mCategory);
                 }
             }
-            void Bar::hoverEnterEvent(QGraphicsSceneHoverEvent* event)
+            void Bar::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit hoverEntered(event->lastScreenPos());
             }
-            void Bar::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
+            void Bar::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
+                Q_UNUSED(event)
                 emit hoverLeaved();
             }

src/barchart/bar_p.h +1 -1

             {
                 Q_OBJECT
             public:
-                Bar(QString category, QGraphicsItem *parent=0);
+                Bar(QString category, QGraphicsItem *parent = 0);
             public:
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);

src/barchart/barchartitem.cpp +29 -31

                 mLayoutSet(false),
                 mSeries(series)
             {
-                connect(series,SIGNAL(showToolTip(QPoint,QString)),this,SLOT(showToolTip(QPoint,QString)));
+                connect(series, SIGNAL(showToolTip(QPoint,QString)), this, SLOT(showToolTip(QPoint,QString)));
                 connect(series, SIGNAL(updatedBars()), this, SLOT(handleLayoutChanged()));
             //TODO:  connect(series,SIGNAL("position or size has changed"), this, SLOT(handleLayoutChanged()));
                 connect(series, SIGNAL(restructuredBar(int)), this, SLOT(handleModelChanged(int)));
                     qDebug() << "BarChartItem::paint called without layout set. Aborting.";
                     return;
                 }
-                foreach(QGraphicsItem* i, childItems()) {
+                foreach(QGraphicsItem* i, childItems())
                     i->paint(painter,option,widget);
             }
             QRectF BarChartItem::boundingRect() const
             {
                 // TODO: performance optimizations. Do we really need to delete and create items every time data is changed or can we reuse them?
                 // Delete old bars
-                foreach (QGraphicsItem* item, childItems()) {
+                foreach (QGraphicsItem *item, childItems())
                     delete item;
                 mBars.clear();
                 mFloatingValues.clear();
                 mLayout.clear();
                 // Create new graphic items for bars
-                for (int c=0; c<mSeries->categoryCount(); c++) {
+                for (int c = 0; c < mSeries->categoryCount(); c++) {
                     QString category = mSeries->categoryName(c);
-                    for (int s=0; s<mSeries->barsetCount(); s++) {
+                    for (int s = 0; s < mSeries->barsetCount(); s++) {
                         QBarSet *set = mSeries->barsetAt(s);
                         Bar *bar = new Bar(category,this);
                         childItems().append(bar);
                         mBars.append(bar);
-                        connect(bar,SIGNAL(clicked(QString)),set,SIGNAL(clicked(QString)));
+                        connect(bar, SIGNAL(clicked(QString)), set, SIGNAL(clicked(QString)));
-                        connect(bar,SIGNAL(rightClicked(QString)),set,SIGNAL(rightClicked(QString)));
+                        connect(bar, SIGNAL(rightClicked(QString)), set, SIGNAL(rightClicked(QString)));
-                        connect(bar,SIGNAL(hoverEntered(QPoint)),set,SLOT(barHoverEnterEvent(QPoint)));
+                        connect(bar, SIGNAL(hoverEntered(QPoint)), set, SLOT(barHoverEnterEvent(QPoint)));
-                        connect(bar,SIGNAL(hoverLeaved()),set,SLOT(barHoverLeaveEvent()));
+                        connect(bar, SIGNAL(hoverLeaved()), set, SLOT(barHoverLeaveEvent()));
-                        mLayout.append(QRectF(0,0,0,0));
+                        mLayout.append(QRectF(0, 0, 0, 0));
                     }
                 }
                 // Create floating values
-                for (int category=0; category<mSeries->categoryCount(); category++) {
+                for (int category = 0; category < mSeries->categoryCount(); category++) {
-                    for (int s=0; s<mSeries->barsetCount(); s++) {
+                    for (int s = 0; s < mSeries->barsetCount(); s++) {
                         QBarSet *set = mSeries->barsetAt(s);
                         BarValue *value = new BarValue(*set, this);
                         childItems().append(value);
                         mFloatingValues.append(value);
-                        connect(set,SIGNAL(toggleFloatingValues()),value,SLOT(toggleVisible()));
+                        connect(set, SIGNAL(toggleFloatingValues()), value, SLOT(toggleVisible()));
                     }
                 }
             }
                     max = mDomainMaxY;
                 }
-                qreal scale = (height/max);
+                qreal scale = (height / max);
-                qreal categoryWidth = width/categoryCount;
+                qreal categoryWidth = width / categoryCount;
                 qreal barWidth = categoryWidth / (setCount+1);
                 int itemIndex(0);
-                for (int category=0; category < categoryCount; category++) {
+                for (int category = 0; category < categoryCount; category++) {
-                    qreal xPos = categoryWidth * category + barWidth/2;
+                    qreal xPos = categoryWidth * category + barWidth / 2;
                     qreal yPos = height;
                     for (int set = 0; set < setCount; set++) {
-                        qreal barHeight = mSeries->valueAt(set,category) * scale;
+                        qreal barHeight = mSeries->valueAt(set, category) * scale;
                         Bar* bar = mBars.at(itemIndex);
-                        QRectF rect(xPos,yPos-barHeight,barWidth,barHeight);
+                        QRectF rect(xPos, yPos - barHeight, barWidth, barHeight);
                         layout.append(rect);
                         bar->setPen(mSeries->barsetAt(set)->pen());
                         bar->setBrush(mSeries->barsetAt(set)->brush());
                 // Position floating values
                 itemIndex = 0;
-                for (int category=0; category < mSeries->categoryCount(); category++) {
+                for (int category = 0; category < mSeries->categoryCount(); category++) {
                     qreal xPos = categoryWidth * category  + barWidth;
                     qreal yPos = height;
                     for (int set=0; set < mSeries->barsetCount(); set++) {
-                        qreal barHeight = mSeries->valueAt(set,category) * scale;
+                        qreal barHeight = mSeries->valueAt(set, category) * scale;
                         BarValue* value = mFloatingValues.at(itemIndex);
                         QBarSet* barSet = mSeries->barsetAt(set);
-                        value->resize(100,50);  // TODO: proper layout for this.
+                        value->resize(100, 50);  // TODO: proper layout for this.
-                        value->setPos(xPos, yPos-barHeight/2);
+                        value->setPos(xPos, yPos-barHeight / 2);
                         value->setPen(barSet->floatingValuePen());
                         if (mSeries->valueAt(set,category) != 0) {
-                            value->setValueString(QString::number(mSeries->valueAt(set,category)));
+                            value->setValueString(QString::number(mSeries->valueAt(set, category)));
                         } else {
                             value->setValueString(QString(""));
                         }
             {
                 mLayout = layout;
-                for (int i=0; i<mBars.count(); i++) {
+                for (int i=0; i < mBars.count(); i++)
                     mBars.at(i)->setRect(layout.at(i));
                 update();
             }
                 handleLayoutChanged();
             }
-            void BarChartItem::handleGeometryChanged(const QRectF& rect)
+            void BarChartItem::handleGeometryChanged(const QRectF &rect)
             {
-                m_rect=rect;
+                m_rect = rect;
                 handleLayoutChanged();
                 mLayoutSet = true;
                 setPos(rect.topLeft());
             void BarChartItem::showToolTip(QPoint pos, QString tip)
             {
                 // TODO: cool tooltip instead of default
-                QToolTip::showText(pos,tip);
+                QToolTip::showText(pos, tip);
             }
             #include "moc_barchartitem_p.cpp"

src/barchart/barchartitem_p.h +4 -4

             public slots:
                 void handleModelChanged(int index);
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
-                void handleGeometryChanged(const QRectF& size);
+                void handleGeometryChanged(const QRectF &size);
                 void handleLayoutChanged();
                 // Internal slots
                 QVector<QRectF> mLayout;
                 // Not owned.
-                QBarSeries* mSeries;
+                QBarSeries *mSeries;
-                QList<Bar*> mBars;
+                QList<Bar *> mBars;
-                QList<BarValue*> mFloatingValues;
+                QList<BarValue *> mFloatingValues;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartmodel.cpp +10 -15

                 // This is slower since they are checked every time, even if data is same since previous call.
                 qreal min = INT_MAX;
-                for (int i=0; i <mDataModel.count(); i++) {
+                for (int i = 0; i < mDataModel.count(); i++) {
                     int itemCount = mDataModel.at(i)->count();
-                    for (int j=0; j<itemCount; j++) {
+                    for (int j = 0; j < itemCount; j++) {
                         qreal temp = mDataModel.at(i)->valueAt(j);
-                        if (temp < min) {
+                        if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
                 // This is slower since they are checked every time, even if data is same since previous call.
                 qreal max = INT_MIN;
-                for (int i=0; i <mDataModel.count(); i++) {
+                for (int i = 0; i < mDataModel.count(); i++) {
                     int itemCount = mDataModel.at(i)->count();
-                    for (int j=0; j<itemCount; j++) {
+                    for (int j = 0; j < itemCount; j++) {
                         qreal temp = mDataModel.at(i)->valueAt(j);
-                        if (temp > max) {
+                        if (temp > max)
                             max = temp;
                     }
                 }
                 qreal value = mDataModel.at(set)->valueAt(category);
                 qreal total = categorySum(category);
-                if (0 == total) {
+                if (0 == total)
                     return 100.0;
                 return value / total;
             }
                 int count = mDataModel.count(); // Count sets
                 for (int set = 0; set < count; set++) {
-                    if (category < mDataModel.at(set)->count()) {
+                    if (category < mDataModel.at(set)->count())
                         sum += mDataModel.at(set)->valueAt(category);
                 }
                 return sum;
             }
                 qreal max = INT_MIN;
                 int count = categoryCount();
-                for (int col=0; col<count; col++) {
+                for (int col = 0; col < count; col++) {
                     qreal sum = categorySum(col);
-                    if (sum > max) {
+                    if (sum > max)
                         max = sum;
                 }
                 return max;
             }

src/barchart/barchartmodel_p.h +2 -4

                 void insertCategory(int i, QString category);
                 void removeCategory(int i);
                 QBarSet *setAt(int index);
-                QList<QBarSet*> barSets();
+                QList<QBarSet *> barSets();
                 int barsetCount();          // Number of sets in model
                 int categoryCount();        // Number of categories
             private:
-                QList<QBarSet*> mDataModel;
+                QList<QBarSet *> mDataModel;
                 QStringList mCategory;
                 int mCurrentSet;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barvalue.cpp +1 -1

                 if (isVisible()) {
                     painter->setPen(mPen);
-                    painter->drawText(boundingRect(),mValueString);
+                    painter->drawText(boundingRect(), mValueString);
                 }
             }

src/barchart/barvalue_p.h +1 -1

             private:
-                QBarSet& mBarSet;
+                QBarSet &mBarSet;
                 QPen mPen;
                 QString mValueString;

src/barchart/percentbarchartitem.cpp +7 -7

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            PercentBarChartItem::PercentBarChartItem(QBarSeries *series, ChartPresenter* presenter) :
+            PercentBarChartItem::PercentBarChartItem(QBarSeries *series, ChartPresenter *presenter) :
                 BarChartItem(series, presenter)
             {
             }
                 qreal categoryCount = mSeries->categoryCount();
                 qreal barWidth = width / (mSeries->categoryCount() * 2);
-                qreal xStep = width/categoryCount;
+                qreal xStep = width / categoryCount;
-                qreal xPos =  xStep/2 - barWidth / 2;
+                qreal xPos =  xStep / 2 - barWidth / 2;
                 int itemIndex(0);
-                for (int category = 0; category < categoryCount ; category++) {
+                for (int category = 0; category < categoryCount; category++) {
                     qreal colSum = mSeries->categorySum(category);
                     qreal scale = (height / colSum);
                     qreal yPos = height;
                         Bar* bar = mBars.at(itemIndex);
                         bar->setPen(mSeries->barsetAt(set)->pen());
                         bar->setBrush(mSeries->barsetAt(set)->brush());
-                        QRectF rect(xPos, yPos-barHeight,barWidth, barHeight);
+                        QRectF rect(xPos, yPos-barHeight, barWidth, barHeight);
                         layout.append(rect);
                         itemIndex++;
                         yPos -= barHeight;
                         BarValue* value = mFloatingValues.at(itemIndex);
                         QBarSet* barSet = mSeries->barsetAt(set);
-                        value->resize(100,50);  // TODO: proper layout for this.
+                        value->resize(100, 50);  // TODO: proper layout for this.
-                        value->setPos(xPos, yPos-barHeight/2);
+                        value->setPos(xPos, yPos-barHeight / 2);
                         value->setPen(barSet->floatingValuePen());
                         if (mSeries->valueAt(set,category) != 0) {

src/barchart/qbarseries.cpp +38 -41

             void QBarSeries::addBarSet(QBarSet *set)
             {
                 mModel->addBarSet(set);
-                connect(set,SIGNAL(clicked(QString)),this,SLOT(barsetClicked(QString)));
+                connect(set, SIGNAL(clicked(QString)), this, SLOT(barsetClicked(QString)));
-                connect(set,SIGNAL(rightClicked(QString)),this,SLOT(barsetRightClicked(QString)));
+                connect(set, SIGNAL(rightClicked(QString)), this, SLOT(barsetRightClicked(QString)));
                 connect(set, SIGNAL(valueChanged()), this, SLOT(barsetChanged()));
                 emit updatedBars();
             }
             */
             void QBarSeries::removeBarSet(QBarSet *set)
             {
-                disconnect(set,SIGNAL(clicked(QString)),this,SLOT(barsetClicked(QString)));
+                disconnect(set, SIGNAL(clicked(QString)), this, SLOT(barsetClicked(QString)));
-                disconnect(set,SIGNAL(rightClicked(QString)),this,SLOT(barsetRightClicked(QString)));
+                disconnect(set, SIGNAL(rightClicked(QString)), this, SLOT(barsetRightClicked(QString)));
                 mModel->removeBarSet(set);
                 emit updatedBars();
             }
                 if (enabled) {
                     for (int i=0; i<mModel->barsetCount(); i++) {
                         QBarSet *set = mModel->setAt(i);
-                        connect(set,SIGNAL(showToolTip(QPoint,QString)),this,SIGNAL(showToolTip(QPoint,QString)));
+                        connect(set, SIGNAL(showToolTip(QPoint,QString)), this, SIGNAL(showToolTip(QPoint,QString)));
                     }
                 } else {
                     for (int i=0; i<mModel->barsetCount(); i++) {
                         QBarSet *set = mModel->setAt(i);
-                        disconnect(set,SIGNAL(showToolTip(QPoint,QString)),this,SIGNAL(showToolTip(QPoint,QString)));
+                        disconnect(set, SIGNAL(showToolTip(QPoint,QString)), this, SIGNAL(showToolTip(QPoint,QString)));
                     }
                 }
             }
             */
             qreal QBarSeries::valueAt(int set, int category)
             {
-                return mModel->valueAt(set,category);
+                return mModel->valueAt(set, category);
             }
             /*!
             */
             qreal QBarSeries::percentageAt(int set, int category)
             {
-                return mModel->percentageAt(set,category);
+                return mModel->percentageAt(set, category);
             }
             /*!
                 return *mModel;
             }
-            bool QBarSeries::setModel(QAbstractItemModel* model)
+            bool QBarSeries::setModel(QAbstractItemModel *model)
             {
                 // disconnect signals from old model
                 if(m_model)
             {
                 if (m_model == NULL)
                     return;
                 m_mapCategories = categories;
                 m_mapBarBottom = bottomBoundry;
                 m_mapBarTop = topBoundry;
                 m_mapOrientation = orientation;
                 // connect the signals
-                if (m_mapOrientation == Qt::Vertical)
+                if (m_mapOrientation == Qt::Vertical) {
                     m_mapCount = m_model->rowCount() - m_mapFirst;
-                    connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
+                    connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)),
-                    connect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
+                            this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
-                    connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
+                    connect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)),
+                            this, SLOT(modelDataAdded(QModelIndex,int,int)));
-                else
+                    connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)),
+                            this, SLOT(modelDataRemoved(QModelIndex,int,int)));
+                } else {
                     m_mapCount = m_model->columnCount() - m_mapFirst;
-                    connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
+                    connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)),
-                    connect(m_model,SIGNAL(columnsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
+                            this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
-                    connect(m_model, SIGNAL(columnsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
+                    connect(m_model,SIGNAL(columnsInserted(QModelIndex, int, int)),
+                            this, SLOT(modelDataAdded(QModelIndex,int,int)));
+                    connect(m_model, SIGNAL(columnsRemoved(QModelIndex, int, int)),
+                            this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 }
                 // create the initial bars
                 delete mModel;
-                if (m_mapOrientation == Qt::Vertical)
+                if (m_mapOrientation == Qt::Vertical) {
                     QStringList categories;
                     for (int k = m_mapFirst; k < m_mapFirst + m_mapCount; k++)
                         categories << m_model->data(m_model->index(k, m_mapCategories), Qt::DisplayRole).toString();
                     mModel = new BarChartModel(categories, this);
-                    for (int i = m_mapBarBottom; i <= m_mapBarTop; i++)
+                    for (int i = m_mapBarBottom; i <= m_mapBarTop; i++) {
                         QBarSet* barSet = new QBarSet(QString("Column: %1").arg(i + 1));
                         for(int m = m_mapFirst; m < m_mapFirst + m_mapCount; m++)
                             *barSet << m_model->data(m_model->index(m, i), Qt::DisplayRole).toDouble();
                         addBarSet(barSet);
                     }
+                } else {
-                else
                     QStringList categories;
                     for (int k = m_mapFirst; k < m_mapFirst + m_mapCount; k++)
                         categories << m_model->data(m_model->index(m_mapCategories, k), Qt::DisplayRole).toString();
                     mModel = new BarChartModel(categories, this);
-                    for (int i = m_mapBarBottom; i <= m_mapBarTop; i++)
+                    for (int i = m_mapBarBottom; i <= m_mapBarTop; i++) {
                         QBarSet* barSet = new QBarSet(QString("Row: %1").arg(i + 1));
                         for(int m = m_mapFirst; m < m_mapFirst + m_mapCount; m++)
                             *barSet << m_model->data(m_model->index(i, m), Qt::DisplayRole).toDouble();
             void QBarSeries::modelDataAdded(QModelIndex /*parent*/, int start, int /*end*/)
             {
-                if (m_mapOrientation == Qt::Vertical)
+                if (m_mapOrientation == Qt::Vertical) {
                     insertCategory(start - m_mapFirst, QString("Row: %1").arg(start + 1));
-                    for (int i = 0; i <= m_mapBarTop - m_mapBarBottom; i++)
+                    for (int i = 0; i <= m_mapBarTop - m_mapBarBottom; i++) {
                         barsetAt(i)->insertValue(start - m_mapFirst, m_model->data(m_model->index(start, i), Qt::DisplayRole).toDouble());
                     }
+                } else {
-                else
                     insertCategory(start - m_mapFirst, QString("Column: %1").arg(start + 1));
-                    for (int i = 0; i <= m_mapBarTop - m_mapBarBottom; i++)
+                    for (int i = 0; i <= m_mapBarTop - m_mapBarBottom; i++) {
                         barsetAt(i)->insertValue(start - m_mapFirst, m_model->data(m_model->index(i, start), Qt::DisplayRole).toDouble());
                     }
                 }
                 emit restructuredBar(1);
             }
-            void QBarSeries::modelDataRemoved(QModelIndex /*parent*/, int start, int /*end*/)
+            void QBarSeries::modelDataRemoved(QModelIndex parent, int start, int end)
             {
+                Q_UNUSED(parent)
+                Q_UNUSED(end)
                 removeCategory(start - m_mapFirst);
                 for (int i = 0; i <= m_mapBarTop - m_mapBarBottom; i++)
                 {
             {
                 QBarCategories categories;
                 int count = mModel->categoryCount();
-                for (int i=1; i<=count; i++) {
+                for (int i=1; i <= count; i++) {
-                      categories.insert(i, mModel->categoryName(i-1));
+                      categories.insert(i, mModel->categoryName(i - 1));
                 }
                 return categories;
             }

src/barchart/qbarseries.h +7 -8

             {
                 Q_OBJECT
             public:
-                QBarSeries(QStringList categories, QObject* parent=0);
+                QBarSeries(QStringList categories, QObject *parent = 0);
                 virtual QSeriesType type() const { return QSeries::SeriesTypeBar; }
                 QList<QBarSet*> barSets();
                 QBarCategories categories() const;
+                bool setModel(QAbstractItemModel *model);
-                bool setModel(QAbstractItemModel* model);
+                QAbstractItemModel *modelExt() { return m_model; }
-                QAbstractItemModel* modelExt() {return m_model;}
                 void setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation = Qt::Vertical);
                 void setModelMappingShift(int first, int count);
             signals:
                 //void changed(int index);
-                void clicked(QBarSet* barset, QString category);        // Up to user of api, what to do with these signals
+                void clicked(QBarSet *barset, QString category);        // Up to user of api, what to do with these signals
-                void rightClicked(QBarSet* barset, QString category);
+                void rightClicked(QBarSet *barset, QString category);
                 //
                 void updatedBars();
                 // <--- TO PIMPL
             public Q_SLOTS:
-                void setToolTipEnabled(bool enabled=true);           // enables tooltips
+                void setToolTipEnabled(bool enabled = true);           // enables tooltips
                 // TODO: TO PIMPL --->
                 void barsetClicked(QString category);
                 void barsetChanged();
             protected:
-                BarChartModel* mModel;
+                BarChartModel *mModel;
             //    QAbstractItemModel* m_model;
                 int m_mapCategories;

src/barchart/qbarset.cpp +2 -1

             qreal QBarSet::total()
             {
                 qreal total(0);
-                for (int i=0; i<mValues.count(); i++) {
+                for (int i=0; i < mValues.count(); i++) {
                     total += mValues.at(i);
                 }
                 return total;
             }
             #include "moc_qbarset.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.h +1 -1

                 QString mName;
                 QList<qreal> mValues;   // TODO: replace with map (category, value)
-                QMap<QString,qreal> mMappedValues;
+                QMap<QString, qreal> mMappedValues;
                 QPen mPen;
                 QBrush mBrush;
                 QPen mFloatingValuePen;

src/barchart/qpercentbarseries.h +1 -3

             {
                 Q_OBJECT
             public:
-                QPercentBarSeries(QStringList categories, QObject* parent=0);
+                QPercentBarSeries(QStringList categories, QObject *parent = 0);
                 virtual QSeriesType type() const { return QSeries::SeriesTypePercentBar; }
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PERCENTBARSERIES_H

src/barchart/qstackedbarseries.h +1 -2

             {
                 Q_OBJECT
             public:
-                QStackedBarSeries(QStringList categories, QObject* parent=0);
+                QStackedBarSeries(QStringList categories, QObject *parent = 0);
                 virtual QSeriesType type() const { return QSeries::SeriesTypeStackedBar; }
             };

src/barchart/stackedbarchartitem.cpp +9 -10

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             StackedBarChartItem::StackedBarChartItem(QBarSeries *series, ChartPresenter *presenter) :
-                BarChartItem(series,presenter)
+                BarChartItem(series, presenter)
             {
             }
             {
             }
             QVector<QRectF> StackedBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 qreal width = geometry().width();
                 qreal scale = (height /  mSeries->maxCategorySum());
                 qreal categotyCount = mSeries->categoryCount();
-                qreal barWidth = width / (categotyCount *2);
+                qreal barWidth = width / (categotyCount * 2);
-                qreal xStep = width/categotyCount;
+                qreal xStep = width / categotyCount;
-                qreal xPos = xStep/2 - barWidth/2;
+                qreal xPos = xStep / 2 - barWidth / 2;
                 int itemIndex(0);
                 for (int category = 0; category < categotyCount; category++) {
                         Bar* bar = mBars.at(itemIndex);
                         bar->setPen(mSeries->barsetAt(set)->pen());
                         bar->setBrush(mSeries->barsetAt(set)->brush());
-                        QRectF rect(xPos,yPos-barHeight,barWidth,barHeight);
+                        QRectF rect(xPos, yPos-barHeight, barWidth, barHeight);
                         layout.append(rect);
                         itemIndex++;
                         yPos -= barHeight;
                 for (int category=0; category < mSeries->categoryCount(); category++) {
                     qreal yPos = height;
                     for (int set=0; set < mSeries->barsetCount(); set++) {
-                        qreal barHeight = mSeries->valueAt(set,category) * scale;
+                        qreal barHeight = mSeries->valueAt(set, category) * scale;
                         BarValue* value = mFloatingValues.at(itemIndex);
                         QBarSet* barSet = mSeries->barsetAt(set);
-                        value->resize(100,50);  // TODO: proper layout for this.
+                        value->resize(100, 50);  // TODO: proper layout for this.
-                        value->setPos(xPos, yPos-barHeight/2);
+                        value->setPos(xPos, yPos-barHeight / 2);
                         value->setPen(barSet->floatingValuePen());
-                        if (mSeries->valueAt(set,category) != 0) {
+                        if (mSeries->valueAt(set, category) != 0) {
                             value->setValueString(QString::number(mSeries->valueAt(set,category)));
                         } else {
                             value->setValueString(QString(""));

src/qlegend.cpp +69 -65

                 mScrollButtonUp = new LegendScrollButton(LegendScrollButton::ScrollButtonIdUp, this);
                 mScrollButtonDown = new LegendScrollButton(LegendScrollButton::ScrollButtonIdDown, this);
-                connect(mScrollButtonLeft,SIGNAL(clicked(QGraphicsSceneMouseEvent*)),this,SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
+                connect(mScrollButtonLeft, SIGNAL(clicked(QGraphicsSceneMouseEvent*)),
-                connect(mScrollButtonRight,SIGNAL(clicked(QGraphicsSceneMouseEvent*)),this,SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
+                        this, SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
-                connect(mScrollButtonUp,SIGNAL(clicked(QGraphicsSceneMouseEvent*)),this,SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
+                connect(mScrollButtonRight, SIGNAL(clicked(QGraphicsSceneMouseEvent*)),
-                connect(mScrollButtonDown,SIGNAL(clicked(QGraphicsSceneMouseEvent*)),this,SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
+                        this, SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
+                connect(mScrollButtonUp, SIGNAL(clicked(QGraphicsSceneMouseEvent*)),
+                        this, SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
+                connect(mScrollButtonDown, SIGNAL(clicked(QGraphicsSceneMouseEvent*)),
+                        this, SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
                 setZValue(ChartPresenter::LegendZValue);
             }
             /*!
                 Sets the \a brush of legend. Brush affects the background of legend.
             */
-            void QLegend::setBrush(const QBrush& brush)
+            void QLegend::setBrush(const QBrush &brush)
             {
-                if(m_brush!=brush){
+                if (m_brush != brush) {
                     m_brush = brush;
                     update();
                 }
             /*!
                 Sets the \a pen of legend. Pen affects the legend borders.
             */
-            void QLegend::setPen(const QPen& pen)
+            void QLegend::setPen(const QPen &pen)
             {
-                if(m_pen!=pen){
+                if (m_pen != pen) {
                     m_pen = pen;
                     update();
                 }
             /*!
                 \internal \a series \a domain Should be called when series is added to chart.
             */
-            void QLegend::handleSeriesAdded(QSeries* series, Domain* domain)
+            void QLegend::handleSeriesAdded(QSeries *series, Domain *domain)
             {
                 Q_UNUSED(domain)
             /*!
                 \internal \a series Should be called when series is removed from chart.
             */
-            void QLegend::handleSeriesRemoved(QSeries* series)
+            void QLegend::handleSeriesRemoved(QSeries *series)
             {
                 disconnectSeries(series);
                 if (series->type() == QSeries::SeriesTypeArea)
                 {
                     // This is special case. Area series has upper and lower series, which each have markers
-                    QAreaSeries* s = static_cast<QAreaSeries*> (series);
+                    QAreaSeries* s = static_cast<QAreaSeries *> (series);
                     deleteMarkers(s->upperSeries());
                     deleteMarkers(s->lowerSeries());
                 } else {
             /*!
                 \internal \a slices Should be called when slices are added to pie chart.
             */
-            void QLegend::handleAdded(QList<QPieSlice*> slices)
+            void QLegend::handleAdded(QList<QPieSlice *> slices)
             {
-                QPieSeries* series = static_cast<QPieSeries*> (sender());
+                QPieSeries* series = static_cast<QPieSeries *> (sender());
                 foreach(QPieSlice* s, slices) {
-                    LegendMarker* marker = new LegendMarker(series,s,this);
+                    LegendMarker* marker = new LegendMarker(series, s, this);
                     marker->setName(s->label());
                     marker->setBrush(s->sliceBrush());
-                    connect(marker,SIGNAL(clicked(QPieSlice*,Qt::MouseButton)),this,SIGNAL(clicked(QPieSlice*,Qt::MouseButton)));
+                    connect(marker, SIGNAL(clicked(QPieSlice*,Qt::MouseButton)),
-                    connect(s,SIGNAL(changed()),marker,SLOT(changed()));
+                            this, SIGNAL(clicked(QPieSlice*,Qt::MouseButton)));
-                    connect(s,SIGNAL(destroyed()),marker,SLOT(deleteLater()));
+                    connect(s, SIGNAL(changed()), marker, SLOT(changed()));
-                    connect(marker,SIGNAL(destroyed()),this,SLOT(handleMarkerDestroyed()));
+                    connect(s, SIGNAL(destroyed()), marker, SLOT(deleteLater()));
+                    connect(marker, SIGNAL(destroyed()), this, SLOT(handleMarkerDestroyed()));
                     mMarkers.append(marker);
                     childItems().append(marker);
                 }
             void QLegend::handleMarkerDestroyed()
             {
                 // TODO: what if more than one markers are destroyed and we update layout after first one?
-                LegendMarker* m = static_cast<LegendMarker*> (sender());
+                LegendMarker* m = static_cast<LegendMarker *> (sender());
                 mMarkers.removeOne(m);
                 updateLayout();
             }
             {
                 Q_UNUSED(event);    // Maybe later something happens with right click...
-                LegendScrollButton* scrollButton = static_cast<LegendScrollButton*> (sender());
+                LegendScrollButton* scrollButton = static_cast<LegendScrollButton *> (sender());
                 Q_ASSERT(scrollButton);
                 switch (scrollButton->id()) {
                 }
                 case QSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
-                    disconnect(pieSeries,SIGNAL(added(QList<QPieSlice*>)),this,SLOT(handleAdded(QList<QPieSlice*>)));
+                    disconnect(pieSeries, SIGNAL(added(QList<QPieSlice *>)), this, SLOT(handleAdded(QList<QPieSlice *>)));
             //        disconnect(pieSeries,SIGNAL(removed(QList<QPieSlice*>)),this,SLOT(handleRemoved(QList<QPieSlice*>)));
                     break;
                 }
                 switch (series->type())
                 {
                 case QSeries::SeriesTypeLine: {
-                    QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
+                    QLineSeries *lineSeries = static_cast<QLineSeries *>(series);
                     appendMarkers(lineSeries);
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
-                    QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
+                    QAreaSeries *areaSeries = static_cast<QAreaSeries *>(series);
                     appendMarkers(areaSeries->upperSeries());
                     if(areaSeries->lowerSeries())
-                    appendMarkers(areaSeries->lowerSeries());
+                        appendMarkers(areaSeries->lowerSeries());
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
-                    QBarSeries* barSeries = static_cast<QBarSeries*>(series);
+                    QBarSeries *barSeries = static_cast<QBarSeries *>(series);
                     appendMarkers(barSeries);
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
-                    QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
+                    QStackedBarSeries *stackedBarSeries = static_cast<QStackedBarSeries *>(series);
                     appendMarkers(stackedBarSeries);
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
-                    QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
+                    QPercentBarSeries *percentBarSeries = static_cast<QPercentBarSeries *>(series);
                     appendMarkers(percentBarSeries);
                     break;
                 }
                 }
                 case QSeries::SeriesTypeSpline: {
-                    QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
+                    QSplineSeries *splineSeries = static_cast<QSplineSeries *>(series);
                     appendMarkers(splineSeries);
                     break;
                 }
                 marker->setName(series->name());
                 marker->setPen(series->pen());
                 marker->setBrush(series->brush());
-                connect(marker,SIGNAL(clicked(QSeries*,Qt::MouseButton)),this,SIGNAL(clicked(QSeries*,Qt::MouseButton)));
+                connect(marker, SIGNAL(clicked(QSeries *, Qt::MouseButton)), this, SIGNAL(clicked(QSeries *, Qt::MouseButton)));
-                connect(marker,SIGNAL(destroyed()),this,SLOT(handleMarkerDestroyed()));
+                connect(marker, SIGNAL(destroyed()), this, SLOT(handleMarkerDestroyed()));
                 mMarkers.append(marker);
                 childItems().append(marker);
             }
             void QLegend::appendMarkers(QBarSeries *series)
             {
                 foreach(QBarSet* s, series->barSets()) {
-                    LegendMarker* marker = new LegendMarker(series,s,this);
+                    LegendMarker* marker = new LegendMarker(series, s, this);
                     marker->setName(s->name());
                     marker->setPen(s->pen());
                     marker->setBrush(s->brush());
-                    connect(marker,SIGNAL(clicked(QBarSet*,Qt::MouseButton)),this,SIGNAL(clicked(QBarSet*,Qt::MouseButton)));
+                    connect(marker, SIGNAL(clicked(QBarSet *, Qt::MouseButton)),
-                    connect(s,SIGNAL(valueChanged()),marker,SLOT(changed()));
+                            this, SIGNAL(clicked(QBarSet *, Qt::MouseButton)));
-                    connect(marker,SIGNAL(destroyed()),this,SLOT(handleMarkerDestroyed()));
+                    connect(s, SIGNAL(valueChanged()), marker, SLOT(changed()));
+                    connect(marker, SIGNAL(destroyed()), this, SLOT(handleMarkerDestroyed()));
                     mMarkers.append(marker);
                     childItems().append(marker);
                 }
             void QLegend::appendMarkers(QPieSeries *series)
             {
                 foreach(QPieSlice* s, series->slices()) {
-                    LegendMarker* marker = new LegendMarker(series,s,this);
+                    LegendMarker* marker = new LegendMarker(series, s, this);
                     marker->setName(s->label());
                     marker->setPen(s->slicePen());
                     marker->setBrush(s->sliceBrush());
-                    connect(marker,SIGNAL(clicked(QPieSlice*,Qt::MouseButton)),this,SIGNAL(clicked(QPieSlice*,Qt::MouseButton)));
+                    connect(marker, SIGNAL(clicked(QPieSlice *, Qt::MouseButton)),
-                    connect(s,SIGNAL(changed()),marker,SLOT(changed()));
+                            this, SIGNAL(clicked(QPieSlice *, Qt::MouseButton)));
-                    connect(s,SIGNAL(destroyed()),marker,SLOT(deleteLater()));
+                    connect(s, SIGNAL(changed()), marker, SLOT(changed()));
-                    connect(marker,SIGNAL(destroyed()),this,SLOT(handleMarkerDestroyed()));
+                    connect(s, SIGNAL(destroyed()), marker, SLOT(deleteLater()));
+                    connect(marker, SIGNAL(destroyed()), this, SLOT(handleMarkerDestroyed()));
                     mMarkers.append(marker);
                     childItems().append(marker);
                 }
                 // Use max height as scroll button size
                 rescaleScrollButtons(QSize(markerMaxSize.height() ,markerMaxSize.height()));
                 qreal totalWidth = 0;
                 qreal totalHeight = 0;
                 switch (mPreferredLayout)
                     if (scrollButtonsVisible()) {
                         mScrollButtonLeft->setVisible(true);
                         mScrollButtonRight->setVisible(true);
-                        totalWidth += (mScrollButtonLeft->boundingRect().width() + mMargin) * 2;   // scrollbuttons visible, so add their width to total width
+                        // scrollbuttons visible, so add their width to total width
+                        totalWidth += (mScrollButtonLeft->boundingRect().width() + mMargin) * 2;
                         scrollButtonWidth = mScrollButtonLeft->boundingRect().width() + mMargin;
-                        x += scrollButtonWidth;                  // start position changes by scrollbutton width
+                        // start position changes by scrollbutton width
+                        x += scrollButtonWidth;
                     } else {
                         mScrollButtonLeft->setVisible(false);
                         mScrollButtonRight->setVisible(false);
                     mScrollButtonUp->setVisible(false);
                     mScrollButtonDown->setVisible(false);
-                    for (int i=0; i<mMarkers.count(); i++) {
+                    for (int i=0; i < mMarkers.count(); i++) {
-                        LegendMarker* m = mMarkers.at(i);
+                        LegendMarker *m = mMarkers.at(i);
-                        if (i<mFirstMarker) {
+                        if (i < mFirstMarker) {
                             // Markers before first are not visible.
                             m->setVisible(false);
                         } else {
                             } else {
                                 // This marker is ok
                                 m->setVisible(true);
-                                m->setPos(x,y);
+                                m->setPos(x, y);
                                 x += xStep;
                                 column++;
                             }
                     }
                     mScrollButtonLeft->setPos(mPos.x() + mMargin, y);
-                    mScrollButtonRight->setPos(x+mMargin,y);
+                    mScrollButtonRight->setPos(x + mMargin, y);
                     totalWidth += maxColumns * markerMaxSize.width() + mMargin * 2;
                     totalHeight = markerMaxSize.height() + mMargin * 2;
                     mScrollButtonLeft->setVisible(false);
                     mScrollButtonRight->setVisible(false);
-                    for (int i=0; i<mMarkers.count(); i++) {
+                    for (int i=0; i < mMarkers.count(); i++) {
                         LegendMarker* m = mMarkers.at(i);
-                        if (i<mFirstMarker) {
+                        if (i < mFirstMarker) {
                             // Markers before first are not visible.
                             m->setVisible(false);
                         } else {
                             } else {
                                 // This marker is ok
                                 m->setVisible(true);
-                                m->setPos(x,y);
+                                m->setPos(x, y);
                                 y += yStep;
                                 row++;
                             }
             void QLegend::rescaleScrollButtons(const QSize &size)
             {
                 QPolygonF left;
-                left << QPointF(size.width(),0) << QPointF(0,size.height()/2) << QPointF(size.width(),size.height());
+                left << QPointF(size.width(), 0) << QPointF(0, size.height() / 2) << QPointF(size.width(), size.height());
                 QPolygonF right;
-                right << QPointF(0,0) << QPointF(size.width(),size.height()/2) << QPointF(0,size.height());
+                right << QPointF(0, 0) << QPointF(size.width(), size.height() / 2) << QPointF(0, size.height());
                 QPolygonF up;
-                up << QPointF(0,size.height()) << QPointF(size.width()/2,0) << QPointF(size.width(),size.height());
+                up << QPointF(0, size.height()) << QPointF(size.width() / 2,0) << QPointF(size.width(), size.height());
                 QPolygonF down;
-                down << QPointF(0,0) << QPointF(size.width()/2,size.height()) << QPointF(size.width(),0);
+                down << QPointF(0, 0) << QPointF(size.width() / 2, size.height()) << QPointF(size.width(), 0);
                 mScrollButtonLeft->setPolygon(left);
                 mScrollButtonRight->setPolygon(right);
             {
                 QSizeF max(0,0);
                 foreach (LegendMarker* m, mMarkers) {
-                    if (m->boundingRect().width() > max.width()) {
+                    if (m->boundingRect().width() > max.width())
                         max.setWidth(m->boundingRect().width());
+                    if (m->boundingRect().height() > max.height())
-                    if (m->boundingRect().height() > max.height()) {
                         max.setHeight(m->boundingRect().height());
                 }
                 return max;
             }
                     // Bounds limited by height.
                     int max;
                     if (scrollButtonsVisible()) {
-                        max = (mMaximumSize.height() - mScrollButtonLeft->boundingRect().height() * 2 - mMargin*4) / maximumMarkerSize().height();
+                        max = (mMaximumSize.height() - mScrollButtonLeft->boundingRect().height() * 2 - mMargin * 4) / maximumMarkerSize().height();
                     } else {
                         max = mMaximumSize.height() / maximumMarkerSize().height();
                     }
-                    if (mFirstMarker > mMarkers.count() - max) {
+                    if (mFirstMarker > mMarkers.count() - max)
                         mFirstMarker = mMarkers.count() - max;
                 } else {
                     // Bounds limited by width
                     int max;
                         max = mMaximumSize.width() / maximumMarkerSize().width();
                     }
-                    if (mFirstMarker > mMarkers.count() - max) {
+                    if (mFirstMarker > mMarkers.count() - max)
                         mFirstMarker = mMarkers.count() - max;
                 }
-                if (mFirstMarker < 0) {
+                if (mFirstMarker < 0)
                     mFirstMarker = 0;
             }
             /*!
             }
             #include "moc_qlegend.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qlegend.h +24 -24

                     PreferredLayoutTop,
                     PreferredLayoutBottom,
                     PreferredLayoutLeft,
-                    PreferredLayoutRight,
+                    PreferredLayoutRight
                 };
                 explicit QLegend(QGraphicsItem *parent = 0);
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
-                void setBrush(const QBrush& brush);
+                void setBrush(const QBrush &brush);
                 QBrush brush() const;
-                void setPen(const QPen& pen);
+                void setPen(const QPen &pen);
                 QPen pen() const;
                 void setPreferredLayout(QLegend::PreferredLayout preferred);
             signals:
                 // for interactions.
-                void clicked(QSeries* series, Qt::MouseButton button);
+                void clicked(QSeries *series, Qt::MouseButton button);
-                void clicked(QBarSet* barset, Qt::MouseButton button);
+                void clicked(QBarSet *barset, Qt::MouseButton button);
-                void clicked(QPieSlice* slice, Qt::MouseButton button);
+                void clicked(QPieSlice *slice, Qt::MouseButton button);
             public slots:
                 // PIMPL --->
-                void handleSeriesAdded(QSeries* series,Domain* domain);
+                void handleSeriesAdded(QSeries *series, Domain *domain);
-                void handleSeriesRemoved(QSeries* series);
+                void handleSeriesRemoved(QSeries *series);
-                void handleAdded(QList<QPieSlice*> slices);
+                void handleAdded(QList<QPieSlice *> slices);
-                void handleRemoved(QList<QPieSlice*> slices);
+                void handleRemoved(QList<QPieSlice *> slices);
                 void handleMarkerDestroyed();
-                void handleScrollButtonClicked(QGraphicsSceneMouseEvent* event);
+                void handleScrollButtonClicked(QGraphicsSceneMouseEvent *event);
                 // PIMPL <---
             private:
                 // PIMPL --->
-                void connectSeries(QSeries* series);
+                void connectSeries(QSeries *series);
-                void disconnectSeries(QSeries* series);
+                void disconnectSeries(QSeries *series);
-                void createMarkers(QSeries* series);
+                void createMarkers(QSeries *series);
-                void appendMarkers(QXYSeries* series);      // All line series are derived from QXYSeries, so this works for now
+                void appendMarkers(QXYSeries *series);      // All line series are derived from QXYSeries, so this works for now
-                void appendMarkers(QBarSeries* series);
+                void appendMarkers(QBarSeries *series);
-                void appendMarkers(QPieSeries* series);
+                void appendMarkers(QPieSeries *series);
-                void deleteMarkers(QSeries* series);
+                void deleteMarkers(QSeries *series);
                 void updateLayout();
-                void rescaleScrollButtons(const QSize& size);
+                void rescaleScrollButtons(const QSize &size);
                 QSizeF maximumMarkerSize();
                 void checkFirstMarkerBounds();
                 bool scrollButtonsVisible();
                 QSizeF mMinimumSize;
                 QSizeF mMaximumSize;
-                QList<LegendMarker*> mMarkers;
+                QList<LegendMarker *> mMarkers;
                 QBrush m_brush;
                 QPen m_pen;
                 int mFirstMarker;
-                LegendScrollButton* mScrollButtonLeft;
+                LegendScrollButton *mScrollButtonLeft;
-                LegendScrollButton* mScrollButtonRight;
+                LegendScrollButton *mScrollButtonRight;
-                LegendScrollButton* mScrollButtonUp;
+                LegendScrollButton *mScrollButtonUp;
-                LegendScrollButton* mScrollButtonDown;
+                LegendScrollButton *mScrollButtonDown;
                 qreal mMargin;
                 // <--- PIMPL

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