HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1082:4c0668542a54

Bugfixes for spline vector allocation issues

Michal Klocek -

r1082:4c0668542a54

parent child

Context file:

r1082:4c0668542a54

Collapse all files

src/chartpresenter.cpp +2 0

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "chartpresenter_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "qaxis.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "qabstractseries_p.h"
             #include "qareaseries.h"
             #include "chartaxis_p.h"
             #include "areachartitem_p.h"
             #include "chartbackground_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_animator(0),
             m_dataset(dataset),
             m_chartTheme(0),
             m_chartRect(QRectF(QPoint(0,0),m_chart->size())),
             m_options(QChart::NoAnimation),
             m_minLeftMargin(0),
             m_minBottomMargin(0),
             m_backgroundItem(0),
             m_titleItem(0),
             m_marginBig(60),
             m_marginSmall(20),
             m_marginTiny(10),
             m_chartMargins(QRect(m_marginBig,m_marginBig,0,0))
             {
             }
             ChartPresenter::~ChartPresenter()
             {
                 delete m_chartTheme;
             }
             void ChartPresenter::setGeometry(const QRectF& rect)
             {
                 m_rect = rect;
                 Q_ASSERT(m_rect.isValid());
                 updateLayout();
             }
             void ChartPresenter::setMinimumMarginWidth(ChartAxis* axis, qreal width)
             {
                 switch(axis->axisType()){
                 case ChartAxis::X_AXIS:
                 {
                     if(width>m_chartRect.width()+ m_chartMargins.left()) {
                         m_minLeftMargin= width - m_chartRect.width();
                         updateLayout();
                     }
                     break;
                 }
                 case ChartAxis::Y_AXIS:
                 {
                     if(m_minLeftMargin!=width){
                         m_minLeftMargin= width;
                         updateLayout();
                     }
                     break;
                 }
                 }
             }
             void ChartPresenter::setMinimumMarginHeight(ChartAxis* axis, qreal height)
             {
                 switch(axis->axisType()){
                 case ChartAxis::X_AXIS:
                 {
                     if(m_minBottomMargin!=height) {
                         m_minBottomMargin= height;
                         updateLayout();
                     }
                     break;
                 }
                 case ChartAxis::Y_AXIS:
                 {
                     if(height>m_chartMargins.bottom()+m_chartRect.height()){
                         m_minBottomMargin= height - m_chartRect.height();
                         updateLayout();
                     }
                     break;
                 }
                 }
             }
             void ChartPresenter::handleAxisAdded(QAxis* axis,Domain* domain)
             {
                 ChartAxis* item = new ChartAxis(axis,this,axis==m_dataset->axisX()?ChartAxis::X_AXIS : ChartAxis::Y_AXIS);
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
                     m_animator->addAnimation(item);
                 }
                 if(axis==m_dataset->axisX()){
                     m_chartTheme->decorate(axis,true);
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minX(),domain->maxX(),domain->tickXCount());
                 }
                 else{
                     m_chartTheme->decorate(axis,false);
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY(),domain->tickYCount());
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
                 //initialize
                 item->handleGeometryChanged(m_chartRect);
                 m_axisItems.insert(axis, item);
             }
             void ChartPresenter::handleAxisRemoved(QAxis* axis)
             {
                 ChartAxis* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 if(m_animator) m_animator->removeAnimation(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QAbstractSeries* series,Domain* domain)
             {
                 Chart *item = series->d_ptr->createGraphics(this);
                 Q_ASSERT(item);
                 QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
                 QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                 //initialize
                 item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                 if(m_chartRect.isValid()) item->handleGeometryChanged(m_chartRect);
                 m_chartItems.insert(series,item);
             }
             void ChartPresenter::handleSeriesRemoved(QAbstractSeries* series)
             {
                 Chart* item = m_chartItems.take(series);
                 Q_ASSERT(item);
                 if(m_animator) {
                     //small hack to handle area animations
                     if(series->type() == QAbstractSeries::SeriesTypeArea){
                         QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                         AreaChartItem* area = static_cast<AreaChartItem*>(item);
                         m_animator->removeAnimation(area->upperLineItem());
                         if(areaSeries->lowerSeries())  m_animator->removeAnimation(area->lowerLineItem());
                     }else
                         m_animator->removeAnimation(item);
                 }
                 delete item;
             }
             void ChartPresenter::setTheme(QChart::ChartTheme theme,bool force)
             {
                 if(m_chartTheme && m_chartTheme->id() == theme) return;
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->setForced(force);
                 m_chartTheme->decorate(m_chart);
                 m_chartTheme->decorate(m_chart->legend());
                 resetAllElements();
             }
             QChart::ChartTheme ChartPresenter::theme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     if(m_options!=QChart::NoAnimation && !m_animator) {
                         m_animator= new ChartAnimator(this);
                     }
                     resetAllElements();
                 }
             }
             void ChartPresenter::resetAllElements()
             {
                 QList<QAxis *> axisList = m_axisItems.uniqueKeys();
                 QList<QAbstractSeries *> seriesList = m_chartItems.uniqueKeys();
                 foreach(QAxis *axis, axisList) {
                     handleAxisRemoved(axis);
                     handleAxisAdded(axis,m_dataset->domain(axis));
                 }
                 foreach(QAbstractSeries *series, seriesList) {
                     handleSeriesRemoved(series);
                     handleSeriesAdded(series,m_dataset->domain(series));
             //        m_dataset->removeSeries(series);
             //        m_dataset->addSeries(series);
                 }
             }
             void ChartPresenter::zoomIn()
             {
                 QRectF rect = chartGeometry();
                 rect.setWidth(rect.width()/2);
                 rect.setHeight(rect.height()/2);
                 rect.moveCenter(chartGeometry().center());
                 zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
                 QRectF r = rect.normalized();
                 r.translate(-m_chartMargins.topLeft());
+                if(!r.isValid()) return;
                 if(m_animator) {
                     QPointF point(r.center().x()/chartGeometry().width(),r.center().y()/chartGeometry().height());
                     m_animator->setState(ChartAnimator::ZoomInState,point);
                 }
                 m_dataset->zoomInDomain(r,chartGeometry().size());
                 if(m_animator) {
                     m_animator->setState(ChartAnimator::ShowState);
                 }
             }
             void ChartPresenter::zoomOut()
             {
                 if(m_animator)
                 {
                     m_animator->setState(ChartAnimator::ZoomOutState);
                 }
                 QSizeF size = chartGeometry().size();
                 QRectF rect = chartGeometry();
                 rect.translate(-m_chartMargins.topLeft());
+                if(!rect.isValid()) return;
                 m_dataset->zoomOutDomain(rect.adjusted(size.width()/4,size.height()/4,-size.width()/4,-size.height()/4),size);
                 //m_dataset->zoomOutDomain(m_zoomStack[m_zoomIndex-1],geometry().size());
                 if(m_animator){
                     m_animator->setState(ChartAnimator::ShowState);
                 }
             }
             void ChartPresenter::scroll(int dx,int dy)
             {
                 if(m_animator){
                     if(dx<0) m_animator->setState(ChartAnimator::ScrollLeftState,QPointF());
                     if(dx>0) m_animator->setState(ChartAnimator::ScrollRightState,QPointF());
                     if(dy<0) m_animator->setState(ChartAnimator::ScrollUpState,QPointF());
                     if(dy>0) m_animator->setState(ChartAnimator::ScrollDownState,QPointF());
                 }
                 m_dataset->scrollDomain(dx,dy,chartGeometry().size());
                 if(m_animator){
                     m_animator->setState(ChartAnimator::ShowState);
                 }
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             void ChartPresenter::updateLayout()
             {
                 if (!m_rect.isValid()) return;
                 // recalculate title size
                 QSize titleSize;
                 int titlePadding=0;
                 if (m_titleItem) {
                     titleSize= m_titleItem->boundingRect().size().toSize();
                 }
                 //defaults
                 m_chartMargins = QRect(QPoint(m_minLeftMargin>m_marginBig?m_minLeftMargin:m_marginBig,m_marginBig),QPoint(m_marginBig,m_minBottomMargin>m_marginBig?m_minBottomMargin:m_marginBig));
                 titlePadding = m_chartMargins.top()/2;
                 QLegend* legend = m_chart->d_ptr->m_legend;
                 // recalculate legend position
                 if (legend->isAttachedToChart() && legend->isEnabled()) {
                     QRect legendRect;
                     // Reserve some space for legend
                     switch (legend->alignment()) {
                     case QLegend::AlignmentTop: {
                         int ledgendSize = legend->minHeight();
                         int topPadding = 2*m_marginTiny + titleSize.height() + ledgendSize + m_marginTiny;
                         m_chartMargins = QRect(QPoint(m_chartMargins.left(),topPadding),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_chartMargins.left(),topPadding - (ledgendSize + m_marginTiny)),QPoint(m_chartMargins.right(),m_rect.height()-topPadding + m_marginTiny));
                         titlePadding = m_marginTiny + m_marginTiny;
                         break;
                     }
                     case QLegend::AlignmentBottom: {
                         int ledgendSize = legend->minHeight();
                         int bottomPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny + m_minBottomMargin;
                         m_chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(m_chartMargins.right(),bottomPadding));
                         m_legendMargins = QRect(QPoint(m_chartMargins.left(),m_rect.height()-bottomPadding + m_marginTiny + m_minBottomMargin),QPoint(m_chartMargins.right(),m_marginTiny + m_marginSmall));
                         titlePadding = m_chartMargins.top()/2;
                         break;
                     }
                     case QLegend::AlignmentLeft: {
                         int ledgendSize = legend->minWidth();
                         int leftPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny + m_minLeftMargin;
                         m_chartMargins = QRect(QPoint(leftPadding,m_chartMargins.top()),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_marginTiny + m_marginSmall,m_chartMargins.top()),QPoint(m_rect.width()-leftPadding + m_marginTiny + m_minLeftMargin,m_chartMargins.bottom()));
                         titlePadding = m_chartMargins.top()/2;
                         break;
                     }
                     case QLegend::AlignmentRight: {
                         int ledgendSize = legend->minWidth();
                         int rightPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny;
                         m_chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(rightPadding,m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_rect.width()- rightPadding+ m_marginTiny ,m_chartMargins.top()),QPoint(m_marginTiny + m_marginSmall,m_chartMargins.bottom()));
                         titlePadding = m_chartMargins.top()/2;
                         break;
                     }
                     default: {
                         break;
                     }
                     }
                 }
                 if(m_rect.width()<2*(m_chartMargins.top()+m_chartMargins.bottom()) || m_rect.height()< 2*(m_chartMargins.top() + m_chartMargins.bottom()))
                 {
                     m_chart->setMinimumSize(2*(m_chartMargins.top()+m_chartMargins.bottom()),2*(m_chartMargins.top() + m_chartMargins.bottom()));
                     return;
                 }
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),titlePadding);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(m_rect.adjusted(m_marginTiny,m_marginTiny, -m_marginTiny, -m_marginTiny));
                 }
                 QRectF chartRect = m_rect.adjusted(m_chartMargins.left(),m_chartMargins.top(),-m_chartMargins.right(),-m_chartMargins.bottom());
                 legend->setGeometry(m_rect.adjusted(m_legendMargins.left(),m_legendMargins.top(),-m_legendMargins.right(),-m_legendMargins.bottom()));
                 if(m_chartRect!=chartRect){
                     m_chartRect=chartRect;
                     emit geometryChanged(m_chartRect);
                 }
             }
             void ChartPresenter::createChartBackgroundItem()
             {
                 if (!m_backgroundItem) {
                     m_backgroundItem = new ChartBackground(rootItem());
                     m_backgroundItem->setPen(Qt::NoPen);
                     m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::createChartTitleItem()
             {
                 if (!m_titleItem) {
                     m_titleItem = new QGraphicsSimpleTextItem(rootItem());
                     m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/qsplineseries.cpp +8 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qsplineseries.h"
             #include "qsplineseries_p.h"
             #include "splinechartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include <QAbstractItemModel>
             /*!
                 \class QSplineSeries
                 \brief Series type used to store data needed to draw a spline.
                 QSplineSeries stores the data points along with the segment control points needed by QPainterPath to draw spline
                 Control points are automatically calculated when data changes. The algorithm computes the points so that the normal spline can be drawn.
                 \image examples_splinechart.png
                 Creating basic spline chart is simple:
                 \code
                 QSplineSeries* series = new QSplineSeries();
                 series->append(0, 6);
                 series->append(2, 4);
                 ...
                 chart->addSeries(series);
                 \endcode
             */
             /*!
               \fn QSeriesType QSplineSeries::type() const
               Returns the type of the series
               */
             /*!
               \fn QSeriesType QSplineSeries::controlPoint(int index) const
               Returns the control point specified by \a index
               */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance then the ownerships is transferred.
               */
             QSplineSeries::QSplineSeries(QObject *parent) :
                 QLineSeries(*new QSplineSeriesPrivate(this),parent)
             {
             }
+            QSplineSeries::~QSplineSeries()
+            {
+                Q_D(QSplineSeries);
+                if(d->m_dataset){
+                       d->m_dataset->removeSeries(this);
+                }
+            }
             QAbstractSeries::QSeriesType QSplineSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeSpline;
             }
             QPointF QSplineSeries::controlPoint(int index) const
             {
                 Q_D(const QSplineSeries);
                 return d->m_controlPoints[index];
             }
             /*!
                  Sets the \a modelX to be used as a data source for x coordinate and \a modelY to be used
                  as a data source for y coordinate. The \a orientation parameter specifies whether the data
                  is in columns or in rows.
                  \sa setModel()
              */
             void QSplineSeries::setModelMapping(int modelX, int modelY, Qt::Orientation orientation)
             {
                 Q_D(QSplineSeries);
                 QXYSeries::setModelMapping(modelX, modelY, orientation);
                 d->updateControlPoints();
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QSplineSeriesPrivate::QSplineSeriesPrivate(QSplineSeries* q):QLineSeriesPrivate(q)
             {
                 QObject::connect(this,SIGNAL(pointAdded(int)), this, SLOT(updateControlPoints()));
                 QObject::connect(this,SIGNAL(pointRemoved(int)), this, SLOT(updateControlPoints()));
                 QObject::connect(this,SIGNAL(pointReplaced(int)), this, SLOT(updateControlPoints()));
             };
             /*!
               Calculates control points which are needed by QPainterPath.cubicTo function to draw the cubic Bezier cureve between two points.
               */
             void QSplineSeriesPrivate::calculateControlPoints()
             {
                 Q_Q(QSplineSeries);
                 const QList<QPointF>& points = q->points();
                 int n = points.count() - 1;
                 if (n == 1)
                 {
                     //for n==1
                     m_controlPoints[0].setX((2 * points[0].x() + points[1].x()) / 3);
                     m_controlPoints[0].setY((2 * points[0].y() + points[1].y()) / 3);
                     m_controlPoints[1].setX(2 * m_controlPoints[0].x() - points[0].x());
                     m_controlPoints[1].setY(2 * m_controlPoints[0].y() - points[0].y());
                     return;
                 }
                 // Calculate first Bezier control points
                 // Right hand side vector
                 //  Set of equations for P0 to Pn points.
                 //
                 //  |   2   1   0   0   ... 0   0   0   ... 0   0   0   |   |   P1_1    |   |   P0 + 2 * P1             |
                 //  |   1   4   1   0   ... 0   0   0   ... 0   0   0   |   |   P1_2    |   |   4 * P1 + 2 * P2         |
                 //  |   0   1   4   1   ... 0   0   0   ... 0   0   0   |   |   P1_3    |   |   4 * P2 + 2 * P3         |
                 //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
                 //  |   0   0   0   0   ... 1   4   1   ... 0   0   0   | * |   P1_i    | = |   4 * P(i-1) + 2 * Pi     |
                 //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
                 //  |   0   0   0   0   0   0   0   0   ... 1   4   1   |   |   P1_(n-1)|   |   4 * P(n-2) + 2 * P(n-1) |
                 //  |   0   0   0   0   0   0   0   0   ... 0   2   7   |   |   P1_n    |   |   8 * P(n-1) + Pn         |
                 //
                 QVector<qreal> vector;
                 vector.resize(n);
                 vector[0] = points[0].x() + 2 * points[1].x();
                 for (int i = 1; i < n - 1; ++i){
                     vector[i] = 4 * points[i].x() + 2 * points[i + 1].x();
                 }
                 vector[n - 1] = (8 * points[n-1].x() + points[n].x()) / 2.0;
                 QVector<qreal> xControl = firstControlPoints(vector);
                 vector[0] = points[0].y() + 2 * points[1].y();
                 for (int i = 1; i < n - 1; ++i) {
                     vector[i] = 4 * points[i].y() + 2 * points[i + 1].y();
                 }
                 vector[n - 1] = (8 * points[n-1].y() + points[n].y()) / 2.0;
                 QVector<qreal> yControl = firstControlPoints(vector);
                 for (int i = 0,j =0; i < n; ++i, ++j) {
                     m_controlPoints[j].setX(xControl[i]);
                     m_controlPoints[j].setY(yControl[i]);
                     j++;
                     if (i < n - 1){
                         m_controlPoints[j].setX(2 * points[i+1].x() - xControl[i + 1]);
                         m_controlPoints[j].setY(2 * points[i+1].y() - yControl[i + 1]);
                     }else{
                         m_controlPoints[j].setX((points[n].x() + xControl[n - 1]) / 2);
                         m_controlPoints[j].setY((points[n].y() + yControl[n - 1]) / 2);
                     }
                 }
             }
             QVector<qreal> QSplineSeriesPrivate::firstControlPoints(const QVector<qreal>& vector)
             {
                 QVector<qreal> result;
                 int count = vector.count();
                 result.resize(count);
                 result[0] = vector[0] / 2.0;
                 QVector<qreal> temp;
                 temp.resize(count);
                 temp[0] = 0;
                 qreal b = 2.0;
                 for (int i = 1; i < count; i++) {
                     temp[i] = 1 / b;
                     b = (i < count - 1 ? 4.0 : 3.5) - temp[i];
                     result[i]=(vector[i] - result[i - 1]) / b;
                 }
                 for (int i = 1; i < count; i++)
                     result[count - i - 1] -= temp[count - i] * result[count - i];
                 return result;
             }
             /*!
               Updates the control points, besed on currently avaiable knots.
               */
             void QSplineSeriesPrivate::updateControlPoints()
             {
                 Q_Q(QSplineSeries);
                 if (q->count() > 1) {
                     m_controlPoints.resize(2*q->count()-2);
                     calculateControlPoints();
                 }
             }
             void QSplineSeriesPrivate::modelDataAdded(QModelIndex parent, int start, int end)
             {
                 updateControlPoints();
                 QXYSeriesPrivate::modelDataAdded(parent, start, end);
             }
             void QSplineSeriesPrivate::modelDataRemoved(QModelIndex parent, int start, int end)
             {
                 updateControlPoints();
                 QXYSeriesPrivate::modelDataRemoved(parent, start, end);
             }
             Chart* QSplineSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QSplineSeries);
                 SplineChartItem* spline  = new SplineChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(spline);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return spline;
             }
             #include "moc_qsplineseries.cpp"
             #include "moc_qsplineseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/qsplineseries.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QSPLINESERIES_H
             #define QSPLINESERIES_H
             #include <qchartglobal.h>
             #include <qlineseries.h>
             #include <QList>
             #include <QPointF>
             #include <QtGlobal>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QSplineSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QSplineSeries : public QLineSeries
             {
                 Q_OBJECT
             public:
                 explicit QSplineSeries(QObject *parent = 0);
+                ~QSplineSeries();
                 QAbstractSeries::QSeriesType type() const;
                 QPointF controlPoint(int index) const;
                 void setModelMapping(int modelX, int modelY, Qt::Orientation orientation = Qt::Vertical);
             private:
                 Q_DECLARE_PRIVATE(QSplineSeries);
                 Q_DISABLE_COPY(QSplineSeries);
                 friend class SplineChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSPLINESERIES_H

src/splinechart/splinechartitem.cpp +7 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "splinechartitem_p.h"
             #include "qsplineseries_p.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
+            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             SplineChartItem::SplineChartItem(QSplineSeries *series, ChartPresenter *presenter) :
                 XYChartItem(series, presenter),
                 m_series(series),
                 m_pointsVisible(false)
             {
                 setZValue(ChartPresenter::LineChartZValue);
                 QObject::connect(m_series->d_func(),SIGNAL(updated()),this,SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF SplineChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath SplineChartItem::shape() const
             {
                 return m_path;
             }
             void SplineChartItem::updateLayout(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
+            {
                 QVector<QPointF> controlPoints;
-                controlPoints.resize(newPoints.count()*2-2);
+                if(newPoints.count()>=2){
+                    controlPoints.resize(newPoints.count()*2-2);
+                }
                 for (int i = 0; i < newPoints.size() - 1; i++) {
                     controlPoints[2*i] = calculateGeometryControlPoint(2 * i);
                     controlPoints[2 * i + 1] = calculateGeometryControlPoint(2 * i + 1);
                 }
                 if (controlPoints.count()<2) {
                     setLayout(newPoints,controlPoints);
                     return;
                 }
                 if (animator()) {
                    animator()->updateLayout(this,oldPoints,newPoints,m_controlPoints,controlPoints,index);
                 } else {
                    setLayout(newPoints,controlPoints);
                 }
             }
             QPointF SplineChartItem::calculateGeometryControlPoint(int index) const
             {
                 return XYChartItem::calculateGeometryPoint(m_series->controlPoint(index));
             }
             void SplineChartItem::setLayout(QVector<QPointF> &points)
             {
                 // Dummy implementation because of a bug in Clang compiler
                 XYChartItem::setLayout(points);
             }
             void SplineChartItem::setLayout(QVector<QPointF> &points, QVector<QPointF> &controlPoints)
             {
                 if ((points.size()<2) || (controlPoints.size()<2)) {
                     XYChartItem::setLayout(points);
                     m_controlPoints=controlPoints;
                     return;
                 }
                 Q_ASSERT(points.count()*2-2 == controlPoints.count());
                 QPainterPath splinePath(points.at(0));
                 for (int i = 0; i < points.size() - 1; i++) {
                     const QPointF& point = points.at(i + 1);
                     splinePath.cubicTo(controlPoints[2*i],controlPoints[2 * i + 1],point);
                 }
                 prepareGeometryChange();
                 m_path = splinePath;
                 m_rect = splinePath.boundingRect();
                 XYChartItem::setLayout(points);
                 m_controlPoints=controlPoints;
             }
             //handlers
             void SplineChartItem::handleUpdated()
             {
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2*m_pointPen.width());
                 update();
             }
             //painter
             void SplineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
+                qDebug()<<__FUNCTION__;
                 painter->save();
                 painter->setClipRect(clipRect());
                 painter->setPen(m_linePen);
                 painter->drawPath(m_path);
                 if (m_pointsVisible) {
                     painter->setPen(m_pointPen);
                     painter->drawPoints(points());
                 }
                 painter->restore();
             }
             #include "moc_splinechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.cpp 0 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             /*!
                \fn QPen QXYSeries::pen() const
                \brief  Returns pen used to draw points for series.
                 \sa setPen()
             */
             /*!
                \fn QBrush QXYSeries::brush() const
                \brief  Returns brush used to draw points for series.
                 \sa setBrush()
             */
             /*!
                 \fn void QXYSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on chart.
             */
             /*!
                 \fn void QXYSeriesPrivate::pointReplaced(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeriesPrivate::pointAdded(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeriesPrivate::pointRemoved(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 \internal
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QXYSeries::QXYSeries(QXYSeriesPrivate &d,QObject *parent) : QAbstractSeries(d, parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point \a x \a y to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(qreal x,qreal y)
             {
                 append(QPointF(x,y));
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 d->m_points<<point;
                 emit d->pointAdded(d->m_points.count()-1);
             }
             /*!
                This is an overloaded function.
                Adds list of data \a points to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::append(const QList<QPointF> &points)
             {
                 foreach(const QPointF& point , points) {
                     append(point);
                 }
             }
             void QXYSeries::replace(qreal oldX,qreal oldY,qreal newX,qreal newY)
             {
                 replace(QPointF(oldX,oldY),QPointF(newX,newY));
             }
             void QXYSeries::replace(const QPointF &oldPoint,const QPointF &newPoint)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(oldPoint);
                 if(index==-1) return;
                 d->m_points[index] = newPoint;
                 emit d->pointReplaced(index);
             }
             /*!
               Removes current \a x and \a y value.
             */
             void QXYSeries::remove(qreal x,qreal y)
             {
                 remove(QPointF(x,y));
             }
             /*!
               Removes current \a point x value. Note \a point y value is ignored.
             */
             void QXYSeries::remove(const QPointF &point)
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(point);
                 if(index==-1) return;
                 d->m_points.remove(index);
                 emit d->pointRemoved(index);
             }
             /*!
                Removes all data points from the series.
             */
             void QXYSeries::removeAll()
             {
                 Q_D(QXYSeries);
                 foreach(const QPointF& point, d->m_points) {
                     remove(point);
                 }
             }
             /*!
                 \internal \a pos
             */
             QList<QPointF> QXYSeries::points() const
             {
                 //    Q_ASSERT(false);
                 Q_D(const QXYSeries);
                 if (d->m_model) {
                     QList<QPointF> result;
                     if (d->m_mapOrientation == Qt::Vertical){
                         // consecutive data is read from model's column
                         for(int i = d->m_mapFirst; i< d->m_mapFirst + count(); ++i) {
                             qreal x =  d->m_model->data(d->m_model->index(i, d->m_mapX), Qt::DisplayRole).toReal();
                             qreal y =  d->m_model->data(d->m_model->index(i, d->m_mapY), Qt::DisplayRole).toReal();
                             result << QPointF(x,y);
                         }
                         return result;
                     }
                     else{
                         // consecutive data is read from model's row
                         for(int i = d->m_mapFirst; i<  d->m_mapFirst + count(); ++i) {
                             qreal x =  d->m_model->data(d->m_model->index(d->m_mapX, i), Qt::DisplayRole).toReal();
                             qreal y =  d->m_model->data(d->m_model->index(d->m_mapY, i), Qt::DisplayRole).toReal();
                             result << QPointF(x,y);
                         }
                         return result;
                     }
                 } else {
                     // model is not specified, return the data from series' internal data store
                     return d->m_points.toList();
                 }
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_D(const QXYSeries);
                 if (d->m_model) {
                     if (d->m_mapOrientation == Qt::Vertical) {
                         // data is in a column. Return the number of mapped items if the model's column have enough items
                         // or the number of items that can be mapped
                         if (d->m_mapCount != -1)
                             return qMin(d->m_mapCount, qMax(d->m_model->rowCount() - d->m_mapFirst, 0));
                         else
                             return qMax(d->m_model->rowCount() - d->m_mapFirst, 0);
                     } else {
                         // data is in a row. Return the number of mapped items if the model's row have enough items
                         // or the number of items that can be mapped
                         if (d->m_mapCount != -1)
                             return qMin(d->m_mapCount, qMax(d->m_model->columnCount() - d->m_mapFirst, 0));
                         else
                             return qMax(d->m_model->columnCount() - d->m_mapFirst, 0);
                     }
                 }
                 // model is not specified, return the number of points in the series internal data store
                 return d->m_points.count();
             }
             /*!
                 Sets \a pen used for drawing points on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setPen(const QPen &pen)
             {
                 Q_D(QXYSeries);
                 if (d->m_pen!=pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen QXYSeries::pen() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                 from chart theme setting is used.
                 \sa QChart::setTheme()
             */
             void QXYSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QXYSeries);
                 if (d->m_brush!=brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QXYSeries::brush() const
             {
                 Q_D(const QXYSeries);
                 return d->m_brush;
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QXYSeries::setPointsVisible(bool visible)
             {
                 Q_D(QXYSeries);
                 if (d->m_pointsVisible != visible){
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             /*!
                 Returns true if drawing the data points of the series is enabled.
             */
             bool QXYSeries::pointsVisible() const
             {
                 Q_D(const QXYSeries);
                 return d->m_pointsVisible;
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa append()
             */
             QXYSeries& QXYSeries::operator<< (const QPointF &point)
             {
                 append(point);
                 return *this;
             }
             /*!
                 Stream operator for adding a list of \a points to the series.
                 \sa append()
             */
             QXYSeries& QXYSeries::operator<< (const QList<QPointF>& points)
             {
                 append(points);
                 return *this;
             }
             /*!
                  \fn bool QXYSeries::setModel(QAbstractItemModel *model)
                  Sets the \a model to be used as a data source
                  \sa setModelMapping()
              */
             bool QXYSeries::setModel(QAbstractItemModel *model)
             {
                 Q_D(QXYSeries);
                 // disconnect signals from old model
                 if (d->m_model) {
                     QObject::disconnect(d->m_model, 0, this, 0);
                     d->m_mapX = -1;
                     d->m_mapY = -1;
                     d->m_mapFirst = 0;
                     d->m_mapCount = -1;
                     d->m_mapOrientation = Qt::Vertical;
                 }
                 // set new model
                 if (model) {
                     d->m_model = model;
                     return true;
                 } else {
                     d->m_model = 0;
                     return false;
                 }
             }
             /*!
                  Sets the \a modelX to be used as a data source for x coordinate and \a modelY to be used
                  as a data source for y coordinate. The \a orientation parameter specifies whether the data
                  is in columns or in rows.
                  \sa setModel()
              */
             void QXYSeries::setModelMapping(int modelX, int modelY, Qt::Orientation orientation)
             {
                 Q_D(QXYSeries);
                 if (d->m_model == 0)
                     return;
                 d->m_mapX = modelX;
                 d->m_mapY = modelY;
                 d->m_mapOrientation = orientation;
                 // connect the signals from the model
                 connect(d->m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                 if (d->m_mapOrientation == Qt::Vertical) {
                     connect(d->m_model,SIGNAL(rowsInserted(QModelIndex,int,int)), d, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(d->m_model,SIGNAL(rowsRemoved(QModelIndex,int,int)), d, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 } else {
                     connect(d->m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), d, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), d, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 }
             }
             void QXYSeries::setModelMappingRange(int first, int count)
             {
                 Q_D(QXYSeries);
                 d->m_mapFirst = qMax(first, 0);
                 d->m_mapCount = qMax(count, -1);
             }
             int QXYSeries::mapX() const
             {
                 Q_D(const QXYSeries);
                 return d->m_mapX;
             }
             int QXYSeries::mapY() const
             {
                 Q_D(const QXYSeries);
                 return d->m_mapY;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q) : QAbstractSeriesPrivate(q),
                 m_mapX(-1),
                 m_mapY(-1),
                 m_pointsVisible(false)
             {
             }
             void QXYSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 Q_Q(QXYSeries);
                 const QList<QPointF>& points = q->points();
                 if(points.isEmpty()){
                     minX=0.0;
                     minY=0.0;
                     maxX=1.0;
                     maxY=1.0;
                 }
                 for (int i = 0; i < points.count(); i++)
                 {
                     qreal x = points[i].x();
                     qreal y = points[i].y();
                     minX = qMin(minX, x);
                     minY = qMin(minY, y);
                     maxX = qMax(maxX, x);
                     maxY = qMax(maxY, y);
                 }
                domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             QList<LegendMarker*> QXYSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QXYSeries);
                 QList<LegendMarker*> list;
                 return list << new XYLegendMarker(q,legend);
             }
             void QXYSeriesPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
                     for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
                         if (m_mapOrientation == Qt::Vertical) {
                             if ((column == m_mapX || column == m_mapY)                          // modified item is in a mapped column
                                     && row >= m_mapFirst                                        // modfied item in not before first item
                                     && (m_mapCount == -1 || row < m_mapFirst + m_mapCount))     // map is not limited or item lays before the end of map
                                 emit pointReplaced(row - m_mapFirst);
                         } else {
                             if ((row == m_mapX || row == m_mapY)                                // modified item is in a mapped row
                                     && column >= m_mapFirst                                     // modfied item in not before first item
                                     && (m_mapCount == -1 || column < m_mapFirst + m_mapCount))  // map is not limited or item lays before the end of map
                                 emit pointReplaced(column - m_mapFirst);
                         }
                     }
                 }
             }
             void QXYSeriesPrivate::modelDataAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 emit pointsAdded(start, end);
             }
             void QXYSeriesPrivate::modelDataRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 emit pointsRemoved(start, end);
             }
             #include "moc_qxyseries.cpp"
             #include "moc_qxyseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/xychartitem.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "xychartitem_p.h"
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             XYChartItem::XYChartItem(QXYSeries *series, ChartPresenter *presenter):ChartItem(presenter),
                 m_minX(0),
                 m_maxX(0),
                 m_minY(0),
                 m_maxY(0),
                 m_series(series)
             {
                 connect(series->d_func(),SIGNAL(pointReplaced(int)),this,SLOT(handlePointReplaced(int)));
                 connect(series->d_func(),SIGNAL(pointAdded(int)),this,SLOT(handlePointAdded(int)));
                 connect(series->d_func(),SIGNAL(pointsAdded(int, int)),this,SLOT(handlePointsAdded(int, int)));
                 connect(series->d_func(),SIGNAL(pointRemoved(int)),this,SLOT(handlePointRemoved(int)));
                 connect(series->d_func(),SIGNAL(pointsRemoved(int, int)),this,SLOT(handlePointsRemoved(int, int)));
                 connect(this,SIGNAL(clicked(QPointF)),series,SIGNAL(clicked(QPointF)));
             }
             QPointF XYChartItem::calculateGeometryPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 qreal x = (point.x() - m_minX)* deltaX;
                 qreal y = (point.y() - m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
             QPointF XYChartItem::calculateGeometryPoint(int index) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 const QList<QPointF>& vector = m_series->points();
                 qreal x = (vector[index].x() - m_minX)* deltaX;
                 qreal y = (vector[index].y() - m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
             QVector<QPointF> XYChartItem::calculateGeometryPoints() const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 QVector<QPointF> result;
                 result.resize(m_series->count());
                 const QList<QPointF>& vector = m_series->points();
                 for (int i = 0; i < m_series->count(); ++i) {
                     qreal x = (vector[i].x() - m_minX)* deltaX;
                     qreal y = (vector[i].y() - m_minY)*-deltaY + m_size.height();
                     result[i].setX(x);
                     result[i].setY(y);
                 }
                 return result;
             }
             QPointF XYChartItem::calculateDomainPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 qreal x = point.x()/deltaX +m_minX;
                 qreal y = (point.y()-m_size.height())/(-deltaY)+ m_minY;
                 return QPointF(x,y);
             }
             void XYChartItem::updateLayout(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
             {
                 if (animator()) {
                     animator()->updateLayout(this,oldPoints,newPoints,index);
                 } else {
                     setLayout(newPoints);
                 }
             }
             void XYChartItem::setLayout(QVector<QPointF> &points)
             {
                 m_points = points;
                 update();
             }
             //handlers
             void XYChartItem::handlePointAdded(int index)
             {
                 if (m_series->model() == 0) {
                     Q_ASSERT(index<m_series->count());
                     Q_ASSERT(index>=0);
                 }
                 QVector<QPointF> points = m_points;
                 QPointF point;
                 point = calculateGeometryPoint(index);
                 points.insert(index, point);
                 updateLayout(m_points, points, index);
                 update();
             }
             void XYChartItem::handlePointsAdded(int start, int end)
             {
                 if (m_series->model() == 0) {
                     for (int i = start; i <= end; i++)
                         handlePointAdded(i);
                 } else if (m_series->mapCount() != -1 && start >= m_series->mapFirst() + m_series->mapCount()) {
                     return;
                 } else {
                     int addedCount = end - start + 1;
                     if (m_series->mapCount() != -1 && addedCount > m_series->mapCount())
                         addedCount = m_series->mapCount();
                     int first = qMax(start, m_series->mapFirst());  // get the index of the first item that will be added
                     int last = qMin(first + addedCount - 1, m_series->count() + m_series->mapFirst() - 1);  // get the index of the last item that will be added
                     for (int i = first; i <= last; i++) {
                         handlePointAdded(i - m_series->mapFirst());
                     }
                     // the map is limited therefore the items that are now outside the map
                     // need to be removed from the drawn points
                     if (m_series->mapCount() != -1 && m_points.size() > m_series->mapCount())
                         for (int i = m_points.size() - 1; i >= m_series->mapCount(); i--)
                             handlePointRemoved(i);
                 }
             }
             void XYChartItem::handlePointRemoved(int index)
             {
                 if (m_series->model() == 0) {
                     Q_ASSERT(index<m_series->count() + 1);
                     Q_ASSERT(index>=0);
                 }
                 QVector<QPointF> points = m_points;
                 points.remove(index);
                 updateLayout(m_points, points, index);
                 update();
             }
             void XYChartItem::handlePointsRemoved(int start, int end)
             {
                 Q_UNUSED(start)
                 Q_UNUSED(end)
                 if (m_series->model() == 0) {
                     for (int i = end; i >= start; i--)
                         handlePointRemoved(i);
                 } else {
                     // series uses model as a data source
                     int mapFirst = m_series->mapFirst();
                     int mapCount = m_series->mapCount();
                     int removedCount = end - start + 1;
                     if (mapCount != -1 && start >= mapFirst + mapCount) {
                         return;
                     } else {
                         int toRemove = qMin(m_points.size(), removedCount);     // first find how many items can actually be removed
                         int first = qMax(start, mapFirst);    // get the index of the first item that will be removed.
                         int last = qMin(first + toRemove - 1, m_points.size() + mapFirst - 1);    // get the index of the last item that will be removed.
                         for (int i = last; i >= first; i--) {
                             handlePointRemoved(i - mapFirst);
                         }
                         if (mapCount != -1) {
                             int itemsAvailable;     // check how many are available to be added
                             if (m_series->mapOrientation() == Qt::Vertical)
                                 itemsAvailable = m_series->model()->rowCount() - mapFirst - m_points.size();
                             else
                                 itemsAvailable = m_series->model()->columnCount() - mapFirst - m_points.size();
                             int toBeAdded = qMin(itemsAvailable, mapCount - m_points.size());     // add not more items than there is space left to be filled.
                             int currentSize = m_points.size();
                             if (toBeAdded > 0)
                                 for (int i = m_points.size(); i < currentSize + toBeAdded; i++) {
                                     handlePointAdded(i);
                                 }
                         }
                     }
                 }
             }
             void XYChartItem::handlePointReplaced(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 Q_ASSERT(index>=0);
                 QPointF point = calculateGeometryPoint(index);
                 QVector<QPointF> points = m_points;
                 points.replace(index,point);
                 updateLayout(m_points,points,index);
                 update();
             }
             void XYChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_minX=minX;
                 m_maxX=maxX;
                 m_minY=minY;
                 m_maxY=maxY;
                 if (isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
                 updateLayout(m_points,points);
                 update();
             }
             void XYChartItem::handleGeometryChanged(const QRectF &rect)
             {
                 Q_ASSERT(rect.isValid());
                 m_size=rect.size();
                 m_clipRect=rect.translated(-rect.topLeft());
                 setPos(rect.topLeft());
                 if (isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
                 updateLayout(m_points,points);
                 update();
             }
             bool XYChartItem::isEmpty()
             {
-                return !m_clipRect.isValid() || qFuzzyIsNull(m_maxX - m_minX) || qFuzzyIsNull(m_maxY - m_minY);
+                return !m_clipRect.isValid() || qFuzzyIsNull(m_maxX - m_minX) || qFuzzyIsNull(m_maxY - m_minY) || m_series->points().isEmpty();
             }
             void XYChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit clicked(calculateDomainPoint(event->pos()));
             }
             #include "moc_xychartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

test/auto/qchart/tst_qchart.cpp +1 -5

             #include <QtTest/QtTest>
             #include <qchartview.h>
             #include <qlineseries.h>
             #include <qareaseries.h>
             #include <qscatterseries.h>
             #include <qsplineseries.h>
             #include <qpieseries.h>
             #include <qbarseries.h>
             #include <qpercentbarseries.h>
             #include <qstackedbarseries.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QAxis *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QChart::AnimationOption)
             Q_DECLARE_METATYPE(QBrush)
             Q_DECLARE_METATYPE(QPen)
             Q_DECLARE_METATYPE(QChart::ChartTheme)
             class tst_QChart : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qchart_data();
                 void qchart();
                 void addSeries_data();
                 void addSeries();
                 void animationOptions_data();
                 void animationOptions();
                 void axisX_data();
                 void axisX();
                 void axisY_data();
                 void axisY();
                 void backgroundBrush_data();
                 void backgroundBrush();
                 void backgroundPen_data();
                 void backgroundPen();
                 void isBackgroundVisible_data();
                 void isBackgroundVisible();
                 void legend_data();
                 void legend();
                 void margins_data();
                 void margins();
                 void removeAllSeries_data();
                 void removeAllSeries();
                 void removeSeries_data();
                 void removeSeries();
                 void scrollDown_data();
                 void scrollDown();
                 void scrollLeft_data();
                 void scrollLeft();
                 void scrollRight_data();
                 void scrollRight();
                 void scrollUp_data();
                 void scrollUp();
                 void theme_data();
                 void theme();
                 void title_data();
                 void title();
                 void titleBrush_data();
                 void titleBrush();
                 void titleFont_data();
                 void titleFont();
                 void zoomIn_data();
                 void zoomIn();
                 void zoomOut_data();
                 void zoomOut();
             private:
                 void createTestData();
             private:
                 QChartView* m_view;
                 QChart* m_chart;
             };
             void tst_QChart::initTestCase()
             {
             }
             void tst_QChart::cleanupTestCase()
             {
             }
             void tst_QChart::init()
             {
                 m_view = new QChartView(new QChart());
                 m_chart = m_view->chart();
             }
             void tst_QChart::createTestData()
             {
                 QLineSeries* series0 = new QLineSeries(this);
                 *series0 << QPointF(0, 0) << QPointF(100, 100);
                 m_chart->addSeries(series0);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             void tst_QChart::cleanup()
             {
                 delete m_view;
                 m_view = 0;
                 m_chart = 0;
             }
             void tst_QChart::qchart_data()
             {
             }
             void tst_QChart::qchart()
             {
                 QVERIFY(m_chart);
                 QVERIFY(m_chart->legend());
                 QVERIFY(!m_chart->legend()->isVisible());
                 QCOMPARE(m_chart->animationOptions(), QChart::NoAnimation);
                 QVERIFY(m_chart->axisX());
                 QVERIFY(m_chart->axisY());
                 QVERIFY(m_chart->backgroundBrush()!=QBrush());
                 QVERIFY(m_chart->backgroundPen()!=QPen());
                 QCOMPARE(m_chart->isBackgroundVisible(), true);
                 QVERIFY(m_chart->margins().top()>0);
                 QVERIFY(m_chart->margins().left()>0);
                 QVERIFY(m_chart->margins().right()>0);
                 QVERIFY(m_chart->margins().bottom()>0);
                 QCOMPARE(m_chart->theme(), QChart::ChartThemeLight);
                 QCOMPARE(m_chart->title(), QString());
                 //QCOMPARE(m_chart->titleBrush(),QBrush());
                 //QCOMPARE(m_chart->titleFont(),QFont());
                 m_chart->removeAllSeries();
                 m_chart->scrollDown();
                 m_chart->scrollLeft();
                 m_chart->scrollRight();
                 m_chart->scrollUp();
                 m_chart->zoomIn();
                 m_chart->zoomIn(QRectF());
                 m_chart->zoomOut();
             }
             void tst_QChart::addSeries_data()
             {
                 QTest::addColumn<QAbstractSeries *>("series");
                 QTest::addColumn<QAxis *>("axis");
                 QAbstractSeries* series0 = new QLineSeries(this);
                 QAbstractSeries* series1 = new QAreaSeries(static_cast<QLineSeries*>(series0));
                 QAbstractSeries* series2 = new QScatterSeries(this);
                 QAbstractSeries* series3 = new QSplineSeries(this);
                 QAbstractSeries* series4 = new QPieSeries(this);
                 QAbstractSeries* series5 = new QBarSeries(QBarCategories(),this);
                 QAbstractSeries* series6 = new QPercentBarSeries(QBarCategories(),this);
                 QAbstractSeries* series7 = new QStackedBarSeries(QBarCategories(),this);
                 QAxis* axis = new QAxis(this);
                 QTest::newRow("default axis: lineSeries") << series0 << (QAxis*) 0;
                 QTest::newRow("axis0: lineSeries") << series0 << axis;
                 QTest::newRow("default axis: areaSeries") << series1 << (QAxis*) 0;
                 QTest::newRow("axis: areaSeries") << series1 << axis;
                 QTest::newRow("default axis: scatterSeries") << series2 << (QAxis*) 0;
                 QTest::newRow("axis1: scatterSeries") << series2 << axis;
                 QTest::newRow("default axis: splineSeries") << series3 << (QAxis*) 0;
                 QTest::newRow("axis: splineSeries") << series3 << axis;
                 QTest::newRow("default axis: pieSeries") << series4 << (QAxis*) 0;
                 QTest::newRow("axis: pieSeries") << series4 << axis;
                 QTest::newRow("default axis: barSeries") << series5 << (QAxis*) 0;
                 QTest::newRow("axis: barSeries") << series5 << axis;
                 QTest::newRow("default axis: percentBarSeries") << series6 << (QAxis*) 0;
                 QTest::newRow("axis: barSeries") << series6 << axis;
                 QTest::newRow("default axis: stackedBarSeries") << series7 << (QAxis*) 0;
                 QTest::newRow("axis: barSeries") << series7 << axis;
             }
             void tst_QChart::addSeries()
             {
                 QFETCH(QAbstractSeries *, series);
                 QFETCH(QAxis *, axis);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 if(!axis) axis = m_chart->axisY();
                 m_chart->addSeries(series,axis);
                 QCOMPARE(m_chart->axisY(series),axis);
                 m_chart->removeSeries(series);
             }
             void tst_QChart::animationOptions_data()
             {
                 QTest::addColumn<QChart::AnimationOption>("animationOptions");
                 QTest::newRow("AllAnimations") << QChart::AllAnimations;
                 QTest::newRow("NoAnimation") << QChart::NoAnimation;
                 QTest::newRow("GridAxisAnimations") << QChart::GridAxisAnimations;
                 QTest::newRow("SeriesAnimations") << QChart::SeriesAnimations;
             }
             void tst_QChart::animationOptions()
             {
                 createTestData();
                 QFETCH(QChart::AnimationOption, animationOptions);
                 m_chart->setAnimationOptions(animationOptions);
                 QCOMPARE(m_chart->animationOptions(), animationOptions);
             }
             void tst_QChart::axisX_data()
             {
             }
             void tst_QChart::axisX()
             {
                 QVERIFY(m_chart->axisX());
                 QAxis* axis = m_chart->axisX();
                 createTestData();
                 //it should be the same axis
                 QCOMPARE(axis,m_chart->axisX());
             }
             void tst_QChart::axisY_data()
             {
                 QTest::addColumn<QAxis*>("axis0");
                 QTest::addColumn<QAxis*>("axis1");
                 QTest::addColumn<QAxis*>("axis2");
                 QTest::newRow("1 defualt, 2 optional") << (QAxis*)0 << new QAxis() << new QAxis();
                 QTest::newRow("3 optional") << new QAxis() << new QAxis() << new QAxis();
             }
             void tst_QChart::axisY()
             {
                 QFETCH(QAxis*, axis0);
                 QFETCH(QAxis*, axis1);
                 QFETCH(QAxis*, axis2);
                 QAxis* defaultAxisY = m_chart->axisY();
                 QVERIFY2(defaultAxisY, "Missing axisY.");
                 QLineSeries* series0 = new QLineSeries();
                 m_chart->addSeries(series0, axis0);
                 QLineSeries* series1 = new QLineSeries();
                 m_chart->addSeries(series1, axis1);
                 QLineSeries* series2 = new QLineSeries();
                 m_chart->addSeries(series2, axis2);
                 if (!axis0)
                     axis0 = defaultAxisY;
                 if (!axis1)
                     axis1 = defaultAxisY;
                 if (!axis2)
                     axis2 = defaultAxisY;
                 QVERIFY(m_chart->axisY(series0) == axis0);
                 QVERIFY(m_chart->axisY(series1) == axis1);
                 QVERIFY(m_chart->axisY(series2) == axis2);
             }
             void tst_QChart::backgroundBrush_data()
             {
                 QTest::addColumn<QBrush>("backgroundBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("white") << QBrush(Qt::white);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QChart::backgroundBrush()
             {
                 QFETCH(QBrush, backgroundBrush);
                 m_chart->setBackgroundBrush(backgroundBrush);
                 QCOMPARE(m_chart->backgroundBrush(), backgroundBrush);
             }
             void tst_QChart::backgroundPen_data()
             {
                 QTest::addColumn<QPen>("backgroundPen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("white") << QPen(Qt::white);
                 QTest::newRow("black") << QPen(Qt::black);
             }
             void tst_QChart::backgroundPen()
             {
                 QFETCH(QPen, backgroundPen);
                 m_chart->setBackgroundPen(backgroundPen);
                 QCOMPARE(m_chart->backgroundPen(), backgroundPen);
             }
             void tst_QChart::isBackgroundVisible_data()
             {
                 QTest::addColumn<bool>("isBackgroundVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QChart::isBackgroundVisible()
             {
                 QFETCH(bool, isBackgroundVisible);
                 m_chart->setBackgroundVisible(isBackgroundVisible);
                 QCOMPARE(m_chart->isBackgroundVisible(), isBackgroundVisible);
             }
             void tst_QChart::legend_data()
             {
             }
             void tst_QChart::legend()
             {
                 QVERIFY(m_chart->legend());
             }
             void tst_QChart::margins_data()
             {
             }
             void tst_QChart::margins()
-            {QTest::addColumn<int>("seriesCount");
-            QTest::newRow("0") << 0;
-            QTest::newRow("-1") << -1;
                 createTestData();
                 QRectF rect = m_chart->geometry();
                 QVERIFY(m_chart->margins().top()+m_chart->margins().bottom() < rect.height());
                 QVERIFY(m_chart->margins().left()+m_chart->margins().right() < rect.width());
             }
             void tst_QChart::removeAllSeries_data()
             {
             }
             void tst_QChart::removeAllSeries()
             {
                 QLineSeries* series0 = new QLineSeries(this);
                 QLineSeries* series1 = new QLineSeries(this);
                 QLineSeries* series2 = new QLineSeries(this);
                 m_chart->addSeries(series0);
                 m_chart->addSeries(series1);
                 m_chart->addSeries(series2);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY(m_chart->axisY(series0)!=0);
                 QVERIFY(m_chart->axisY(series1)!=0);
                 QVERIFY(m_chart->axisY(series2)!=0);
                 m_chart->removeAllSeries();
                 QVERIFY(m_chart->axisY(series0)==0);
                 QVERIFY(m_chart->axisY(series1)==0);
                 QVERIFY(m_chart->axisY(series2)==0);
             }
             void tst_QChart::removeSeries_data()
             {
                 addSeries_data();
             }
             void tst_QChart::removeSeries()
             {
                 QFETCH(QAbstractSeries *, series);
                 QFETCH(QAxis *, axis);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 if(!axis) axis = m_chart->axisY();
                 m_chart->addSeries(series,axis);
                 QCOMPARE(m_chart->axisY(series),axis);
                 m_chart->removeSeries(series);
                 QVERIFY(m_chart->axisY(series)==0);
             }
             void tst_QChart::scrollDown_data()
             {
             }
             void tst_QChart::scrollDown()
             {
                 createTestData();
                 qreal min = m_chart->axisY()->min();
                 m_chart->scrollDown();
                 QVERIFY(m_chart->axisY()->min()<min);
             }
             void tst_QChart::scrollLeft_data()
             {
             }
             void tst_QChart::scrollLeft()
             {
                 createTestData();
                 qreal min = m_chart->axisX()->min();
                 m_chart->scrollLeft();
                 QVERIFY(m_chart->axisX()->min()<min);
             }
             void tst_QChart::scrollRight_data()
             {
             }
             void tst_QChart::scrollRight()
             {
                 createTestData();
                 qreal min = m_chart->axisX()->min();
                 m_chart->scrollRight();
                 QVERIFY(m_chart->axisX()->min()>min);
             }
             void tst_QChart::scrollUp_data()
             {
             }
             void tst_QChart::scrollUp()
             {
                 createTestData();
                 qreal min = m_chart->axisY()->min();
                 m_chart->scrollUp();
                 QVERIFY(m_chart->axisY()->min()>min);
             }
             void tst_QChart::theme_data()
             {
                 QTest::addColumn<QChart::ChartTheme>("theme");
                 QTest::newRow("ChartThemeBlueCerulean") << QChart::ChartThemeBlueCerulean;
                 QTest::newRow("ChartThemeBlueIcy") << QChart::ChartThemeBlueIcy;
                 QTest::newRow("ChartThemeBlueNcs") << QChart::ChartThemeBlueNcs;
                 QTest::newRow("ChartThemeBrownSand") << QChart::ChartThemeBrownSand;
                 QTest::newRow("ChartThemeDark") << QChart::ChartThemeDark;
                 QTest::newRow("hartThemeHighContrast") << QChart::ChartThemeHighContrast;
                 QTest::newRow("ChartThemeLight") << QChart::ChartThemeLight;
             }
             void tst_QChart::theme()
             {
                 QFETCH(QChart::ChartTheme, theme);
                 createTestData();
                 m_chart->setTheme(theme);
                 QVERIFY(m_chart->theme()==theme);
             }
             void tst_QChart::title_data()
             {
                 QTest::addColumn<QString>("title");
                 QTest::newRow("null") << QString();
                 QTest::newRow("foo") << QString("foo");
             }
             void tst_QChart::title()
             {
                 QFETCH(QString, title);
                 m_chart->setTitle(title);
                 QCOMPARE(m_chart->title(), title);
             }
             void tst_QChart::titleBrush_data()
             {
                 QTest::addColumn<QBrush>("titleBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("white") << QBrush(Qt::white);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QChart::titleBrush()
             {
                 QFETCH(QBrush, titleBrush);
                 m_chart->setTitleBrush(titleBrush);
                 QCOMPARE(m_chart->titleBrush(), titleBrush);
             }
             void tst_QChart::titleFont_data()
             {
                 QTest::addColumn<QFont>("titleFont");
                 QTest::newRow("null") << QFont();
                 QTest::newRow("courier") << QFont("Courier", 8, QFont::Bold, true);
             }
             void tst_QChart::titleFont()
             {
                 QFETCH(QFont, titleFont);
                 m_chart->setTitleFont(titleFont);
                 QCOMPARE(m_chart->titleFont(), titleFont);
             }
             void tst_QChart::zoomIn_data()
             {
                 QTest::addColumn<QRectF>("rect");
                 QTest::newRow("null") << QRectF();
                 QTest::newRow("100x100") << QRectF(10,10,100,100);
                 QTest::newRow("200x200") << QRectF(10,10,200,200);
             }
             void tst_QChart::zoomIn()
             {
                 QFETCH(QRectF, rect);
                 createTestData();
                 QRectF marigns = m_chart->margins();
                 rect.adjust(marigns.left(),marigns.top(),-marigns.right(),-marigns.bottom());
                 qreal minX = m_chart->axisX()->min();
                 qreal minY = m_chart->axisY()->min();
                 qreal maxX = m_chart->axisX()->max();
                 qreal maxY = m_chart->axisY()->max();
                 m_chart->zoomIn(rect);
                 if(rect.isValid()){
                     QVERIFY(minX<m_chart->axisX()->min());
                     QVERIFY(maxX>m_chart->axisX()->max());
                     QVERIFY(minY<m_chart->axisY()->min());
                     QVERIFY(maxY>m_chart->axisY()->max());
                 }
             }
             void tst_QChart::zoomOut_data()
             {
             }
             void tst_QChart::zoomOut()
             {
                 createTestData();
                 qreal minX = m_chart->axisX()->min();
                 qreal minY = m_chart->axisY()->min();
                 qreal maxX = m_chart->axisX()->max();
                 qreal maxY = m_chart->axisY()->max();
                 m_chart->zoomIn();
                 QVERIFY(minX<m_chart->axisX()->min());
                 QVERIFY(maxX>m_chart->axisX()->max());
                 QVERIFY(minY<m_chart->axisY()->min());
                 QVERIFY(maxY>m_chart->axisY()->max());
                 m_chart->zoomOut();
                 QVERIFY(minX==m_chart->axisX()->min());
                 QVERIFY(maxX==m_chart->axisX()->max());
                 QVERIFY(minY==m_chart->axisY()->min());
                 QVERIFY(maxY==m_chart->axisY()->max());
             }
             QTEST_MAIN(tst_QChart)
             #include "tst_qchart.moc"

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