HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r258:09026acabba0

Adds RemoveAllSeries method to API

Michal Klocek -

r258:09026acabba0

parent child

Context file:

r258:09026acabba0

Collapse all files

src/chartdataset.cpp +21 -1

             #include "chartdataset_p.h"
             #include "qchartaxis.h"
             //series
             #include "qlinechartseries.h"
             #include "qbarchartseries.h"
             #include "qstackedbarchartseries.h"
             #include "qpercentbarchartseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QObject *parent):QObject(parent),
             m_axisX(new QChartAxis(this)),
             m_axisY(new QChartAxis(this)),
             m_domainIndex(0),
             m_axisXInitialized(false)
             {
             }
             ChartDataSet::~ChartDataSet()
             {
                 // TODO Auto-generated destructor stub
             }
             const Domain ChartDataSet::domain(QChartAxis *axisY) const
             {
             	int i = m_domainMap.count(axisY);
             	if(i == 0){
             		return Domain();
             	}
             	i = i - m_domainIndex -1;
                 return m_domainMap.values(axisY).at(i);
             }
             void ChartDataSet::addSeries(QChartSeries* series, QChartAxis *axisY)
             {
                 // TODO: we should check the series not already added
                 series->setParent(this); // take ownership
                 clearDomains();
                 if(axisY==0) axisY = m_axisY;
                 axisY->setParent(this); // take ownership
                 QList<QChartSeries*>  seriesList = m_seriesMap.values(axisY);
                 QList<Domain> domainList = m_domainMap.values(axisY);
                 Q_ASSERT(domainList.size()<=1);
                 Domain domain;
                 if(domainList.size()>0) domain = domainList.at(0);
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QLineChartSeries* xyseries = static_cast<QLineChartSeries*>(series);
                         for (int i = 0; i < xyseries->count(); i++)
                         {
                             qreal x = xyseries->x(i);
                             qreal y = xyseries->y(i);
                             domain.m_minX = qMin(domain.m_minX,x);
                             domain.m_minY = qMin(domain.m_minY,y);
                             domain.m_maxX = qMax(domain.m_maxX,x);
                             domain.m_maxY = qMax(domain.m_maxY,y);
                         }
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                     qDebug() << "QChartSeries::SeriesTypeBar";
                         QBarChartSeries* barSeries = static_cast<QBarChartSeries*>(series);
                         qreal x = barSeries->countCategories();
                         qreal y = barSeries->max();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                     qDebug() << "QChartSeries::SeriesTypeStackedBar";
                         QStackedBarChartSeries* stackedBarSeries = static_cast<QStackedBarChartSeries*>(series);
                         qreal x = stackedBarSeries->countCategories();
                         qreal y = stackedBarSeries->maxCategorySum();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                     qDebug() << "QChartSeries::SeriesTypePercentBar";
                         QPercentBarChartSeries* percentBarSeries = static_cast<QPercentBarChartSeries*>(series);
                         qreal x = percentBarSeries->countCategories();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = 0;
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = 100;
                         break;
                     }
                     case QChartSeries::SeriesTypePie: {
                         QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                         // TODO: domain stuff
                         break;
                     }
                     case QChartSeries::SeriesTypeScatter: {
                         QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                         Q_ASSERT(scatterSeries);
                         foreach (QPointF point, scatterSeries->data()) {
                             domain.m_minX = qMin(domain.m_minX, point.x());
                             domain.m_maxX = qMax(domain.m_maxX, point.x());
                             domain.m_minY = qMin(domain.m_minY, point.y());
                             domain.m_maxY = qMax(domain.m_maxY, point.y());
                         }
                         break;
                     }
                     default: {
                         qDebug()<<__FUNCTION__<<"type" << series->type()<<"not supported";
                         return;
                         break;
                     }
                 }
                 if(!m_domainMap.contains(axisY))
                 {
                     emit axisAdded(axisY);
                     QObject::connect(axisY,SIGNAL(minChanged(qreal)),this,SLOT(handleMinChanged(qreal)));
                     QObject::connect(axisY,SIGNAL(maxChanged(qreal)),this,SLOT(handleMaxChanged(qreal)));
                     QObject::connect(axisY,SIGNAL(ticksChanged(QChartAxis*)),this,SLOT(handleTickChanged(QChartAxis*)));
                 }
                 m_domainMap.replace(axisY,domain);
                 m_seriesMap.insert(axisY,series);
                 if(!m_axisXInitialized)
                 {
                     emit axisAdded(axisX());
                     QObject::connect(axisX(),SIGNAL(minChanged(qreal)),this,SLOT(handleMinChanged(qreal)));
                     QObject::connect(axisX(),SIGNAL(maxChanged(qreal)),this,SLOT(handleMaxChanged(qreal)));
                     QObject::connect(axisX(),SIGNAL(ticksChanged(QChartAxis*)),this,SLOT(handleTickChanged(QChartAxis*)));
                     m_axisXInitialized=true;
                 }
                 emit seriesAdded(series);
                 QStringList ylabels = createLabels(axisY,domain.m_minY,domain.m_maxY);
                 QStringList xlabels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
                 emit axisLabelsChanged(axisY,ylabels);
                 emit axisLabelsChanged(axisX(),xlabels);
                 emit seriesDomainChanged(series,domain);
             }
             void ChartDataSet::removeSeries(QChartSeries* series)
             {
                 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
                 foreach(QChartAxis* axis , keys) {
                     if(m_seriesMap.contains(axis,series)){
                         emit seriesRemoved(series);
                         m_seriesMap.remove(axis,series);
                         //remove axis if no longer there
-                        if(!m_seriesMap.contains(axis) && axis != m_axisY){
+                        if(!m_seriesMap.contains(axis)){
                             emit axisRemoved(axis);
                             m_domainMap.remove(axis);
+                            if(axis != m_axisY)
                             delete axis;
                         }
+                        series->setParent(0);
                         break;
                     }
                 }
             }
+            void ChartDataSet::removeAllSeries()
+            {
+                QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
+                foreach(QChartAxis* axis , keys) {
+                    QList<QChartSeries*> seriesList = m_seriesMap.values(axis);
+                    for(int i =0 ; i < seriesList.size();i++ )
+                    {
+                        emit seriesRemoved(seriesList.at(i));
+                        delete(seriesList.at(i));
+                    }
+                    m_seriesMap.remove(axis);
+                    m_domainMap.remove(axis);
+                    emit axisRemoved(axis);
+                    if(axis != m_axisY) delete axis;
+                    }
+                m_domainIndex=0;
+            }
             bool ChartDataSet::nextDomain()
             {
                 int limit = (m_domainMap.values().size()/m_domainMap.uniqueKeys().size())-1;
                 if (m_domainIndex < limit) {
                     m_domainIndex++;
                     setDomain(m_domainIndex);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             bool ChartDataSet::previousDomain()
             {
                 if (m_domainIndex > 0) {
                     m_domainIndex--;
                     setDomain(m_domainIndex);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             void ChartDataSet::setDomain(int index)
             {
                 QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
                 foreach (QChartAxis* axis , domainList) {
                     int i = m_domainMap.count(axis) - index -1;
                     Q_ASSERT(i>=0);
                     Domain domain = m_domainMap.values(axis).at(i);
                     QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
                     QList<QChartSeries*> seriesList = m_seriesMap.values(axis);
                     foreach(QChartSeries* series, seriesList) {
                         emit seriesDomainChanged(series,domain);
                     }
                     emit axisLabelsChanged(axis,labels);
                 }
                 Domain domain = m_domainMap.value(axisY());
                 QStringList labels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
                 emit axisLabelsChanged(axisX(),labels);
             }
             void ChartDataSet::clearDomains(int toIndex)
             {
                 Q_ASSERT(toIndex>=0);
                 m_domainIndex = toIndex;
                 QList<QChartAxis*> keys = m_domainMap.uniqueKeys();
                 foreach (QChartAxis* key , keys)
                 {
                     QList<Domain> domains = m_domainMap.values(key);
                     m_domainMap.remove(key);
                     int i = domains.size() - toIndex - 1;
                     while(i--){
                         domains.removeFirst();
                     }
                     for(int j=domains.size()-1; j>=0 ;j--)
                         m_domainMap.insert(key,domains.at(j));
                 }
             }
             void ChartDataSet::addDomain(const QRectF& rect, const QRectF& viewport)
             {
                 Q_ASSERT(rect.isValid());
                 Q_ASSERT(viewport.isValid());
                 clearDomains(m_domainIndex);
                 QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
                 foreach (QChartAxis* axis , domainList){
                     Domain domain(m_domainMap.value(axis).subDomain(rect,viewport.width(),viewport.height()));
                     QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
                     QList<QChartSeries*> seriesList = m_seriesMap.values(axis);
                     foreach(QChartSeries* series, seriesList){
                         emit seriesDomainChanged(series,domain);
                     }
                     emit axisLabelsChanged(axis,labels);
                     m_domainMap.insert(axis,domain);
                 }
                 Domain domain = m_domainMap.value(axisY());
                 QStringList labels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
                 emit axisLabelsChanged(axisX(),labels);
                 m_domainIndex++;
             }
             QChartAxis* ChartDataSet::axisY(QChartSeries* series) const
             {
                 if(series == 0) return m_axisY;
                 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
                 foreach(QChartAxis* axis , keys) {
                     if(m_seriesMap.contains(axis,series)){
                         return axis;
                     }
                 }
                 return 0;
             }
             QStringList ChartDataSet::createLabels(QChartAxis* axis,qreal min, qreal max)
             {
                 Q_ASSERT(max>=min);
                 QStringList labels;
                 int ticks = axis->ticksCount()-1;
                 for(int i=0; i<= ticks; i++){
                     qreal value = min + (i * (max - min)/ ticks);
                     QString label = axis->axisTickLabel(value);
                     if(label.isEmpty()){
                         labels << QString::number(value);
                     }else{
                         labels << label;
                     }
                 }
                 return labels;
             }
             void ChartDataSet::handleMinChanged(qreal min)
             {
             }
             void ChartDataSet::handleMaxChanged(qreal max)
             {
             }
             void ChartDataSet::handleTickChanged(QChartAxis* axis)
             {
                 Domain domain = m_domainMap.value(axisY());
                 if(axis==axisX()){
                     QStringList labels = createLabels(axis,domain.m_minX,domain.m_maxX);
                     emit axisLabelsChanged(axis,labels);
                 }else{
                     QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
                     emit axisLabelsChanged(axis,labels);
                 }
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset_p.h +1 0

             #ifndef CHARTDATASET_P_H_
             #define CHARTDATASET_P_H_
             #include "qchartseries.h"
             #include "domain_p.h"
             #include <QVector>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartAxis;
             class ChartDataSet : public QObject
             {
                 Q_OBJECT
             public:
                 ChartDataSet(QObject* parent=0);
                 virtual ~ChartDataSet();
                 void addSeries(QChartSeries* series,QChartAxis *axisY = 0);
                 void removeSeries(QChartSeries* series);
+                void removeAllSeries();
                 void addDomain(const QRectF& rect, const QRectF& viewport);
                 bool nextDomain();
                 bool previousDomain();
                 void clearDomains(int toIndex =0);
                 const Domain domain(QChartAxis *axisY) const;
                 int domainIndex() const {return m_domainIndex;}
                 QChartAxis* axisX() const { return m_axisX;};
                 QChartAxis* axisY(QChartSeries* series = 0) const;
             signals:
                 void seriesAdded(QChartSeries* series);
                 void seriesRemoved(QChartSeries* series);
                 void axisAdded(QChartAxis* axis);
                 void axisRemoved(QChartAxis* axis);
                 void axisLabelsChanged(QChartAxis* axis, const QStringList& labels);
                 void seriesDomainChanged(QChartSeries* series,const Domain& domain);
             private slots:
             	void handleMinChanged(qreal min);
             	void handleMaxChanged(qreal max);
             	void handleTickChanged(QChartAxis*);
             private:
                 void setDomain(int index);
                 QStringList createLabels(QChartAxis* axis,qreal min, qreal max);
             private:
                 QMultiMap<QChartAxis*, Domain> m_domainMap;
                 QMultiMap<QChartAxis*, QChartSeries*> m_seriesMap;
                 QChartAxis* m_axisX;
                 QChartAxis* m_axisY;
                 int m_domainIndex;
                 bool m_axisXInitialized;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTENGINE_P_H_ */

src/qchart.cpp +5 0

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
             m_backgroundItem(0),
             m_titleItem(0),
             m_dataset(new ChartDataSet(this)),
             m_presenter(new ChartPresenter(this,m_dataset))
             {
             }
             QChart::~QChart() {}
             void QChart::addSeries(QChartSeries* series,QChartAxis* axisY)
             {
                 m_dataset->addSeries(series,axisY);
             }
             void QChart::removeSeries(QChartSeries* series)
             {
                 m_dataset->removeSeries(series);
             }
+            void QChart::removeAllSeries()
+            {
+                m_dataset->removeAllSeries();
+            }
             void QChart::setChartBackgroundBrush(const QBrush& brush)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setBrush(brush);
                 m_backgroundItem->update();
             }
             void QChart::setChartBackgroundPen(const QPen& pen)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setPen(pen);
                 m_backgroundItem->update();
             }
             void QChart::setChartTitle(const QString& title)
             {
                 createChartTitleItem();
                 m_titleItem->setPlainText(title);
             }
             void QChart::setChartTitleFont(const QFont& font)
             {
                 createChartTitleItem();
                 m_titleItem->setFont(font);
             }
             void QChart::createChartBackgroundItem()
             {
                 if(!m_backgroundItem) {
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setZValue(-1);
                 }
             }
             void QChart::createChartTitleItem()
             {
                 if(!m_titleItem) m_titleItem = new QGraphicsTextItem(this);
             }
             int QChart::margin() const
             {
                 return m_presenter->margin();
             }
             void QChart::setMargin(int margin)
             {
                 m_presenter->setMargin(margin);
             }
             void QChart::setChartTheme(QChart::ChartTheme theme)
             {
                 m_presenter->setChartTheme(theme);
             }
             QChart::ChartTheme QChart::chartTheme() const
             {
                 return m_presenter->chartTheme();
             }
             void QChart::zoomIn()
             {
                 if (!m_dataset->nextDomain()) {
                     QRectF rect = m_presenter->geometry();
                     rect.setWidth(rect.width()/2);
                     rect.setHeight(rect.height()/2);
                     rect.moveCenter(m_presenter->geometry().center());
                     zoomIn(rect);
                 }
             }
             void QChart::zoomIn(const QRectF& rect)
             {
                 if(!rect.isValid()) return;
                    QRectF r = rect.normalized();
                    int margin = m_presenter->margin();
                    r.translate(-margin, -margin);
                    m_dataset->addDomain(r,m_presenter->geometry());
             }
             void QChart::zoomOut()
             {
                 m_dataset->previousDomain();
             }
             void QChart::zoomReset()
             {
                 m_dataset->clearDomains();
             }
             QChartAxis* QChart::axisX() const
             {
                 return m_dataset->axisX();
             }
             QChartAxis* QChart::axisY() const
             {
                 return m_dataset->axisY();
             }
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 m_rect = QRectF(QPoint(0,0),event->newSize());
                 QRectF rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),m_rect.top()/2 + margin()/2);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(rect);
                 }
                 QGraphicsWidget::resizeEvent(event);
                 update();
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +3 -2

             #ifndef CHART_H
             #define CHART_H
             #include <qchartglobal.h>
             #include <qchartseries.h>
             #include <QGraphicsWidget>
             #include <QLinearGradient>
             #include <QFont>
             class QGraphicsSceneResizeEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class AxisItem;
             class QChartSeries;
             class PlotDomain;
             class BarPresenter;
             class QChartAxis;
             class ChartTheme;
             class ChartItem;
             class ChartDataSet;
             class ChartPresenter;
             /*!
              * TODO: define the responsibilities
              */
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
             public:
                 enum ChartTheme {
                     /*! The default theme follows the GUI style of the Operating System */
                     ChartThemeDefault,
                     ChartThemeVanilla,
                     ChartThemeIcy,
                     ChartThemeGrayscale,
                     ChartThemeScientific,
                     //ChartThemeUnnamed1
                 };
             public:
                 QChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 ~QChart();
-                void addSeries(QChartSeries* series,QChartAxis *axisY=0);
+                void addSeries(QChartSeries* series,QChartAxis* axisY=0);// takes series ownership , takes axis ownership
-                void removeSeries(QChartSeries* series);
+                void removeSeries(QChartSeries* series); //returns ownership , deletes axis if no series attached
+                void removeAllSeries(); // deletes series and axis
                 void setMargin(int margin);
                 int margin() const;
                 void setChartTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme chartTheme() const;
                 void setChartTitle(const QString& title);
                 void setChartTitleFont(const QFont& font);
                 void setChartBackgroundBrush(const QBrush& brush);
                 void setChartBackgroundPen(const QPen& pen);
                 void zoomIn();
                 void zoomIn(const QRectF& rect);
                 void zoomOut();
                 void zoomReset();
                 QChartAxis* axisX() const;
                 QChartAxis* axisY() const;
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
             private:
                 inline void createChartBackgroundItem();
                 inline void createChartTitleItem();
             private:
                 Q_DISABLE_COPY(QChart)
                 QGraphicsRectItem* m_backgroundItem;
                 QGraphicsTextItem* m_titleItem;
                 QRectF m_rect;
                 ChartDataSet *m_dataset;
                 ChartPresenter *m_presenter;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchartview.cpp +5 0

             #include "qchartview.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             #include <QGraphicsView>
             #include <QGraphicsScene>
             #include <QRubberBand>
             #include <QResizeEvent>
             #include <QDebug>
             /*!
                 \class QChartView
                 \brief Chart widget.
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChartView::QChartView(QWidget *parent) :
             QGraphicsView(parent),
             m_scene(new QGraphicsScene(this)),
             m_chart(new QChart()),
             m_rubberBand(0),
             m_verticalRubberBand(false),
             m_horizonalRubberBand(false)
             {
                 setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setScene(m_scene);
                 m_chart->setMargin(50);
                 m_scene->addItem(m_chart);
                 setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
             }
             QChartView::~QChartView()
             {
             }
             void QChartView::resizeEvent(QResizeEvent *event)
             {
                 m_scene->setSceneRect(0,0,size().width(),size().height());
                 m_chart->resize(size());
                 QWidget::resizeEvent(event);
             }
             void QChartView::addSeries(QChartSeries* series,QChartAxis *axisY)
             {
                 m_chart->addSeries(series,axisY);
             }
             void QChartView::removeSeries(QChartSeries* series)
             {
                 m_chart->removeSeries(series);
             }
+            void QChartView::removeAllSeries()
+            {
+                m_chart->removeAllSeries();
+            }
             void QChartView::zoomIn()
             {
                 m_chart->zoomIn();
             }
             void QChartView::zoomIn(const QRect& rect)
             {
                 m_chart->zoomIn(rect);
             }
             void QChartView::zoomOut()
             {
                 m_chart->zoomOut();
             }
             int QChartView::margin() const
             {
                 return m_chart->margin();
             }
             void QChartView::setChartTitle(const QString& title)
             {
                 m_chart->setChartTitle(title);
             }
             void QChartView::setChartTitleFont(const QFont& font)
             {
                 m_chart->setChartTitleFont(font);
             }
             void QChartView::setChartBackgroundBrush(const QBrush& brush)
             {
                 m_chart->setChartBackgroundBrush(brush);
             }
             void QChartView::setChartBackgroundPen(const QPen& pen)
             {
                 m_chart->setChartBackgroundPen(pen);
             }
             void QChartView::setRubberBandPolicy(const RubberBandPolicy policy)
             {
                 switch(policy) {
                     case VerticalRubberBand:
                     m_verticalRubberBand = true;
                     m_horizonalRubberBand = false;
                     break;
                     case HorizonalRubberBand:
                     m_verticalRubberBand = false;
                     m_horizonalRubberBand = true;
                     break;
                     case RectangleRubberBand:
                     m_verticalRubberBand = true;
                     m_horizonalRubberBand = true;
                     break;
                     case NoRubberBand:
                     default:
                     delete m_rubberBand;
                     m_rubberBand=0;
                     m_horizonalRubberBand = false;
                     m_verticalRubberBand = false;
                     return;
                 }
                 if(!m_rubberBand) {
                     m_rubberBand = new QRubberBand(QRubberBand::Rectangle, this);
                     m_rubberBand->setEnabled(true);
                 }
             }
             QChartView::RubberBandPolicy QChartView::rubberBandPolicy() const
             {
                 if(m_horizonalRubberBand && m_verticalRubberBand) return RectangleRubberBand;
                 if(m_horizonalRubberBand) return HorizonalRubberBand;
                 if(m_verticalRubberBand) return VerticalRubberBand;
                 return NoRubberBand;
             }
             void QChartView::mousePressEvent(QMouseEvent *event)
             {
                 if(m_rubberBand && m_rubberBand->isEnabled() && event->button() == Qt::LeftButton) {
                     int margin = m_chart->margin();
                     QRect rect(margin, margin, width() - 2 * margin, height() - 2 * margin);
                     if (rect.contains(event->pos())) {
                         m_rubberBandOrigin = event->pos();
                         m_rubberBand->setGeometry(QRect(m_rubberBandOrigin, QSize()));
                         m_rubberBand->show();
                         event->accept();
                     }
                 }
             }
             void QChartView::mouseMoveEvent(QMouseEvent *event)
             {
                 if(m_rubberBand && m_rubberBand->isVisible()) {
                     int margin = m_chart->margin();
                     QRect rect(margin, margin, width() - 2 * margin, height() - 2 * margin);
                     int width = event->pos().x() - m_rubberBandOrigin.x();
                     int height = event->pos().y() - m_rubberBandOrigin.y();
                     if(!m_verticalRubberBand) {
                         m_rubberBandOrigin.setY(rect.top());
                         height = rect.height();
                     }
                     if(!m_horizonalRubberBand) {
                         m_rubberBandOrigin.setX(rect.left());
                         width= rect.width();
                     }
                     m_rubberBand->setGeometry(QRect(m_rubberBandOrigin.x(),m_rubberBandOrigin.y(), width,height).normalized());
                 }
                 else {
                     QGraphicsView::mouseMoveEvent(event);
                 }
             }
             void QChartView::mouseReleaseEvent(QMouseEvent *event)
             {
                 if(m_rubberBand) {
                     if (event->button() == Qt::LeftButton && m_rubberBand->isVisible()) {
                         m_rubberBand->hide();
                         QRect rect = m_rubberBand->geometry();
                         m_chart->zoomIn(rect);
                         event->accept();
                     }
                     if(event->button()==Qt::RightButton)
                     m_chart->zoomReset();
                 }
                 else {
                     QGraphicsView::mouseReleaseEvent(event);
                 }
             }
             void QChartView::keyPressEvent(QKeyEvent *event)
             {
                 switch (event->key()) {
                     case Qt::Key_Plus:
                     zoomIn();
                     break;
                     case Qt::Key_Minus:
                     zoomOut();
                     break;
                     default:
                     QGraphicsView::keyPressEvent(event);
                     break;
                 }
             }
             void QChartView::setChartTheme(QChart::ChartTheme theme)
             {
                 m_chart->setChartTheme(theme);
             }
             QChart::ChartTheme QChartView::chartTheme() const
             {
                 return m_chart->chartTheme();
             }
             QChartAxis* QChartView::axisX() const
             {
                 return m_chart->axisX();
             }
             QChartAxis* QChartView::axisY() const
             {
                 return m_chart->axisY();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartview.h +3 -2

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

test/auto/chartdataset/tst_chartdataset.cpp +73 -2

             #include <QtTest/QtTest>
             #include <qchartaxis.h>
             #include <qchartseries.h>
             #include <qlinechartseries.h>
             #include <private/chartdataset_p.h>
             #include <private/domain_p.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(Domain)
             Q_DECLARE_METATYPE(QChartAxis*)
             Q_DECLARE_METATYPE(QChartSeries*)
             Q_DECLARE_METATYPE(QLineChartSeries*)
             class tst_ChartDataSet: public QObject {
             Q_OBJECT
             public slots:
             	void initTestCase();
             	void cleanupTestCase();
             	void init();
             	void cleanup();
             private slots:
             	void chartdataset_data();
             	void chartdataset();
             	void addDomain_data();
             	void addDomain();
             	void addSeries_data();
             	void addSeries();
             	void axisY_data();
             	void axisY();
             	void clearDomains_data();
             	void clearDomains();
             	void domain_data();
             	void domain();
             	void nextpreviousDomain_data();
             	void nextpreviousDomain();
             	void removeSeries_data();
             	void removeSeries();
+            	void removeAllSeries_data();
+            	void removeAllSeries();
             };
             void tst_ChartDataSet::initTestCase()
             {
             	qRegisterMetaType<Domain>("Domain");
             	qRegisterMetaType<QChartAxis*>();
             	qRegisterMetaType<QChartSeries*>();
             }
             void tst_ChartDataSet::cleanupTestCase()
             {
             }
             void tst_ChartDataSet::init()
             {
             }
             void tst_ChartDataSet::cleanup()
             {
             }
             void tst_ChartDataSet::chartdataset_data()
             {
             }
             void tst_ChartDataSet::chartdataset()
             {
             	ChartDataSet dataSet;
             	QVERIFY2(dataSet.axisX(), "Missing axisX.");
             	QVERIFY2(dataSet.axisY(), "Missing axisY.");
             	//check if not dangling pointer
             	dataSet.axisX()->objectName();
             	dataSet.axisY()->objectName();
             	QVERIFY(dataSet.domain(dataSet.axisX())==Domain());
             	QVERIFY(dataSet.domain(dataSet.axisY())==Domain());
             	QCOMPARE(dataSet.domainIndex(), 0);
             }
             void tst_ChartDataSet::addDomain_data()
             {
             	QTest::addColumn<QRectF>("rect");
             	QTest::addColumn<QRectF>("viewport");
             	QTest::newRow("400x400,1000x1000") << QRectF(200, 200, 600, 600)
             			<< QRectF(0, 0, 1000, 1000);
             	QTest::newRow("600x600,1000x1000") << QRectF(100, 100, 700, 700)
             			<< QRectF(0, 0, 1000, 1000);
             	QTest::newRow("200x200,1000x1000") << QRectF(400, 400, 600, 600)
             			<< QRectF(0, 0, 1000, 1000);
             }
             void tst_ChartDataSet::addDomain()
             {
             	QFETCH(QRectF, rect);
             	QFETCH(QRectF, viewport);
             	ChartDataSet dataSet;
             	Domain domain1(0, 1000, 0, 1000);
             	QLineChartSeries series;
             	series.add(0, 0);
             	series.add(1000, 1000);
             	dataSet.addSeries(&series);
             	QCOMPARE(dataSet.domainIndex(), 0);
             	QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
             	QSignalSpy spy1(&dataSet,
             			SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
             	QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
             	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QChartSeries*)));
             	QSignalSpy spy4(&dataSet,
             			SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
             	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
             	Domain domain2 = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain1 == domain2);
             	dataSet.addDomain(rect, viewport);
             	QCOMPARE(dataSet.domainIndex(), 1);
             	Domain domain3 = dataSet.domain(dataSet.axisY());
             	Domain domain4 = domain1.subDomain(rect, viewport.width(),
             			viewport.height());
             	QVERIFY(domain3 == domain4);
             	QCOMPARE(spy0.count(), 0);
             	QCOMPARE(spy1.count(), 2);
             	QCOMPARE(spy2.count(), 0);
             	QCOMPARE(spy3.count(), 0);
             	QCOMPARE(spy4.count(), 1);
             	QCOMPARE(spy5.count(), 0);
             }
             void tst_ChartDataSet::addSeries_data()
             {
             	QTest::addColumn<int>("seriesCount");
             	QTest::addColumn<int>("axisYCount");
             	QTest::newRow("2 series, default axis") << 2 << 0;
             	QTest::newRow("2 series, 2 new axis") << 2 << 2;
             	QTest::newRow("2 series, 1 new axis") << 2 << 2;
             	QTest::newRow("3 series, 3 new axis") << 3 << 3;
             	QTest::newRow("3 series, 2 new axis") << 3 << 2;
             	QTest::newRow("3 series, 1 new axis") << 3 << 1;
             }
             void tst_ChartDataSet::addSeries()
             {
             	QFETCH(int, seriesCount);
             	QFETCH(int, axisYCount);
             	ChartDataSet dataSet;
             	QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
             	QSignalSpy spy1(&dataSet,
             			SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
             	QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
             	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QChartSeries*)));
             	QSignalSpy spy4(&dataSet,
             			SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
             	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
             	QList<QChartAxis*> axisList;
             	for (int i = 0; i < axisYCount; i++) {
             		QChartAxis* axis = new QChartAxis();
             		axisList << axis;
             	}
             	QList<QChartAxis*>::iterator iterator = axisList.begin();
             	for (int i = 0; i < seriesCount; i++) {
             		QChartAxis* axisY = 0;
             		QLineChartSeries* series = new QLineChartSeries();
             		if (iterator != axisList.end()) {
             			axisY = *iterator;
             			iterator++;
             		} else if (axisList.count() > 0) {
             			iterator--;
             			axisY = *iterator;
             			iterator++;
             		}
             		dataSet.addSeries(series, axisY);
             	}
             	//default axis
             	if (axisYCount == 0)
             		axisYCount+=2;
             	else
             	    axisYCount++;
             	QCOMPARE(spy0.count(), axisYCount);
             	QCOMPARE(spy1.count(), seriesCount*2);
             	QCOMPARE(spy2.count(), 0);
             	QCOMPARE(spy3.count(), seriesCount);
             	QCOMPARE(spy4.count(), seriesCount);
             	QCOMPARE(spy5.count(), 0);
             	QCOMPARE(dataSet.domainIndex(), 0);
             }
             void tst_ChartDataSet::axisY_data()
             {
             	QTest::addColumn<QChartAxis*>("axisY");
             	QTest::newRow("axisY1") << new QChartAxis();
             	QTest::newRow("axisY2") << new QChartAxis();
             }
             void tst_ChartDataSet::axisY()
             {
             	QFETCH(QChartAxis*, axisY);
             	ChartDataSet dataSet;
             	QChartAxis* defaultAxisY = dataSet.axisY();
             	QVERIFY2(defaultAxisY, "Missing axisY.");
             	QLineChartSeries* series1 = new QLineChartSeries();
             	dataSet.addSeries(series1);
             	QLineChartSeries* series2 = new QLineChartSeries();
             	dataSet.addSeries(series2, axisY);
             	QVERIFY(dataSet.axisY(series1) == defaultAxisY);
             	QVERIFY(dataSet.axisY(series2) == axisY);
             }
             void tst_ChartDataSet::clearDomains_data()
             {
             	QTest::addColumn<int>("indexCount");
             	QTest::newRow("0") << 0;
             	QTest::newRow("1") << 1;
             	QTest::newRow("5") << 2;
             	QTest::newRow("8") << 3;
             }
             void tst_ChartDataSet::clearDomains()
             {
             	QFETCH(int, indexCount);
             	Domain domain1(0, 100, 0, 100);
             	QLineChartSeries* series = new QLineChartSeries();
             	series->add(0, 0);
             	series->add(100, 100);
             	ChartDataSet dataSet;
             	QCOMPARE(dataSet.domainIndex(), 0);
             	dataSet.addSeries(series);
             	Domain domain2 = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain2 == domain1);
             	QList<Domain> domains;
             	domains << domain1;
             	for (int i = 0; i < indexCount; i++) {
             		dataSet.addDomain(QRect(0, 0, 10, 10), QRect(0, 0, 100, 100));
             		domains << dataSet.domain(dataSet.axisY());
             	}
             	QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
             	QSignalSpy spy1(&dataSet,
             			SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
             	QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
             	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QChartSeries*)));
             	QSignalSpy spy4(&dataSet,
             			SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
             	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
             	dataSet.clearDomains(indexCount);
             	QCOMPARE(dataSet.domainIndex(), indexCount);
             	domain2 = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain2 == domains.at(indexCount));
             	QCOMPARE(spy0.count(), 0);
             	QCOMPARE(spy1.count(), 0);
             	QCOMPARE(spy2.count(), 0);
             	QCOMPARE(spy3.count(), 0);
             	QCOMPARE(spy4.count(), 0);
             	QCOMPARE(spy5.count(), 0);
             }
             void tst_ChartDataSet::domain_data()
             {
             	QTest::addColumn<Domain>("domain1");
             	QTest::addColumn<Domain>("domain2");
             	QTest::addColumn<Domain>("domain3");
             	QTest::addColumn<Domain>("domain");
             	QTest::newRow("Domain(0,10,0,10)") << Domain(0, 10, 0, 10)
             			<< Domain(0, 5, 0, 5) << Domain(0, 3, 0, 3) << Domain(0, 10, 0, 10);
             	QTest::newRow("Domain(-1,11,0,11)") << Domain(-1, 10, 0, 10)
             			<< Domain(0, 11, 0, 11) << Domain(0, 3, 0, 3)
             			<< Domain(-1, 11, 0, 11);
             	QTest::newRow("Domain(-5,5,1,8)") << Domain(-5, 0, 1, 1)
             			<< Domain(0, 5, 0, 8) << Domain(1, 2, 1, 2) << Domain(-5, 5, 0, 8);
             }
             void tst_ChartDataSet::domain()
             {
             	QFETCH(Domain, domain1);
             	QFETCH(Domain, domain2);
             	QFETCH(Domain, domain3);
             	QFETCH(Domain, domain);
             	ChartDataSet dataSet;
             	QLineChartSeries* series1 = new QLineChartSeries();
             	series1->add(domain1.m_minX, domain1.m_minY);
             	series1->add(domain1.m_maxX, domain1.m_maxY);
             	QLineChartSeries* series2 = new QLineChartSeries();
             	series2->add(domain2.m_minX, domain2.m_minY);
             	series2->add(domain2.m_maxX, domain2.m_maxY);
             	QLineChartSeries* series3 = new QLineChartSeries();
             	series3->add(domain3.m_minX, domain3.m_minY);
             	series3->add(domain3.m_maxX, domain3.m_maxY);
             	QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
             	QSignalSpy spy1(&dataSet,
             			SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
             	QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
             	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QChartSeries*)));
             	QSignalSpy spy4(&dataSet,
             			SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
             	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
             	dataSet.addSeries(series1);
             	dataSet.addSeries(series2);
             	dataSet.addSeries(series3);
             	QCOMPARE(dataSet.domainIndex(), 0);
             	QVERIFY2(dataSet.domain(dataSet.axisY()) == domain, "Domain not equal");
             	QCOMPARE(spy0.count(), 2);
             	QCOMPARE(spy1.count(), 6);
             	QCOMPARE(spy2.count(), 0);
             	QCOMPARE(spy3.count(), 3);
             	QCOMPARE(spy4.count(), 3);
             	QCOMPARE(spy5.count(), 0);
             }
             void tst_ChartDataSet::nextpreviousDomain_data()
             {
             	QTest::addColumn<QRectF>("rect");
             	QTest::addColumn<QRectF>("viewport");
             	QTest::newRow("400x400,1000x1000") << QRectF(200, 200, 600, 600)
             			<< QRectF(0, 0, 1000, 1000);
             	QTest::newRow("600x600,1000x1000") << QRectF(100, 100, 700, 700)
             			<< QRectF(0, 0, 1000, 1000);
             	QTest::newRow("200x200,1000x1000") << QRectF(400, 400, 600, 600)
             			<< QRectF(0, 0, 1000, 1000);
             }
             void tst_ChartDataSet::nextpreviousDomain()
             {
             	QFETCH(QRectF, rect);
             	QFETCH(QRectF, viewport);
             	ChartDataSet dataSet;
             	Domain domain1(0, 1000, 0, 1000);
             	QLineChartSeries* series = new QLineChartSeries();
             	series->add(0, 0);
             	series->add(1000, 1000);
             	dataSet.addSeries(series);
             	QCOMPARE(dataSet.domainIndex(), 0);
             	Domain domain2 = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain1 == domain2);
             	dataSet.addDomain(rect, viewport);
             	QCOMPARE(dataSet.domainIndex(), 1);
             	Domain domain3 = dataSet.domain(dataSet.axisY());
             	Domain domain4 = domain1.subDomain(rect, viewport.width(),
             			viewport.height());
             	QVERIFY(domain3 == domain4);
             	dataSet.addDomain(rect, viewport);
             	QCOMPARE(dataSet.domainIndex(), 2);
             	Domain domain5 = dataSet.domain(dataSet.axisY());
             	Domain domain6 = domain3.subDomain(rect, viewport.width(),
             			viewport.height());
             	QVERIFY(domain5 == domain6);
             	dataSet.addDomain(rect, viewport);
             	QCOMPARE(dataSet.domainIndex(), 3);
             	Domain domain7 = dataSet.domain(dataSet.axisY());
             	Domain domain8 = domain5.subDomain(rect, viewport.width(),
             			viewport.height());
             	QVERIFY(domain7 == domain8);
             	QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
             	QSignalSpy spy1(&dataSet,
             			SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
             	QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
             	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QChartSeries*)));
             	QSignalSpy spy4(&dataSet,
             			SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
             	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
             	Domain domain;
             	bool previous = dataSet.previousDomain();
             	QCOMPARE(previous, true);
             	QCOMPARE(dataSet.domainIndex(), 2);
             	domain = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain == domain5);
             	previous = dataSet.previousDomain();
             	QCOMPARE(previous, true);
             	QCOMPARE(dataSet.domainIndex(), 1);
             	domain = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain == domain3);
             	previous = dataSet.previousDomain();
             	QCOMPARE(previous, true);
             	QCOMPARE(dataSet.domainIndex(), 0);
             	domain = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain == domain1);
             	previous = dataSet.previousDomain();
             	QCOMPARE(previous, false);
             	QCOMPARE(dataSet.domainIndex(), 0);
             	domain = dataSet.domain(dataSet.axisY());
             	QVERIFY(domain == domain1);
             	bool next = dataSet.nextDomain();
             	QCOMPARE(next, true);
             	QCOMPARE(dataSet.domainIndex(),1);
             	next = dataSet.nextDomain();
             	QCOMPARE(next, true);
             	QCOMPARE(dataSet.domainIndex(),2);
             	next = dataSet.nextDomain();
             	QCOMPARE(next, true);
             	QCOMPARE(dataSet.domainIndex(),3);
             	next = dataSet.nextDomain();
             	QCOMPARE(next, false);
             	QCOMPARE(dataSet.domainIndex(),3);
             	QCOMPARE(spy0.count(), 0);
             	QCOMPARE(spy1.count(), 12);
             	QCOMPARE(spy2.count(), 0);
             	QCOMPARE(spy3.count(), 0);
             	QCOMPARE(spy4.count(), 6);
             	QCOMPARE(spy5.count(), 0);
             }
             void tst_ChartDataSet::removeSeries_data()
             {
             	QTest::addColumn<int>("seriesCount");
             	QTest::addColumn<int>("axisYCount");
             	QTest::newRow("2 series, default axis") << 2 << 0;
             	QTest::newRow("2 series, 2 new axis") << 2 << 2;
             	QTest::newRow("2 series, 1 new axis") << 2 << 2;
             	QTest::newRow("3 series, 3 new axis") << 3 << 3;
             	QTest::newRow("3 series, 2 new axis") << 3 << 2;
             	QTest::newRow("3 series, 1 new axis") << 3 << 1;
             }
             void tst_ChartDataSet::removeSeries()
             {
             	QFETCH(int, seriesCount);
             	QFETCH(int, axisYCount);
             	ChartDataSet dataSet;
             	QList<QChartAxis*> axisList;
             	QList<QChartSeries*> seriesList;
             	for (int i = 0; i < axisYCount; i++) {
             		QChartAxis* axis = new QChartAxis();
             		axisList << axis;
             	}
             	QList<QChartAxis*>::iterator iterator = axisList.begin();
             	for (int i = 0; i < seriesCount; i++) {
             		QChartAxis* axisY = 0;
             		QLineChartSeries* series = new QLineChartSeries();
             		if (iterator != axisList.end()) {
             			axisY = *iterator;
             			iterator++;
             		} else if (axisList.count() > 0) {
             			iterator--;
             			axisY = *iterator;
             			iterator++;
             		}
             		dataSet.addSeries(series, axisY);
             		seriesList << series;
             	}
             	QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
             	QSignalSpy spy1(&dataSet,
             			SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
             	QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
             	QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QChartSeries*)));
             	QSignalSpy spy4(&dataSet,
             			SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
             	QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
             	for (int i = 0; i < seriesCount; i++) {
             		dataSet.removeSeries(seriesList.at(i));
             	}
+                //default axis
+                if (axisYCount == 0)
+                    axisYCount++;
             	QCOMPARE(spy0.count(), 0);
             	QCOMPARE(spy1.count(), 0);
             	QCOMPARE(spy2.count(), axisYCount);
             	QCOMPARE(spy3.count(), 0);
             	QCOMPARE(spy4.count(), 0);
             	QCOMPARE(spy5.count(), seriesCount);
             	QCOMPARE(dataSet.domainIndex(), 0);
+            	qDeleteAll(seriesList);
+            }
+            void tst_ChartDataSet::removeAllSeries_data()
+            {
+                QTest::addColumn<int>("seriesCount");
+                QTest::addColumn<int>("axisYCount");
+                QTest::newRow("2 series, default axis") << 2 << 0;
+                QTest::newRow("2 series, 2 new axis") << 2 << 2;
+                QTest::newRow("2 series, 1 new axis") << 2 << 2;
+                QTest::newRow("3 series, 3 new axis") << 3 << 3;
+                QTest::newRow("3 series, 2 new axis") << 3 << 2;
+                QTest::newRow("3 series, 1 new axis") << 3 << 1;
             }
+            void tst_ChartDataSet::removeAllSeries()
+            {
+                QFETCH(int, seriesCount);
+                QFETCH(int, axisYCount);
+                ChartDataSet dataSet;
+                QList<QChartAxis*> axisList;
+                for (int i = 0; i < axisYCount; i++) {
+                    QChartAxis* axis = new QChartAxis();
+                    axisList << axis;
+                }
+                QList<QChartAxis*>::iterator iterator = axisList.begin();
+                for (int i = 0; i < seriesCount; i++) {
+                    QChartAxis* axisY = 0;
+                    QLineChartSeries* series = new QLineChartSeries();
+                    if (iterator != axisList.end()) {
+                        axisY = *iterator;
+                        iterator++;
+                    } else if (axisList.count() > 0) {
+                        iterator--;
+                        axisY = *iterator;
+                        iterator++;
+                    }
+                    dataSet.addSeries(series, axisY);
+                }
+                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
+                QSignalSpy spy1(&dataSet, SIGNAL(axisLabelsChanged(QChartAxis*, QStringList const&)));
+                QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
+                QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QChartSeries*)));
+                QSignalSpy spy4(&dataSet, SIGNAL(seriesDomainChanged(QChartSeries*, Domain const&)));
+                QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QChartSeries*)));
+                dataSet.removeAllSeries();
+                //default axis
+                if (axisYCount == 0)
+                    axisYCount++;
+                QCOMPARE(spy0.count(), 0);
+                QCOMPARE(spy1.count(), 0);
+                QCOMPARE(spy2.count(), axisYCount);
+                QCOMPARE(spy3.count(), 0);
+                QCOMPARE(spy4.count(), 0);
+                QCOMPARE(spy5.count(), seriesCount);
+                QCOMPARE(dataSet.domainIndex(), 0);
+            }
             QTEST_MAIN(tst_ChartDataSet)
             #include "tst_chartdataset.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