HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1057:d444309c9f1b

Fixes and improvments to series API...

Michal Klocek -

r1057:d444309c9f1b

parent child

Context file:

r1057:d444309c9f1b

Collapse all files

demos/chartthemes/themewidget.cpp +4 -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 "themewidget.h"
             #include <QChartView>
             #include <QPieSeries>
             #include <QPieSlice>
             #include <QBarSeries>
             #include <QPercentBarSeries>
             #include <QStackedBarSeries>
             #include <QBarSet>
             #include <QLineSeries>
             #include <QSplineSeries>
             #include <QScatterSeries>
             #include <QAreaSeries>
             #include <QLegend>
             #include <QGridLayout>
             #include <QFormLayout>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGroupBox>
             #include <QLabel>
             #include <QTime>
             ThemeWidget::ThemeWidget(QWidget* parent) :
                 QWidget(parent),
                 m_listCount(3),
                 m_valueMax(10),
                 m_valueCount(7),
                 m_dataTable(generateRandomData(m_listCount,m_valueMax,m_valueCount)),
                 m_themeComboBox(createThemeBox()),
                 m_antialiasCheckBox(new QCheckBox("Anti-aliasing")),
                 m_animatedComboBox(createAnimationBox()),
                 m_legendComboBox(createLegendBox())
             {
                 connectSignals();
                 // create layout
                 QGridLayout* baseLayout = new QGridLayout();
                 QHBoxLayout *settingsLayout = new QHBoxLayout();
                 settingsLayout->addWidget(new QLabel("Theme:"));
                 settingsLayout->addWidget(m_themeComboBox);
                 settingsLayout->addWidget(new QLabel("Animation:"));
                 settingsLayout->addWidget(m_animatedComboBox);
                 settingsLayout->addWidget(new QLabel("Legend:"));
                 settingsLayout->addWidget(m_legendComboBox);
                 settingsLayout->addWidget(m_antialiasCheckBox);
                 settingsLayout->addStretch();
                 baseLayout->addLayout(settingsLayout, 0, 0, 1, 3);
                 //create charts
                 QChartView *chartView;
                 chartView = new QChartView(createAreaChart());
                 baseLayout->addWidget(chartView, 1, 0);
                 m_charts << chartView;
                 chartView = new QChartView(createBarChart(m_valueCount));
                 baseLayout->addWidget(chartView, 1, 1);
                 m_charts << chartView;
                 chartView = new QChartView(createLineChart());
                 baseLayout->addWidget(chartView, 1, 2);
                 m_charts << chartView;
                 chartView = new QChartView(createPieChart());
                 chartView->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored); // funny things happen if the pie slice labels no not fit the screen...
                 baseLayout->addWidget(chartView, 2, 0);
                 m_charts << chartView;
                 chartView = new QChartView(createSplineChart());
                 baseLayout->addWidget(chartView, 2, 1);
                 m_charts << chartView;
                 chartView = new QChartView(createScatterChart());
                 baseLayout->addWidget(chartView, 2, 2);
                 m_charts << chartView;
                 setLayout(baseLayout);
                 // Set defaults
                 m_antialiasCheckBox->setChecked(true);
                 updateUI();
             }
             ThemeWidget::~ThemeWidget()
             {
             }
             void ThemeWidget::connectSignals()
             {
                 connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 connect(m_antialiasCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateUI()));
                 connect(m_animatedComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 connect(m_legendComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
             }
             DataTable ThemeWidget::generateRandomData(int listCount,int valueMax,int valueCount) const
             {
                 DataTable dataTable;
                 // set seed for random stuff
                 qsrand(QTime(0, 0, 0).secsTo(QTime::currentTime()));
                 // generate random data
                 for (int i(0); i < listCount; i++) {
                     DataList dataList;
                     qreal yValue(0);
                     for (int j(0); j < valueCount; j++) {
                         yValue = yValue + (qreal) (qrand() % valueMax) / (qreal) valueCount;
                         QPointF value((j + (qreal) rand() / (qreal) RAND_MAX) * ((qreal) m_valueMax / (qreal) valueCount),
                                       yValue);
                         QString label = "Slice " + QString::number(i) + ":" + QString::number(j);
                         dataList << Data(value, label);
                     }
                     dataTable << dataList;
                 }
                 return dataTable;
             }
             QComboBox* ThemeWidget::createThemeBox() const
             {
                 // settings layout
                 QComboBox* themeComboBox = new QComboBox();
                 themeComboBox->addItem("Light", QChart::ChartThemeLight);
                 themeComboBox->addItem("Blue Cerulean", QChart::ChartThemeBlueCerulean);
                 themeComboBox->addItem("Dark", QChart::ChartThemeDark);
                 themeComboBox->addItem("Brown Sand", QChart::ChartThemeBrownSand);
                 themeComboBox->addItem("Blue NCS", QChart::ChartThemeBlueNcs);
                 themeComboBox->addItem("High Contrast", QChart::ChartThemeHighContrast);
                 themeComboBox->addItem("Blue Icy", QChart::ChartThemeBlueIcy);
                 return themeComboBox;
             }
             QComboBox* ThemeWidget::createAnimationBox() const
             {
                 // settings layout
                 QComboBox* animationComboBox = new QComboBox();
                 animationComboBox->addItem("No Animations", QChart::NoAnimation);
                 animationComboBox->addItem("GridAxis Animations", QChart::GridAxisAnimations);
                 animationComboBox->addItem("Series Animations", QChart::SeriesAnimations);
                 animationComboBox->addItem("All Animations", QChart::AllAnimations);
                 return animationComboBox;
             }
             QComboBox* ThemeWidget::createLegendBox() const
             {
                 QComboBox* legendComboBox = new QComboBox();
                 legendComboBox->addItem("No Legend ", 0);
                 legendComboBox->addItem("Legend Top", QLegend::AlignmentTop);
                 legendComboBox->addItem("Legend Bottom", QLegend::AlignmentBottom);
                 legendComboBox->addItem("Legend Left", QLegend::AlignmentLeft);
                 legendComboBox->addItem("Legend Right", QLegend::AlignmentRight);
                 return legendComboBox;
             }
             QChart* ThemeWidget::createAreaChart() const
             {
                 QChart *chart = new QChart();
                 chart->axisX()->setNiceNumbersEnabled(true);
                 chart->axisY()->setNiceNumbersEnabled(true);
                 chart->setTitle("Area chart");
                 // The lower series initialized to zero values
                 QLineSeries *lowerSeries = 0;
                 QString name("Series ");
                 int nameIndex = 0;
                 for (int i(0); i < m_dataTable.count(); i++) {
                     QLineSeries *upperSeries = new QLineSeries(chart);
                     for (int j(0); j < m_dataTable[i].count(); j++) {
                         Data data = m_dataTable[i].at(j);
-                        if (lowerSeries)
+                        if (lowerSeries){
-                            upperSeries->append(QPointF(j, lowerSeries->y(i) + data.first.y()));
+                            const QList<QPointF>& points = lowerSeries->points();
-                        else
+                            upperSeries->append(QPointF(j, points[i].y() + data.first.y()));
+                        }else
                             upperSeries->append(QPointF(j, data.first.y()));
                     }
                     QAreaSeries *area = new QAreaSeries(upperSeries, lowerSeries);
                     area->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(area);
                     lowerSeries = upperSeries;
                 }
                 return chart;
             }
             QChart* ThemeWidget::createBarChart(int valueCount) const
             {
                 QChart* chart = new QChart();
                 chart->axisX()->setNiceNumbersEnabled(true);
                 chart->axisY()->setNiceNumbersEnabled(true);
                 chart->setTitle("Bar chart");
                 QBarCategories categories;
                 for (int i(0); i < valueCount; i++)
                     categories << QString::number(i);
                 QStackedBarSeries* series = new QStackedBarSeries(categories, chart);
                 for (int i(0); i < m_dataTable.count(); i++) {
                     QBarSet *set = new QBarSet("Bar set " + QString::number(i));
                     foreach (Data data, m_dataTable[i])
                         *set << data.first.y();
                     series->appendBarSet(set);
                 }
                 chart->addSeries(series);
                 return chart;
             }
             QChart* ThemeWidget::createLineChart() const
             {
                 QChart* chart = new QChart();
                 chart->axisX()->setNiceNumbersEnabled(true);
                 chart->axisY()->setNiceNumbersEnabled(true);
                 chart->setTitle("Line chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QLineSeries *series = new QLineSeries(chart);
                     foreach (Data data, list)
                         series->append(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createPieChart() const
             {
                 QChart* chart = new QChart();
                 chart->setTitle("Pie chart");
                 qreal pieSize = 1.0 / m_dataTable.count();
                 for (int i = 0; i < m_dataTable.count(); i++) {
                     QPieSeries *series = new QPieSeries(chart);
                     foreach (Data data, m_dataTable[i]) {
                         QPieSlice *slice = series->append(data.first.y(), data.second);
                         if (data == m_dataTable[i].first()) {
                             slice->setLabelVisible();
                             slice->setExploded();
                         }
                     }
                     qreal hPos = (pieSize / 2) + (i / (qreal) m_dataTable.count());
                     series->setPieSize(pieSize);
                     series->setHorizontalPosition(hPos);
                     series->setVerticalPosition(0.5);
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createSplineChart() const
             { // spine chart
                 QChart* chart = new QChart();
                 chart->axisX()->setNiceNumbersEnabled(true);
                 chart->axisY()->setNiceNumbersEnabled(true);
                 chart->setTitle("Spline chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QSplineSeries *series = new QSplineSeries(chart);
                     foreach (Data data, list)
                         series->append(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createScatterChart() const
             { // scatter chart
                 QChart* chart = new QChart();
                 chart->axisX()->setNiceNumbersEnabled(true);
                 chart->axisY()->setNiceNumbersEnabled(true);
                 chart->setTitle("Scatter chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QScatterSeries *series = new QScatterSeries(chart);
                     foreach (Data data, list)
                         series->append(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                 }
                 return chart;
             }
             void ThemeWidget::updateUI()
             {
                 QChart::ChartTheme theme = (QChart::ChartTheme) m_themeComboBox->itemData(m_themeComboBox->currentIndex()).toInt();
                 if (m_charts.at(0)->chart()->theme() != theme) {
                     foreach (QChartView *chartView, m_charts)
                         chartView->chart()->setTheme(theme);
                     QPalette pal = window()->palette();
                     if (theme == QChart::ChartThemeLight) {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeDark) {
                         pal.setColor(QPalette::Window, QRgb(0x121218));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBlueCerulean) {
                         pal.setColor(QPalette::Window, QRgb(0x40434a));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBrownSand) {
                         pal.setColor(QPalette::Window, QRgb(0x9e8965));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeBlueNcs) {
                         pal.setColor(QPalette::Window, QRgb(0x018bba));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeHighContrast) {
                         pal.setColor(QPalette::Window, QRgb(0xffab03));
                         pal.setColor(QPalette::WindowText, QRgb(0x181818));
                     } else if (theme == QChart::ChartThemeBlueIcy) {
                         pal.setColor(QPalette::Window, QRgb(0xcee7f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     }
                     window()->setPalette(pal);
                 }
                 bool checked = m_antialiasCheckBox->isChecked();
                 foreach (QChartView *chart, m_charts)
                     chart->setRenderHint(QPainter::Antialiasing, checked);
                 QChart::AnimationOptions options(m_animatedComboBox->itemData(m_animatedComboBox->currentIndex()).toInt());
                 if (m_charts.at(0)->chart()->animationOptions() != options) {
                     foreach (QChartView *chartView, m_charts)
                         chartView->chart()->setAnimationOptions(options);
                 }
                 QLegend::Alignments alignment(m_legendComboBox->itemData(m_legendComboBox->currentIndex()).toInt());
                 if (!alignment) {
                     foreach (QChartView *chartView, m_charts) {
                         chartView->chart()->legend()->hide();
                     }
                 } else {
                     foreach (QChartView *chartView, m_charts) {
                         chartView->chart()->legend()->setAlignment(alignment);
                         chartView->chart()->legend()->show();
                     }
                 }
             }

demos/dynamicspline/chart.cpp +2 -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 "chart.h"
             #include <QAxis>
             #include <QSplineSeries>
             #include <QTime>
             Chart::Chart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
                 :QChart(parent, wFlags),
                 m_step(1),
                 m_x(0),
                 m_y(1)
             {
                 qsrand((uint) QTime::currentTime().msec());
                 QObject::connect(&m_timer, SIGNAL(timeout()), this, SLOT(handleTimeout()));
                 m_timer.setInterval(1000);
                 m_series = new QSplineSeries(this);
                 QPen green(Qt::red);
                 green.setWidth(3);
                 m_series->setPen(green);
                 m_series->append(m_x, m_y);
                 addSeries(m_series);
                 axisY()->setRange(-5, 5);
                 axisX()->setRange(-9, 1);
                 axisX()->setTicksCount(11);
                 m_timer.start();
             }
             Chart::~Chart()
             {
             }
             void Chart::handleTimeout()
             {
                 m_x += m_step;
+                qreal y = m_y;
                 m_y = qrand() % 5 - 2.5;
                 m_series->append(m_x, m_y);
                 if (m_x >= 10)
-                    m_series->remove(m_x - 10);
+                    m_series->remove(m_x - 10,y);
                 scrollRight();
             }

src/areachart/qareaseries.cpp +11 -6

             /****************************************************************************
             **
             ** 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 "qareaseries.h"
             #include "qareaseries_p.h"
             #include "qlineseries.h"
             #include "areachartitem_p.h"
             #include "legendmarker_p.h"
             #include "domain_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAreaSeries
                 \brief The QAreaSeries class is used for making area charts.
                 \mainclass
             	An area chart is used to show quantitative data. It is based on line chart, in the way that area between axis and the line
             	is emphasized with color. Since the area chart is based on line chart, QAreaSeries constructor needs QLineSeries instance,
             	which defines "upper" boundary of the area. "Lower" boundary is defined by default by axis X. Instead of axis X "lower" boundary can be specified by other line.
             	In that case QAreaSeries should be initiated with two QLineSerie instances. Please note terms "upper" and "lower" boundary can be misleading in cases
             	where "lower" boundary had bigger values than the "upper" one, however the main point that area between these two boundary lines will be filled.
                 See the \l {AreaChart Example} {area chart example} to learn how to create a simple area chart.
                 \image examples_areachart.png
             */
             /*!
                 \fn virtual QSeriesType QAreaSeries::type() const
                 \brief Returns type of series.
                 \sa QAbstractSeries, QSeriesType
             */
             /*!
                \fn QLineSeries* QAreaSeries::upperSeries() const
                \brief Returns upperSeries used to define one of area boundaries.
             */
             /*!
                \fn QLineSeries* QAreaSeries::lowerSeries() const
                \brief Returns lowerSeries used to define one of area boundaries. Note if QAreaSeries where counstucted wihtout a\ lowerSeries
                 this function return Null pointer.
             */
             /*!
                \fn QPen QAreaSeries::pen() const
                \brief  Returns the pen used to draw line for this series.
                 \sa setPen()
             */
             /*!
                \fn QPen QAreaSeries::brush() const
                \brief  Returns the brush used to draw line for this series.
                 \sa setBrush()
             */
             /*!
                \fn bool  QAreaSeries::pointsVisible() const
                \brief  Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
             /*!
                 \fn void QAreaSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on area chart.
             */
             /*!
                 \fn void QAreaSeries::selected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of QAreaSeries API.
             */
             /*!
                 \fn void QAreaSeriesPrivate::updated()
                 \brief \internal
             */
             /*!
                 Constructs area series object which is a child of \a upperSeries. Area will be spanned between \a
                 upperSeries line and \a lowerSeries line.  If no \a lowerSeries is passed to constructor, area is specified by axis x (y=0) instead.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
             QAreaSeries::QAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries)
                 : QAbstractSeries(*new QAreaSeriesPrivate(upperSeries,lowerSeries,this),upperSeries)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QAreaSeries::~QAreaSeries()
             {
             }
             QAbstractSeries::QSeriesType QAreaSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeArea;
             }
             QLineSeries* QAreaSeries::upperSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_upperSeries;
             }
             QLineSeries* QAreaSeries::lowerSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_lowerSeries;
             }
             /*!
                 Sets \a pen used for drawing area outline.
             */
             void QAreaSeries::setPen(const QPen &pen)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pen != pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen  QAreaSeries::pen() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pen;
             }
             /*!
                 Sets \a brush used for filling the area.
             */
             void QAreaSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QAreaSeries);
                 if (d->m_brush != brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QAreaSeries::brush() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_brush;
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QAreaSeries::setPointsVisible(bool visible)
             {
                 Q_D(QAreaSeries);
                 if (d->m_pointsVisible != visible) {
                     d->m_pointsVisible = visible;
                     emit d->updated();
                 }
             }
             bool QAreaSeries::pointsVisible() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_pointsVisible;
             }
             /*!
                 Does nothing at present. Paremeter \a model is not used. Always returns false.
                 To set the model for area series set the models for upperSeries, lowerSeries
              */
             bool QAreaSeries::setModel(QAbstractItemModel* model)
             {
                 Q_UNUSED(model);
                 qWarning()<<"Not implemented";
                 return false;
             }
             /*!
                 Does nothing at present. Always returns 0;
                 To get the model set for area series call upperSeries->model(), lowerSeries->model()
              */
             QAbstractItemModel* QAreaSeries::model() const
             {
                 return 0;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries,QAreaSeries* q) :
                 QAbstractSeriesPrivate(q),
                 m_upperSeries(upperSeries),
                 m_lowerSeries(lowerSeries),
                 m_pointsVisible(false)
             {
             }
             void QAreaSeriesPrivate::scaleDomain(Domain& domain)
             {
                 Q_Q(QAreaSeries);
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 QLineSeries* upperSeries = q->upperSeries();
                 QLineSeries* lowerSeries = q->lowerSeries();
-                for (int i = 0; i < upperSeries->count(); i++)
+                const QList<QPointF>& points = upperSeries->points();
+                for (int i = 0; i < points.count(); i++)
                 {
-                    qreal x = upperSeries->x(i);
+                    qreal x = points[i].x();
-                    qreal y = upperSeries->y(i);
+                    qreal y = points[i].y();
                     minX = qMin(minX, x);
                     minY = qMin(minY, y);
                     maxX = qMax(maxX, x);
                     maxY = qMax(maxY, y);
                 }
                 if(lowerSeries) {
-                    for (int i = 0; i < lowerSeries->count(); i++)
+                    const QList<QPointF>& points = upperSeries->points();
+                    for (int i = 0; i < points.count(); i++)
                     {
-                        qreal x = lowerSeries->x(i);
+                        qreal x = points[i].x();
-                        qreal y = lowerSeries->y(i);
+                        qreal y = points[i].y();
                         minX = qMin(minX, x);
                         minY = qMin(minY, y);
                         maxX = qMax(maxX, x);
                         maxY = qMax(maxY, y);
                     }}
                 domain.setRangeX(minX,maxX,tickXCount);
                 domain.setRangeY(minY,maxY,tickYCount);
             }
             Chart* QAreaSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QAreaSeries);
                 AreaChartItem* area = new AreaChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(area->upperLineItem());
                     if(q->lowerSeries())  presenter->animator()->addAnimation(area->lowerLineItem());
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return area;
             }
             QList<LegendMarker*> QAreaSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QAreaSeries);
                 QList<LegendMarker*> list;
                 return list << new AreaLegendMarker(q,legend);
             }
             #include "moc_qareaseries.cpp"
             #include "moc_qareaseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/scatterchartitem.cpp +2 -2

             /****************************************************************************
             **
             ** 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 "scatterchartitem_p.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QGraphicsScene>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ScatterChartItem::ScatterChartItem(QScatterSeries *series, ChartPresenter *presenter) :
                 XYChartItem(series,presenter),
                 m_series(series),
                 m_items(this),
                 m_shape(QScatterSeries::MarkerShapeRectangle),
                 m_size(15)
             {
                 QObject::connect(m_series->d_func(),SIGNAL(updated()), this, SLOT(handleUpdated()));
                 setZValue(ChartPresenter::ScatterSeriesZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 handleUpdated();
                 m_items.setHandlesChildEvents(false);
                 // TODO: how to draw a drop shadow?
             //    QGraphicsDropShadowEffect *dropShadow = new QGraphicsDropShadowEffect();
             //    dropShadow->setOffset(2.0);
             //    dropShadow->setBlurRadius(2.0);
             //    setGraphicsEffect(dropShadow);
             }
             QRectF ScatterChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void ScatterChartItem::createPoints(int count)
             {
                 for (int i = 0; i < count; ++i) {
                     QGraphicsItem *item = 0;
                     switch (m_shape) {
                                case QScatterSeries::MarkerShapeCircle:{
                                    QGraphicsEllipseItem* i = new QGraphicsEllipseItem(0,0,m_size,m_size);
                                    const QRectF& rect = i->boundingRect();
                                    i->setPos(-rect.width()/2,-rect.height()/2);
                                    item = new Marker(i,this);
                                    break;
                                }
                                case QScatterSeries::MarkerShapeRectangle:{
                                    QGraphicsRectItem* i = new QGraphicsRectItem(0,0,m_size,m_size);
                                    i->setPos(-m_size/2,-m_size/2);
                                    item = new Marker(i,this);
                                    break;
                                }
                                default:
                                    qWarning()<<"Unsupported marker type";
                                    break;
                     }
                     m_items.addToGroup(item);
                 }
             }
             void ScatterChartItem::deletePoints(int count)
             {
                 QList<QGraphicsItem *> items = m_items.childItems();
                 for (int i = 0; i < count; ++i) {
                     delete(items.takeLast());
                 }
             }
             void ScatterChartItem::markerSelected(Marker *marker)
             {
-                emit XYChartItem::clicked(QPointF(m_series->x(marker->index()), m_series->y(marker->index())));
+                emit XYChartItem::clicked(marker->point());
             }
             void ScatterChartItem::setLayout(QVector<QPointF>& points)
             {
                 if(points.size()==0)
                 {
                     XYChartItem::setLayout(points);
                     return;
                 }
                 int diff = m_items.childItems().size() - points.size();
                 if(diff>0) {
                     deletePoints(diff);
                 }
                 else if(diff<0) {
                     createPoints(-diff);
                 }
                 if(diff!=0) handleUpdated();
                 QList<QGraphicsItem*> items = m_items.childItems();
                 for (int i = 0; i < points.size(); i++) {
                     Marker* item = static_cast<Marker*>(items.at(i));
                     const QPointF& point = points.at(i);
                     const QRectF& rect = item->boundingRect();
-                    item->setIndex(i);
+                    item->setPoint(point);
                     item->setPos(point.x()-rect.width()/2,point.y()-rect.height()/2);
                     if(!clipRect().contains(point)) {
                         item->setVisible(false);
                     }
                     else {
                         item->setVisible(true);
                     }
                 }
                 prepareGeometryChange();
                 m_rect = clipRect();
                 XYChartItem::setLayout(points);
             }
             void ScatterChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter)
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
             }
             void ScatterChartItem::setPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                        static_cast<Marker*>(item)->setPen(pen);
                 }
             }
             void ScatterChartItem::setBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                         static_cast<Marker*>(item)->setBrush(brush);
                  }
             }
             void ScatterChartItem::handleUpdated()
             {
                 int count = m_items.childItems().count();
                 if(count==0) return;
                 bool recreate = m_size != m_series->size() || m_shape != m_series->shape();
                 //TODO: only rewrite on size change
                 m_size = m_series->size();
                 m_shape = m_series->shape();
                 if(recreate){
                     deletePoints(count);
                     createPoints(count);
                 }
                 setPen(m_series->pen());
                 setBrush(m_series->brush());
             }
             #include "moc_scatterchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/scatterchartitem_p.h +6 -6

             /****************************************************************************
             **
             ** 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 SCATTERCHARTITEM_H
             #define SCATTERCHARTITEM_H
             #include "qchartglobal.h"
             #include "xychartitem_p.h"
             #include <QGraphicsEllipseItem>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeries;
             class Marker;
             class ScatterChartItem : public XYChartItem
             {
                 Q_OBJECT
             public:
                 explicit ScatterChartItem(QScatterSeries *series, ChartPresenter *presenter);
             public:
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 void setPen(const QPen &pen);
                 void setBrush(const QBrush &brush);
                 void markerSelected(Marker *item);
             public Q_SLOTS:
                 void handleUpdated();
             private:
                 void createPoints(int count);
                 void deletePoints(int count);
             protected:
                 void setLayout(QVector<QPointF> &points);
             private:
                 QScatterSeries *m_series;
                 QGraphicsItemGroup m_items;
                 int m_shape;
                 int m_size;
                 QRectF m_rect;
             };
             class Marker: public QAbstractGraphicsShapeItem
             {
             public:
-               Marker(QAbstractGraphicsShapeItem *item , ScatterChartItem *parent) : QAbstractGraphicsShapeItem(0) ,m_item(item), m_parent(parent), m_index(-1)
+               Marker(QAbstractGraphicsShapeItem *item , ScatterChartItem *parent) : QAbstractGraphicsShapeItem(0) ,m_item(item), m_parent(parent)
                {
                }
                ~Marker()
                {
                    delete m_item;
                }
-               void setIndex(int index)
+               void setPoint(const QPointF& point)
                {
-                   m_index=index;
+                   m_point=point;
                }
-               int index() const
+               QPointF point() const
                {
-                   return m_index;
+                   return m_point;
                }
                QPainterPath shape() const
                {
                    return m_item->shape();
                }
                QRectF boundingRect() const
                {
                    return m_item->boundingRect();
                }
                bool contains(const QPointF &point) const
                {
                    return m_item->contains(point);
                }
                void setPen(const QPen &pen)
                {
                    m_item->setPen(pen);
                }
                void setBrush(const QBrush &brush)
                {
                    m_item->setBrush(brush);
                }
                void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
                {
                    m_item->paint(painter,option,widget);
                }
             protected:
                void mousePressEvent(QGraphicsSceneMouseEvent *event)
                {
                    Q_UNUSED(event)
                    m_parent->markerSelected(this);
                }
             private:
                QAbstractGraphicsShapeItem* m_item;
                ScatterChartItem* m_parent;
-               int m_index;
+               QPointF m_point;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // SCATTERPRESENTER_H

src/splinechart/qsplineseries.cpp +49 -35

             /****************************************************************************
             **
             ** 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"
             /*!
                 \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)
             {
             }
             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->calculateControlPoints();
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             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);
+                int n = m_points.count() - 1;
-                int n = q->count() - 1;
                 if (n == 1)
                 {
                     //for n==1
-                    m_controlPoints.append(QPointF((2 * q->x(0) + q->x(1)) / 3, (2 * q->y(0) + q->y(1)) / 3));
+                    m_controlPoints[0].setX((2 * m_points[0].x() + m_points[1].x()) / 3);
-                    m_controlPoints.append(QPointF(2 * m_controlPoints[0].x() - q->x(0), 2 * m_controlPoints[0].y() - q->y(0)));
+                    m_controlPoints[0].setY((2 * m_points[0].y() + m_points[1].y()) / 3);
+                    m_controlPoints[1].setX(2 * m_controlPoints[0].x() - m_points[0].x());
+                    m_controlPoints[1].setY(2 * m_controlPoints[0].y() - m_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         |
                 //
-                QList<qreal> points;
+                QVector<qreal> vector;
+                vector.resize(n);
-                points.append(q->x(0) + 2 * q->x(1));
+                vector[0] = m_points[0].x() + 2 * m_points[1].x();
-                for (int i = 1; i < n - 1; ++i)
+                for (int i = 1; i < n - 1; ++i){
-                    points.append(4 * q->x(i) + 2 * q->x(i + 1));
+                    vector[i] = 4 * m_points[i].x() + 2 * m_points[i + 1].x();
+                }
-                points.append((8 * q->x(n - 1) + q->x(n)) / 2.0);
+                vector[n - 1] = (8 * m_points[n-1].x() + m_points[n].x()) / 2.0;
-                QList<qreal> xControl = firstControlPoints(points);
+                QVector<qreal> xControl = firstControlPoints(vector);
-                points[0] = q->y(0) + 2 * q->y(1);
+                vector[0] = m_points[0].y() + 2 * m_points[1].y();
                 for (int i = 1; i < n - 1; ++i) {
-                    points[i] = 4 * q->y(i) + 2 * q->y(i + 1);
+                    vector[i] = 4 * m_points[i].y() + 2 * m_points[i + 1].y();
                 }
-                points[n - 1] = (8 * q->y(n - 1) + q->y(n)) / 2.0;
+                vector[n - 1] = (8 * m_points[n-1].y() + m_points[n].y()) / 2.0;
+                QVector<qreal> yControl = firstControlPoints(vector);
-                QList<qreal> yControl = firstControlPoints(points);
+                for (int i = 0,j =0; i < n; ++i, ++j) {
-                for (int i = 0; i < n; ++i) {
+                    m_controlPoints[j].setX(xControl[i]);
+                    m_controlPoints[j].setY(yControl[i]);
-                    m_controlPoints.append(QPointF(xControl[i], yControl[i]));
+                    j++;
-                    if (i < n - 1)
+                    if (i < n - 1){
-                        m_controlPoints.append(QPointF(2 * q->x(i + 1) - xControl[i + 1], 2 * q->y(i + 1) - yControl[i + 1]));
+                        m_controlPoints[j].setX(2 * m_points[i+1].x() - xControl[i + 1]);
-                    else
+                        m_controlPoints[j].setY(2 * m_points[i+1].y() - yControl[i + 1]);
-                        m_controlPoints.append(QPointF((q->x(n) + xControl[n - 1]) / 2, (q->y(n) + yControl[n - 1]) / 2));
+                    }else{
+                        m_controlPoints[j].setX((m_points[n].x() + xControl[n - 1]) / 2);
+                        m_controlPoints[j].setY((m_points[n].y() + yControl[n - 1]) / 2);
+                    }
                 }
             }
-            QList<qreal> QSplineSeriesPrivate::firstControlPoints(QList<qreal> list)
+            QVector<qreal> QSplineSeriesPrivate::firstControlPoints(const QVector<qreal>& vector)
             {
-                QList<qreal> result;
+                QVector<qreal> result;
-                QList<qreal> temp;
+                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;
-                result.append(list[0] / b);
-                temp.append(0);
+                for (int i = 1; i < count; i++) {
-                for (int i = 1; i < list.size(); i++) {
+                    temp[i] = 1 / b;
-                    temp.append(1 / b);
+                    b = (i < count - 1 ? 4.0 : 3.5) - temp[i];
-                    b = (i < list.size() - 1 ? 4.0 : 3.5) - temp[i];
+                    result[i]=(vector[i] - result[i - 1]) / b;
-                    result.append((list[i] - result[i - 1]) / b);
                 }
-                for (int i = 1; i < list.size(); i++)
+                for (int i = 1; i < count; i++)
-                    result[list.size() - i - 1] -= temp[list.size() - i] * result[list.size() - 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 (m_points.count() > 1) {
-                if (q->count() > 1) {
+                    m_controlPoints.resize(2*m_points.count()-2);
-                    m_controlPoints.clear();
                     calculateControlPoints();
                 }
             }
             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_p.h +6 -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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QSPLINESERIES_P_H
             #define QSPLINESERIES_P_H
             #include "qlineseries_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QSplineSeriesPrivate: public QLineSeriesPrivate
             {
                 Q_OBJECT
             public:
                 Chart* createGraphics(ChartPresenter* presenter);
                 QSplineSeriesPrivate(QSplineSeries* q);
-                void calculateControlPoints();
-                QList<qreal> firstControlPoints(QList<qreal> rhs);
             public Q_SLOTS:
                 void updateControlPoints();
+            private:
+                void calculateControlPoints();
+                QVector<qreal> firstControlPoints(const QVector<qreal>& vector);
             public:
-                QList<QPointF> m_controlPoints;
+                QVector<QPointF> m_controlPoints;
             private:
                 Q_DECLARE_PUBLIC(QSplineSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/xychart/qxyseries.cpp +47 -95

             /****************************************************************************
             **
             ** 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 QXYSeries::selected()
                 The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be
                 implemented by the user of QXYSeries API.
             */
             /*!
                 \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)
             {
-                Q_D(QXYSeries);
+                append(QPointF(x,y));
-                Q_ASSERT(d->m_x.size() == d->m_y.size());
-                d->m_x<<x;
-                d->m_y<<y;
-                emit d->pointAdded(d->m_x.size()-1);
             }
             /*!
                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)
             {
-                append(point.x(),point.y());
+                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)
+            void QXYSeries::append(const QList<QPointF> &points)
             {
                 foreach(const QPointF& point , points) {
-                    append(point.x(),point.y());
+                    append(point);
                 }
             }
-            /*!
-              Modifies \a y value for given \a x a value.
-            */
-            void QXYSeries::replace(qreal x,qreal y)
-                Q_D(QXYSeries);
-                int index = d->m_x.indexOf(x);
-                d->m_x[index] = x;
-                d->m_y[index] = y;
-                emit d->pointReplaced(index);
-            /*!
+            void QXYSeries::replace(qreal oldX,qreal oldY,qreal newX,qreal newY)
-              This is an overloaded function.
-              Replaces current y value of for given \a point x value with \a point y value.
-            */
-            void QXYSeries::replace(const QPointF &point)
             {
-                replace(point.x(),point.y());
+                replace(QPointF(oldX,oldY),QPointF(newX,newY));
             }
-            /*!
+            void QXYSeries::replace(const QPointF &oldPoint,const QPointF &newPoint)
-              Removes first \a x value and related y value.
-            */
-            void QXYSeries::remove(qreal x)
             {
                 Q_D(QXYSeries);
-                int index = d->m_x.indexOf(x);
+                int index = d->m_points.indexOf(oldPoint);
+                if(index==1) return;
-                if (index == -1) return;
+                d->m_points[index] = newPoint;
+                emit d->pointReplaced(index);
-                d->m_x.remove(index);
-                d->m_y.remove(index);
-                emit d->pointRemoved(index);
             }
             /*!
               Removes current \a x and \a y value.
             */
             void QXYSeries::remove(qreal x,qreal y)
             {
-                Q_D(QXYSeries);
+                remove(QPointF(x,y));
-                int index =-1;
-                do {
-                    index = d->m_x.indexOf(x,index+1);
-                } while (index !=-1 && d->m_y.at(index)!=y);
-                if (index==-1) return;
-                d->m_x.remove(index);
-                d->m_y.remove(index);
-                emit d->pointRemoved(index);
             }
             /*!
               Removes current \a point x value. Note \a point y value is ignored.
             */
             void QXYSeries::remove(const QPointF &point)
             {
-                remove(point.x(),point.y());
+                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);
-                d->m_x.clear();
+                foreach(const QPointF& point, d->m_points) {
-                d->m_y.clear();
+                      remove(point);
-            /*!
-                \internal \a pos
-            */
-            qreal QXYSeries::x(int pos) const
-                Q_D(const QXYSeries);
-                if (d->m_model) {
-                    if (d->m_mapOrientation == Qt::Vertical)
-                        // consecutive data is read from model's column
-                        return d->m_model->data(d->m_model->index(pos + d->m_mapFirst, d->m_mapX), Qt::DisplayRole).toDouble();
-                    else
-                        // consecutive data is read from model's row
-                        return d->m_model->data(d->m_model->index(d->m_mapX, pos + d->m_mapFirst), Qt::DisplayRole).toDouble();
-                } else {
-                    // model is not specified, return the data from series' internal data store
-                    return d->m_x.at(pos);
                 }
             }
             /*!
                 \internal \a pos
             */
-            qreal QXYSeries::y(int pos) const
+            QList<QPointF> QXYSeries::points() const
             {
                 Q_D(const QXYSeries);
                 if (d->m_model) {
-                    if (d->m_mapOrientation == Qt::Vertical)
+                    QList<QPointF> result;
+                    if (d->m_mapOrientation == Qt::Vertical){
                         // consecutive data is read from model's column
-                        return d->m_model->data(d->m_model->index(pos + d->m_mapFirst, d->m_mapY), Qt::DisplayRole).toDouble();
-                    else
+                        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
-                        return d->m_model->data(d->m_model->index(d->m_mapY, pos + d->m_mapFirst), Qt::DisplayRole).toDouble();
+                        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_y.at(pos);
+                    return d->m_points.toList();
                 }
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_D(const QXYSeries);
-                Q_ASSERT(d->m_x.size() == d->m_y.size());
                 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_x.size();
+                return d->m_points.count();
-            /*!
-                Returns the data points of the series.
-            */
-            QList<QPointF> QXYSeries::data()
-                Q_D(QXYSeries);
-                QList<QPointF> data;
-                for (int i(0); i < d->m_x.count() && i < d->m_y.count(); i++)
-                    data.append(QPointF(d->m_x.at(i), d->m_y.at(i)));
-                return data;
             }
             /*!
                 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)
+            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_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 = first;
                 d->m_mapCount = count;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             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);
+                for (int i = 0; i < m_points.count(); i++)
-                for (int i = 0; i < q->count(); i++)
                 {
-                    qreal x = q->x(i);
-                    qreal y = q->y(i);
+                    qreal x = m_points[i].x();
+                    qreal y = m_points[i].y();
                     minX = qMin(minX, x);
                     minY = qMin(minY, y);
                     maxX = qMax(maxX, x);
                     maxY = qMax(maxY, y);
                 }
                 domain.setRangeX(minX,maxX,tickXCount);
                 domain.setRangeY(minY,maxY,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/qxyseries.h +5 -8

             /****************************************************************************
             **
             ** 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 QXYSERIES_H
             #define QXYSERIES_H
             #include <qchartglobal.h>
             #include <qabstractseries.h>
             #include <QPen>
             #include <QBrush>
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QXYSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QXYSeries : public QAbstractSeries
             {
                 Q_OBJECT
             protected:
                 explicit QXYSeries(QXYSeriesPrivate &d,QObject *parent = 0);
                 ~QXYSeries();
             public:
                 void append(qreal x, qreal y);
                 void append(const QPointF &point);
-                void append(const QList<QPointF> points);
+                void append(const QList<QPointF> &points);
-                void replace(qreal x,qreal y);
+                void replace(qreal oldX,qreal oldY,qreal newX,qreal newY);
-                void replace(const QPointF &point);
+                void replace(const QPointF &oldPoint,const QPointF &newPoint);
-                void remove(qreal x);
                 void remove(qreal x, qreal y);
                 void remove(const QPointF &point);
                 void removeAll();
                 int count() const;
-                qreal x(int pos) const;
+                QList<QPointF> points() const;
-                qreal y(int pos) const;
-                QList<QPointF> data();
                 QXYSeries& operator << (const QPointF &point);
-                QXYSeries& operator << (const QList<QPointF> points);
+                QXYSeries& operator << (const QList<QPointF> &points);
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setPointsVisible(bool visible = true);
                 bool pointsVisible() const;
                 bool setModel(QAbstractItemModel *model);
                 virtual void setModelMapping(int modelX, int modelY, Qt::Orientation orientation = Qt::Vertical);
                 void setModelMappingRange(int first, int count = -1);
             //private Q_SLOTS:
             //    void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
             Q_SIGNALS:
                 void clicked(const QPointF &point);
                 void selected();
             private:
                 Q_DECLARE_PRIVATE(QXYSeries);
                 Q_DISABLE_COPY(QXYSeries);
                 friend class XYLegendMarker;
                 friend class XYChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/xychart/qxyseries_p.h +1 -2

             /****************************************************************************
             **
             ** 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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QXYSERIES_P_H
             #define QXYSERIES_P_H
             #include "qabstractseries_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QXYSeries;
             class QXYSeriesPrivate: public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QXYSeriesPrivate(QXYSeries* q);
                 void scaleDomain(Domain& domain);
                 QList<LegendMarker*> createLegendMarker(QLegend* legend);
             private Q_SLOTS:
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelDataAdded(QModelIndex parent, int start, int end);
                 void modelDataRemoved(QModelIndex parent, int start, int end);
             Q_SIGNALS:
                 void updated();
                 void pointReplaced(int index);
                 void pointRemoved(int index);
                 void pointsRemoved(int start, int end);
                 void pointAdded(int index);
                 void pointsAdded(int start, int end);
             protected:
-                QVector<qreal> m_x;
+                QVector<QPointF> m_points;
-                QVector<qreal> m_y;
                 QPen m_pen;
                 QBrush m_brush;
                 int m_mapX;
                 int m_mapY;
                 bool m_pointsVisible;
             private:
                 Q_DECLARE_PUBLIC(QXYSeries);
                 friend class QScatterSeries;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/xychart/xychartitem.cpp +11 -8

             /****************************************************************************
             **
             ** 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);
-                qreal x = (m_series->x(index) - m_minX)* deltaX;
+                const QList<QPointF>& vector = m_series->points();
-                qreal y = (m_series->y(index) - m_minY)*-deltaY + m_size.height();
+                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> points;
+                QVector<QPointF> result;
-                points.reserve(m_series->count());
+                result.resize(m_series->count());
+                const QList<QPointF>& vector = m_series->points();
                 for (int i = 0; i < m_series->count(); ++i) {
-                    qreal x = (m_series->x(i) - m_minX)* deltaX;
+                    qreal x = (vector[i].x() - m_minX)* deltaX;
-                    qreal y = (m_series->y(i) - m_minY)*-deltaY + m_size.height();
+                    qreal y = (vector[i].y() - m_minY)*-deltaY + m_size.height();
-                    points << QPointF(x,y);
+                    result[i].setX(x);
+                    result[i].setY(y);
                 }
-                return points;
+                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 {
                     // series uses model as a data source
                     int first = m_series->mapFirst();
                     int count = m_series->mapCount();
                     int addedCount = end - start + 1;
                     if (count != -1 && start >= first + count) {
                         return;
                     }
                     // adding items to unlimited map
                     else if (count == -1 && start >= first) {
                         for (int i = start; i <= end; i++)
                             handlePointAdded(i - first);
                     } else if (count == - 1 && start < first) {
                         // not all newly added items
                         for (int i = first; i < first + addedCount; i++)
                             handlePointAdded(i - first);
                     }
                     // commented out code below does the same thing, but its more confusing.
                     //        } else if (count == -1) {
                     //            int begin = qMax(start, first);
                     //            for (int i = begin; i < begin + (end - start + 1); i++)
                     //                handlePointAdded(i - first);
                     //        }
                     // adding items to limited map
                     else if (start >= first) {
                         // remove the items that will no longer fit into the map
                         // int toRemove = addedCount - (count - points().size());
                         for (int i = start; i <= end; i++) {
                             handlePointAdded(i - first);
                         }
                         if (m_points.size() > count)
                             for (int i = m_points.size() - 1; i >= count; i--)
                                 handlePointRemoved(i);
                         //            update();
                     } else {
                         //
                         for (int i = first; i < first + addedCount; i++) {
                             handlePointAdded(i - first);
                         }
                         if (m_points.size() > count)
                             for (int i = m_points.size() - 1; i >= count; 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 first = m_series->mapFirst();
                     int count = m_series->mapCount();
                     int removedCount = end - start + 1;
                     if (count != -1 && start >= first + count) {
                         return;
                     }
                     // removing items from unlimited map
                     else if (count == -1 && start >= first) {
                         for (int i = end; i >= start; i--)
                             handlePointRemoved(i - first);
                     } else if (count == - 1 && start < first) {
                         // not all removed items
                         for (int i = first + removedCount - 1; i >= first; i--)
                             handlePointRemoved(i - first);
                     }
                     // removing items from limited map
                     else if (start >= first) {
                         //
                         int lastExisting = qMin(first + m_points.size() - 1, end);
                         for (int i = lastExisting; i >= start; i--) {
                             handlePointRemoved(i - first);
                         }
                         // the map is limited, so after removing the items some new items may have fall within the mapped area
                         int itemsAvailable;
                         if (m_series->mapOrientation() == Qt::Vertical)
                             itemsAvailable = m_series->model()->rowCount() - first - m_points.size();
                         else
                             itemsAvailable = m_series->model()->columnCount() - first - m_points.size();
                         int toBeAdded = qMin(itemsAvailable, count - m_points.size());
                         int currentSize = m_points.size();
                         if (itemsAvailable > 0)
                             for (int i = m_points.size(); i < currentSize + toBeAdded; i++)
                                 handlePointAdded(i);
                     } else {
                         // first removed item lays before the mapped area
                         int toRemove = qMin(m_points.size() - 1, removedCount);
                         for (int i = first; i < first + toRemove; i++)
                             handlePointRemoved(0);
                         // the map is limited, so after removing the items some new items may have fall into the map
                         int itemsAvailable;
                         if (m_series->mapOrientation() == Qt::Vertical)
                             itemsAvailable = m_series->model()->rowCount() - first - m_points.size();
                         else
                             itemsAvailable = m_series->model()->columnCount() - first - m_points.size();
                         int toBeAdded = qMin(itemsAvailable, count - m_points.size());
                         int currentSize = m_points.size();
                         if (itemsAvailable > 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);
             }
             void XYChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit clicked(calculateDomainPoint(event->pos()));
             }
             #include "moc_xychartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

test/auto/auto.pro +1 -1

             !include( ../test.pri ) {
              error( "Couldn't find the test.pri file!" )
             }
             TEMPLATE = subdirs
-            SUBDIRS += qchartview qchart
+            SUBDIRS += qchartview qchart qlineseries
             test_private:{
                 SUBDIRS += chartdataset domain
             }

test/wavechart/wavechart.cpp +2 -2

             /****************************************************************************
             **
             ** 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 "wavechart.h"
             #include <cmath>
             QTCOMMERCIALCHART_USE_NAMESPACE
             #define PI 3.14159265358979
             static const int numPoints =100;
             WaveChart::WaveChart(QChart* chart, QWidget* parent) :
                 QChartView(chart, parent),
                 m_series(new QLineSeries()),
                 m_wave(0),
                 m_step(2 * PI / numPoints)
             {
                 QPen blue(Qt::blue);
                 blue.setWidth(3);
                 m_series->setPen(blue);
                 QTime now = QTime::currentTime();
                 qsrand((uint) now.msec());
                 int fluctuate = 100;
                 for (qreal x = 0; x <= 2 * PI; x += m_step) {
                     m_series->append(x, fabs(sin(x) * fluctuate));
                 }
                 chart->addSeries(m_series);
                 QObject::connect(&m_timer, SIGNAL(timeout()), this, SLOT(update()));
                 m_timer.setInterval(5000);
                 m_timer.start();
             }
             ;
             void WaveChart::update()
             {
                 int fluctuate;
+                const QList<QPointF>& points = m_series->points();
                 for (qreal i = 0, x = 0; x <= 2 * PI; x += m_step, i++) {
                     fluctuate = qrand() % 100;
-                    m_series->replace(x, fabs(sin(x) * fluctuate));
+                    m_series->replace(x,points[i].y(),x,fabs(sin(x) * fluctuate));
                 }
             }

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