HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r796:4bbe1f66d4b7

rename functions add() -> append()

Jani Honkonen -

r796:4bbe1f66d4b7

parent child

Context file:

r796:4bbe1f66d4b7

Collapse all files

demos/chartthemes/themewidget.cpp +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:BSD$
              ** You may use this file under the terms of the BSD license as follows:
              **
              ** "Redistribution and use in source and binary forms, with or without
              ** modification, are permitted provided that the following conditions are
              ** met:
              **   * Redistributions of source code must retain the above copyright
              **     notice, this list of conditions and the following disclaimer.
              **   * Redistributions in binary form must reproduce the above copyright
              **     notice, this list of conditions and the following disclaimer in
              **     the documentation and/or other materials provided with the
              **     distribution.
              **   * Neither the name of Digia nor the names of its contributors
              **     may be used to endorse or promote products derived from this
              **     software without specific prior written permission.
              **
              ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
              ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
              ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
              ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
              ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
              ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
              ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
              ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
              ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
              ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
              ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
              ** $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 <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(100),
                 m_valueCount(11),
                 m_dataTable(generateRandomData(m_listCount,m_valueMax,m_valueCount)),
                 m_themeComboBox(createThemeBox()),
                 m_antialiasCheckBox(new QCheckBox("Anti aliasing")),
                 m_animatedComboBox(createAnimationBox())
             {
                 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(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);
             }
             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()));
             }
             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;
                     for (int j(0); j < valueCount; j++) {
                         QPointF value(j + (qreal) rand() / (qreal) RAND_MAX, qrand() % valueMax);
                         QString label = "Item " + 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("Default", QChart::ChartThemeDefault);
                 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;
             }
             QChart* ThemeWidget::createAreaChart() const
             {
                 // area chart
                 QChart *chart = new QChart();
                 chart->setTitle("Area chart");
                 {
                     QString name("Series ");
                     int nameIndex = 0;
                     for (int i(0); i < m_dataTable.count(); i++) {
                         QLineSeries *series1 = new QLineSeries(chart);
                         QLineSeries *series2 = new QLineSeries(chart);
                         foreach (Data data, m_dataTable[i]) {
-                            series1->add(data.first);
+                            series1->append(data.first);
-                            series2->add(QPointF(data.first.x(), 0.0));
+                            series2->append(QPointF(data.first.x(), 0.0));
                         }
                         QAreaSeries *area = new QAreaSeries(series1, series2);
                         area->setName(name + QString::number(nameIndex));
                         nameIndex++;
                         chart->addSeries(area);
                     }
                 }
                 return chart;
             }
             QChart* ThemeWidget::createBarChart(int valueCount) const
             {
                 // bar chart
                 QChart* chart = new QChart();
                 chart->setTitle("Bar chart");
                 {
                     QBarCategories categories;
                     // TODO: categories
                     for (int i(0); i < valueCount; i++)
                         categories << QString::number(i);
             //            QBarSeries* series = new QBarSeries(categories, chart);
             //            QPercentBarSeries* series = new QPercentBarSeries(categories, chart);
                     QStackedBarSeries* series = new QStackedBarSeries(categories, chart);
                     for (int i(0); i < m_dataTable.count(); i++) {
                         QBarSet *set = new QBarSet("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
             {
                 // line chart
                 QChart* chart = new QChart();
                 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->add(data.first);
+                        series->append(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createPieChart() const
             {
                 // pie chart
                 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->add(data.first.y(), data.second);
+                        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->setPiePosition(hPos, 0.5);
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createSplineChart() const
             { // spine chart
                 QChart* chart = new QChart();
                 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->add(data.first);
+                        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->setTitle("Scatter chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QScatterSeries *series = new QScatterSeries(chart);
                     foreach (Data data, list)
-                        series->add(data.first);
+                        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);
                 }
             }

examples/chartview/main.cpp +5 -5

             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <qlineseries.h>
             #include <qscatterseries.h>
             #include <qbarseries.h>
             #include <qbarset.h>
             #include <qpieseries.h>
             #include <QStringList>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 //! [1]
                 // Create chart view
                 QChartView *chartView = new QChartView();
                 chartView->setRenderHint(QPainter::Antialiasing);
                 chartView->setChartTitle("Simple Line Chart");
                 // Add series to the chart
                 QLineSeries *line = new QLineSeries();
-                line->add(0.0, 0.8);
+                line->append(0.0, 0.8);
-                line->add(1.1, 1.1);
+                line->append(1.1, 1.1);
-                line->add(2.0, 2.5);
+                line->append(2.0, 2.5);
                 chartView->addSeries(line);
                 //! [1]
                 chartView->setChartTitle("\'Scietific\' theme");
                 //! [2]
                 // Change theme
                 chartView->setChartTheme(QChart::ChartThemeHighContrast);
                 //! [2]
                 chartView->setChartTitle("Simple Pie Chart");
                 //! [3]
                 // Add pie series
                 // ...
                 QPieSeries *pie = new QPieSeries();
-                pie->add(3.4, "slice1");
+                pie->append(3.4, "slice1");
-                pie->add(6.7, "slice2");
+                pie->append(6.7, "slice2");
                 chartView->addSeries(pie);
                 //! [3]
                 chartView->setChartTitle("Simple Scatter Chart");
                 //! [4]
                 // Add scatter series
                 // ...
                 QScatterSeries *scatter = new QScatterSeries();
                 for (qreal x(0); x < 100; x += 0.5) {
                     qreal y = rand() % 100;
                     *(scatter) << QPointF(x, y);
                 }
                 chartView->addSeries(scatter);
                 //! [4]
                 chartView->setChartTitle("Simple Bar Chart");
                 //! [5]
                 // ...
                 // Add bar series
                 QStringList barCategory;
                 barCategory << "Jan"
                              << "Feb"
                              << "Mar";
                 QBarSeries *bar = new QBarSeries(barCategory);
                 QBarSet *barSet = new QBarSet("Sales");
                 *barSet << 123.2
                         << 301.3
                         << 285.8;
                 bar->addBarSet(barSet);
                 chartView->addSeries(bar);
                 //! [5]
                 QMainWindow w;
                 w.resize(400, 300);
                 w.setCentralWidget(chartView);
                 w.setWindowFlags(Qt::FramelessWindowHint);
                 w.show();
                 return a.exec();
             }

examples/dynamiclinechart/wavegenerator.h +2 -2

             #include <QTimer>
             #include <QTime>
             #include <QObject>
             #include <cmath>
             #include <qlineseries.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             #define PI 3.14159265358979
             static const int numPoints =100;
             class WaveGenerator: public QObject
             {
                 Q_OBJECT
             public:
                 WaveGenerator(QLineSeries* series1, QLineSeries* series2) :
                     m_series1(series1),
                     m_series2(series2),
                     m_wave(0),
                     m_step(2*PI/numPoints)
                 {
                     QTime now = QTime::currentTime();
                     qsrand((uint)now.msec());
                     int fluctuate = 100;
                     for (qreal x = 0; x <= 2*PI; x+=m_step) {
-                          series1->add(x, fabs(sin(x)*fluctuate));
+                          series1->append(x, fabs(sin(x)*fluctuate));
-                          series2->add(x, fabs(cos(x)*fluctuate));
+                          series2->append(x, fabs(cos(x)*fluctuate));
                     }
                     QObject::connect(&m_timer,SIGNAL(timeout()),this,SLOT(update()));
                     m_timer.setInterval(5000);
                     m_timer.start();
                 };
             public slots:
                 void update()
                 {
                     int fluctuate;
                     for (qreal i = 0, x = 0; x <= 2*PI; x+=m_step, i++) {
                         fluctuate = qrand() % 100;
                         m_series1->replace(x, fabs(sin(x)*fluctuate));
                         fluctuate = qrand() % 100;
                         m_series2->replace(x, fabs(cos(x)*fluctuate));
                     }
                 }
             private:
                 QLineSeries* m_series1;
                 QLineSeries* m_series2;
                 int m_wave;
                 qreal m_step;
                 QTimer m_timer;
             };

examples/ekgchart/chartview.cpp +4 -4

             #include "chartview.h"
             #include <QSplineSeries>
             #include <QTime>
             ChartView::ChartView(QWidget* parent):QChartView(parent),
             m_step(1),
             m_x(0),
             m_y(1)
             {
                 QTime now = QTime::currentTime();
                 qsrand((uint)now.msec());
                 setChartTitle("Three random line charts");
                 QObject::connect(&m_timer,SIGNAL(timeout()),this,SLOT(handleTimeout()));
                 m_timer.setInterval(1000);
                 m_series0 = new QLineSeries(this);
                 QPen blue(Qt::blue);
                 blue.setWidth(3);
                 m_series0->setPen(blue);
                 m_series1 = new QSplineSeries(this);
                 QPen green(Qt::red);
                 green.setWidth(3);
                 m_series1->setPen(green);
-                m_series0->add(m_x,m_y);
+                m_series0->append(m_x,m_y);
-                m_series1->add(m_x,m_y);
+                m_series1->append(m_x,m_y);
                 setChartTitle("Simple EKG chart");
                 addSeries(m_series0);
                 addSeries(m_series1);
                 axisY()->setRange(-5,5);
                 axisX()->setRange(-9,1);
                 axisX()->setTicksCount(11);
                 m_timer.start();
             }
             ChartView::~ChartView()
             {
             }
             void ChartView::handleTimeout()
             {
                 m_x+=m_step;
                 m_y = qrand() % 5 - 2.5;
-                m_series0->add(m_x,m_y);
+                m_series0->append(m_x,m_y);
-                m_series1->add(m_x,m_y);
+                m_series1->append(m_x,m_y);
                 if(m_x>=10)
                 {
                     m_series0->remove(m_x-10);
                     m_series1->remove(m_x-10);
                 }
                 scrollRight();
             }

examples/linechart/main.cpp +5 -5

             /****************************************************************************
             **
             ** 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:BSD$
             ** You may use this file under the terms of the BSD license as follows:
             **
             ** "Redistribution and use in source and binary forms, with or without
             ** modification, are permitted provided that the following conditions are
             ** met:
             **   * Redistributions of source code must retain the above copyright
             **     notice, this list of conditions and the following disclaimer.
             **   * Redistributions in binary form must reproduce the above copyright
             **     notice, this list of conditions and the following disclaimer in
             **     the documentation and/or other materials provided with the
             **     distribution.
             **   * Neither the name of Digia nor the names of its contributors
             **     may be used to endorse or promote products derived from this
             **     software without specific prior written permission.
             **
             ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
             ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
             ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
             ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
             ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
             ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
             ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
             ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
             ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
             ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
             ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QLineSeries>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 QLineSeries* series0 = new QLineSeries();
                 QPen blue(Qt::blue);
                 blue.setWidth(3);
                 series0->setPen(blue);
                 QLineSeries* series1 = new QLineSeries();
                 QPen red(Qt::red);
                 red.setWidth(3);
                 series1->setPen(red);
             //![1]
             //![2]
-                series0->add(0, 6);
+                series0->append(0, 6);
-                series0->add(2, 4);
+                series0->append(2, 4);
-                series0->add(3, 8);
+                series0->append(3, 8);
-                series0->add(7, 4);
+                series0->append(7, 4);
-                series0->add(10, 5);
+                series0->append(10, 5);
                 *series1 << QPointF(1, 1) << QPointF(3, 3) << QPointF(7, 6) << QPointF(8, 3) << QPointF(10, 2);
             //![2]
             //![3]
                 QChart* chart = new QChart();
                 chart->addSeries(series0);
                 chart->addSeries(series1);
                 chart->setTitle("Simple line chart example");
             //![3]
             //![4]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![4]
             //![5]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![5]
                 return a.exec();
             }

examples/multichart/multichartwidget.cpp +2 -2

             #include "multichartwidget.h"
             #include <QVBoxLayout>
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <qscatterseries.h>
             #include <qpieseries.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MultiChartWidget::MultiChartWidget(QWidget *parent) :
                 QWidget(parent)
             {
                 QVBoxLayout *l = new QVBoxLayout(this);
                 // Create chart 1 and add a simple pie series onto it
                 QChartView *chartView1 = new QChartView();
                 l->addWidget(chartView1);
                 QPieSeries *pie = new QPieSeries();
-                pie->add(1.1, "label1");
+                pie->append(1.1, "label1");
-                pie->add(1.2, "label2");
+                pie->append(1.2, "label2");
                 chartView1->addSeries(pie);
                 // Create chart 2 and add a simple scatter series onto it
                 QChartView *chartView2 = new QChartView();
                 l->addWidget(chartView2);
                 QScatterSeries *scatter = new QScatterSeries();
                 *scatter << QPointF(0.5, 5.0)
                          << QPointF(1.0, 4.5)
                          << QPointF(1.0, 5.5)
                          << QPointF(1.5, 5.0)
                          << QPointF(2.0, 4.5)
                          << QPointF(2.0, 5.5)
                          << QPointF(2.5, 5.0);
                 chartView2->addSeries(scatter);
             }

examples/piechart/main.cpp +5 -5

             /****************************************************************************
              **
              ** 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:BSD$
              ** You may use this file under the terms of the BSD license as follows:
              **
              ** "Redistribution and use in source and binary forms, with or without
              ** modification, are permitted provided that the following conditions are
              ** met:
              **   * Redistributions of source code must retain the above copyright
              **     notice, this list of conditions and the following disclaimer.
              **   * Redistributions in binary form must reproduce the above copyright
              **     notice, this list of conditions and the following disclaimer in
              **     the documentation and/or other materials provided with the
              **     distribution.
              **   * Neither the name of Digia nor the names of its contributors
              **     may be used to endorse or promote products derived from this
              **     software without specific prior written permission.
              **
              ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
              ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
              ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
              ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
              ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
              ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
              ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
              ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
              ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
              ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
              ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QPieSeries>
             #include <QPieSlice>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 QPieSeries *series = new QPieSeries();
-                series->add(1, "Slice 1");
+                series->append(1, "Slice 1");
-                series->add(2, "Slice 2");
+                series->append(2, "Slice 2");
-                series->add(3, "Slice 3");
+                series->append(3, "Slice 3");
-                series->add(4, "Slice 4");
+                series->append(4, "Slice 4");
-                series->add(5, "Slice 5");
+                series->append(5, "Slice 5");
             //![1]
             //![2]
                 QPieSlice *slice = series->slices().first();
                 slice->setExploded();
                 slice->setLabelVisible();
                 slice->setPen(QPen(Qt::darkGreen, 2));
                 slice->setBrush(Qt::green);
             //![2]
             //![3]
                 QChart* chart = new QChart();
                 chart->addSeries(series);
                 chart->setTitle("Simple piechart example");
             //![3]
             //![4]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![4]
             //![5]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![5]
                 return a.exec();
             }

examples/presenterchart/chartview.cpp +3 -3

             #include "chartview.h"
             #include <QLineSeries>
             #include <QScatterSeries>
             #include <QSplineSeries>
             #include <QAreaSeries>
             #include <QTime>
             ChartView::ChartView(QWidget* parent):QChartView(parent),
             m_index(0)
             {
                 setChartTitle("Charts presenter");
                 QObject::connect(&m_timer,SIGNAL(timeout()),this,SLOT(handleTimeout()));
                 m_timer.setInterval(3000);
             //![1]
                 QLineSeries* series0 = new QLineSeries(this);
                 QPen blue(Qt::blue);
                 blue.setWidth(3);
                 series0->setPen(blue);
                 QScatterSeries* series1 = new QScatterSeries(this);
                 QPen red(Qt::red);
                 red.setWidth(3);
                 series1->setPen(red);
                 series1->setBrush(Qt::white);
                 QSplineSeries* series2 = new QSplineSeries(this);
                 QPen green(Qt::green);
                 green.setWidth(3);
                 series2->setPen(green);
                 QAreaSeries* series3 = new QAreaSeries(series0);
                 QPen yellow(Qt::black);
                 yellow.setWidth(3);
                 series3->setPen(yellow);
                 series3->setBrush(Qt::yellow);
             //![1]
             //![2]
                 int numPoints = 10;
                 for (int x = 0; x <= numPoints; ++x) {
                     qreal y = qrand() % 100;
-                    series0->add(x,y);
+                    series0->append(x,y);
-                    series1->add(x,y);
+                    series1->append(x,y);
-                    series2->add(x,y);
+                    series2->append(x,y);
                 }
             //![2]
             //![3]
                 m_series<<series0;
                 m_titles<<chartTitle()+": LineChart";
                 m_series<<series1;
                 m_titles<<chartTitle()+": ScatterChart";
                 m_series<<series2;
                 m_titles<<chartTitle()+": SplineChart";
                 m_series<<series3;
                 m_titles<<chartTitle()+": AreaChart";
             //![3]
                 addSeries(series0);
                 setChartTitle(m_titles.at(0));
             //![4]
                 foreach (QSeries* series, m_series) {
                     QObject::connect(series,SIGNAL(clicked(const QPointF&)),this,SLOT(handlePointClicked(const QPointF&)));
                 }
             //![4]
                 m_timer.start();
             }
             ChartView::~ChartView()
             {
                 if(m_series.size()==0) return;
                 removeSeries(m_series.at(m_index));
                 qDeleteAll(m_series);
             }
             //![5]
             void ChartView::handleTimeout()
             {
                 if(m_series.size()==0) return;
                 removeSeries(m_series.at(m_index));
                 m_index++;
                 m_index=m_index%m_series.size();
                 addSeries(m_series.at(m_index));
                 setChartTitle(m_titles.at(m_index));
             }
             //![5]
             //![6]
             void ChartView::handlePointClicked(const QPointF& point)
             {
                 setChartTitle(m_titles.at(m_index) + QString(" x: %1 y: %2").arg(point.x()).arg(point.y()));
             }
             //![6]

examples/scatterchart/main.cpp +5 -5

             /****************************************************************************
              **
              ** 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:BSD$
              ** You may use this file under the terms of the BSD license as follows:
              **
              ** "Redistribution and use in source and binary forms, with or without
              ** modification, are permitted provided that the following conditions are
              ** met:
              **   * Redistributions of source code must retain the above copyright
              **     notice, this list of conditions and the following disclaimer.
              **   * Redistributions in binary form must reproduce the above copyright
              **     notice, this list of conditions and the following disclaimer in
              **     the documentation and/or other materials provided with the
              **     distribution.
              **   * Neither the name of Digia nor the names of its contributors
              **     may be used to endorse or promote products derived from this
              **     software without specific prior written permission.
              **
              ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
              ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
              ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
              ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
              ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
              ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
              ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
              ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
              ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
              ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
              ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QScatterSeries>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 QPen pen(Qt::black);
                 pen.setWidth(2);
                 QBrush blue(Qt::blue);
                 QBrush red(Qt::red);
                 QScatterSeries *series0 = new QScatterSeries();
                 series0->setPen(pen);
                 series0->setBrush(blue);
                 series0->setShape(QScatterSeries::MarkerShapeCircle);
                 series0->setSize(15.0);
                 QScatterSeries *series1 = new QScatterSeries();
                 series1->setPen(pen);
                 series1->setBrush(red);
                 series1->setShape(QScatterSeries::MarkerShapeCircle);
                 series1->setSize(15.0);
             //![1]
             //![2]
-                series0->add(0, 6);
+                series0->append(0, 6);
-                series0->add(2, 4);
+                series0->append(2, 4);
-                series0->add(3, 8);
+                series0->append(3, 8);
-                series0->add(7, 4);
+                series0->append(7, 4);
-                series0->add(10, 5);
+                series0->append(10, 5);
                 *series1 << QPointF(1, 1) << QPointF(3, 3) << QPointF(7, 6) << QPointF(8, 3) << QPointF(10, 2);
             //![2]
             //![3]
                 QChart* chart = new QChart();
                 chart->addSeries(series0);
                 chart->addSeries(series1);
                 chart->setTitle("Simple scatterchart example");
             //![3]
             //![4]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![4]
             //![5]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![5]
                 return a.exec();
             }

examples/splinechart/splinewidget.cpp +21 -21

             #include "splinewidget.h"
             #include "qchartview.h"
             #include "qlineseries.h"
             #include <QGridLayout>
             #include <QPushButton>
             #include "qchartaxis.h"
             #include <qmath.h>
             #include <QTime>
             QTCOMMERCIALCHART_USE_NAMESPACE
             SplineWidget::SplineWidget(QWidget *parent)
                 : QWidget(parent)
             {
             //    qsrand(time(NULL));
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
                 //! [1]
                 //create QSplineSeries
                 series = new QSplineSeries(this);
                 //! [1]
                 //! [2]
                 // customize the series presentation settings
                 QPen seriesPen(Qt::blue);
                 seriesPen.setWidth(3);
             //    series->setPen(seriesPen);
                 //! [2]
                 //! [add points to series]
                 //add data points to the series
-                series->add(QPointF(150, 100));
+                series->append(QPointF(150, 100));
-                series->add(QPointF(200, 130));
+                series->append(QPointF(200, 130));
-                series->add(QPointF(250, 120));
+                series->append(QPointF(250, 120));
-                series->add(QPointF(300, 140));
+                series->append(QPointF(300, 140));
-                series->add(QPointF(350, 160));
+                series->append(QPointF(350, 160));
                 //! [add points to series]
                 QSplineSeries* series2 = new QSplineSeries;
-                series2->add(QPointF(400, 120));
+                series2->append(QPointF(400, 120));
-                series2->add(QPointF(450, 150));
+                series2->append(QPointF(450, 150));
-                series2->add(QPointF(500, 145));
+                series2->append(QPointF(500, 145));
-                series2->add(QPointF(550, 170));
+                series2->append(QPointF(550, 170));
-            //    series->add(QPointF(600, 190));
+            //    series->append(QPointF(600, 190));
-            //    series->add(QPointF(650, 210));
+            //    series->append(QPointF(650, 210));
-            //    series->add(QPointF(700, 190));
+            //    series->append(QPointF(700, 190));
-            //    series->add(QPointF(750, 180));
+            //    series->append(QPointF(750, 180));
-            //    series->add(QPointF(800, 170));
+            //    series->append(QPointF(800, 170));
                 QSplineSeries* series3 = new QSplineSeries;
-                    series3->add(QPointF(600, 190));
+                    series3->append(QPointF(600, 190));
-                    series3->add(QPointF(650, 210));
+                    series3->append(QPointF(650, 210));
-                    series3->add(QPointF(700, 190));
+                    series3->append(QPointF(700, 190));
-                    series3->add(QPointF(750, 180));
+                    series3->append(QPointF(750, 180));
-                    series3->add(QPointF(800, 170));
+                    series3->append(QPointF(800, 170));
                 //! [3]
                 // create chart view
                 QChartView* chart = new QChartView;
                 chart->addSeries(series);
                 chart->addSeries(series2);
                 chart->addSeries(series3);
                 chart->setChartTitle("Spline chart example");
                 chart->axisX()->setMax(1500);
                 chart->axisY()->setMax(500);
                 chart->setMinimumSize(800,600);
                 //! [3]
                 //! [4]
                 //add new data point button
                 QPushButton* addButton = new QPushButton("Add new point");
                 connect(addButton, SIGNAL(clicked()), this, SLOT(addNewPoint()));
                 // remove the last data point in the series
                 QPushButton* removeButton = new QPushButton("Remove point");
                 connect(removeButton, SIGNAL(clicked()), this, SLOT(removePoint()));
                 //! [4]
                 //! [5]
                 //butttons layout
                 QVBoxLayout* buttonsLayout = new QVBoxLayout;
                 buttonsLayout->addWidget(addButton);
                 buttonsLayout->addWidget(removeButton);
                 buttonsLayout->addStretch();
                 QGridLayout* mainLayout = new QGridLayout;
                 mainLayout->addWidget(chart, 1, 0);
                 mainLayout->addLayout(buttonsLayout, 1, 1);
                 setLayout(mainLayout);
                 //! [5]
             }
             //! [add point]
             void SplineWidget::addNewPoint()
             {
                 if (series->count() > 0)
-                    series->add(QPointF(series->x(series->count() - 1) + 40 + qrand()%40, qAbs(series->y(series->count() - 1) - 50 + qrand()%100)));
+                    series->append(QPointF(series->x(series->count() - 1) + 40 + qrand()%40, qAbs(series->y(series->count() - 1) - 50 + qrand()%100)));
                 else
-                    series->add(QPointF(50, 50 + qrand()%50));
+                    series->append(QPointF(50, 50 + qrand()%50));
             }
             //! [add point]
             //! [remove point]
             void SplineWidget::removePoint()
             {
                 if (series->count() > 0)
                     series->remove(QPointF(series->x(series->count() - 1), series->y(series->count() - 1)));
             }
             //! [remove point]
             SplineWidget::~SplineWidget()
             {
             }

qmlplugin/declarativepieseries.cpp +1 -1

             #include "declarativepieseries.h"
             #include "declarativechart.h"
             #include "qchart.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativePieSeries::DeclarativePieSeries(QObject *parent) :
                 QPieSeries(parent),
                 m_chart(0)
             {
             }
             void DeclarativePieSeries::classBegin()
             {
             }
             void DeclarativePieSeries::componentComplete()
             {
                 DeclarativeChart *declarativeChart = qobject_cast<DeclarativeChart *>(parent());
                 if (declarativeChart) {
                     QChart *chart = qobject_cast<QChart *>(declarativeChart->m_chart);
                     Q_ASSERT(chart);
                     qDebug() << "parent for pie:" << chart;
                     chart->addSeries(this);
                 }
             }
             QDeclarativeListProperty<QPieSlice> DeclarativePieSeries::slices()
             {
                 return QDeclarativeListProperty<QPieSlice>(this, 0, &DeclarativePieSeries::appendSlice);
             }
             void DeclarativePieSeries::appendSlice(QDeclarativeListProperty<QPieSlice> *list,
                                                   QPieSlice *slice)
             {
                 DeclarativePieSeries *series = qobject_cast<DeclarativePieSeries *>(list->object);
                 if (series)
-                    series->add(slice->value(), slice->label());
+                    series->append(slice->value(), slice->label());
             }
             #include "moc_declarativepieseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

qmlplugin/declarativexyseries.cpp +1 -1

             //#include "DeclarativeXySeries.h"
             #include "declarativexyseries.h"
             #include "qxyseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeXySeries::DeclarativeXySeries()
             {
             }
             DeclarativeXySeries::~DeclarativeXySeries()
             {
             }
             void DeclarativeXySeries::classBegin()
             {
             }
             void DeclarativeXySeries::appendPoints(QDeclarativeListProperty<DeclarativeXyPoint> *list,
                                                       DeclarativeXyPoint *element)
             {
                 QXYSeries *series = qobject_cast<QXYSeries *>(list->object);
                 if (series)
-                    series->add(QPointF(element->x(), element->y()));
+                    series->append(QPointF(element->x(), element->y()));
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/areachart/qareaseries.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 "qareaseries.h"
             #include "qlineseries.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.
             	\image areachart.png
             	Creating basic area chart is simple:
             	\code
             	QLineSeries* lineSeries = new QLineSeries();
-            	series->add(0, 6);
+                series->append(0, 6);
-            	series->add(2, 4);
+                series->append(2, 4);
             	QAreaSeries* areaSeries = new QAreaSeries(lineSeries);
             	...
             	chartView->addSeries(areaSeries);
                 \endcode
             */
             /*!
                 \fn virtual QSeriesType QAreaSeries::type() const
                 \brief Returns type of series.
                 \sa QSeries, 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::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 transfered.
             */
             QAreaSeries::QAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries)
                 : QSeries(upperSeries),
                 m_upperSeries(upperSeries),
                 m_lowerSeries(lowerSeries),
                 m_pointsVisible(false)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QAreaSeries::~QAreaSeries()
             {
             }
             /*!
                 Sets \a pen used for drawing area outline.
             */
             void QAreaSeries::setPen(const QPen &pen)
             {
                 if (m_pen != pen) {
                     m_pen = pen;
                     emit updated();
                 }
             }
             /*!
                 Sets \a brush used for filling the area.
             */
             void QAreaSeries::setBrush(const QBrush &brush)
             {
                 if (m_brush != brush) {
                     m_brush = brush;
                     emit updated();
                 }
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QAreaSeries::setPointsVisible(bool visible)
             {
                 if (m_pointsVisible != visible) {
                     m_pointsVisible = visible;
                     emit updated();
                 }
             }
             //bool QAreaSeries::setModel(QAbstractItemModel* model)
             //{
             //    m_upperSeries->setModel(model);
             //    if (m_lowerSeries)
             //        m_lowerSeries->setModel(model);
             //    return true;
             //}
             //void QAreaSeries::setModelMappingUpper(int modelX, int modelY, Qt::Orientation orientation)
             //{
             //    m_upperSeries->setModelMapping(modelX, modelY, orientation);
             //}
             //void QAreaSeries::setModelMappingLower(int modelX, int modelY, Qt::Orientation orientation)
             //{
             //    if (m_lowerSeries)
             //        m_lowerSeries->setModelMapping(modelX, modelY, orientation);
             //}
             #include "moc_qareaseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/qlineseries.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 "qlineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLineSeries
                 \brief The QLineSeries class is used for making line charts.
                 \mainclass
             	A line chart is used to show information as a series of data points
             	connected by straight lines.
             	\image linechart.png
             	Creating basic line chart is simple:
             	\code
             	QLineSeries* series = new QLineSeries();
-            	series->add(0, 6);
+                series->append(0, 6);
-            	series->add(2, 4);
+                series->append(2, 4);
             	...
             	chartView->addSeries(series);
                 \endcode
             */
             /*!
                 \fn virtual QSeriesType QLineSeries::type() const
                 \brief Returns type of series.
                 \sa QSeries, QSeriesType
             */
             /*!
                \fn bool QLineSeries::pointsVisible() const
                \brief  Returns if the points are drawn for this series.
                 \sa setPointsVisible()
             */
             /*!
                \fn QPen QLineSeries::linePen() const
                \brief  Returns the pen used to draw line connecting points.
                 \sa setPen()
             */
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transfered.
             */
             QLineSeries::QLineSeries(QObject *parent) : QXYSeries(parent),
                 m_pointsVisible(false)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QLineSeries::~QLineSeries()
             {
             }
             /*!
                 Sets if data points are \a visible and should be drawn on line.
             */
             void QLineSeries::setPointsVisible(bool visible)
             {
                 if (m_pointsVisible != visible){
                     m_pointsVisible = visible;
                     emit QXYSeries::updated();
                 }
             }
             QDebug operator<< (QDebug debug, const QLineSeries series)
             {
                 Q_ASSERT(series.m_x.size() == series.m_y.size());
                 int size = series.m_x.size();
                 for (int i=0; i<size; i++) {
                     debug.nospace() << "(" << series.m_x.at(i) << ','<< series.m_y.at(i) << ") ";
                 }
                 return debug.space();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.cpp +9 -9

             /****************************************************************************
             **
             ** 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 "qpieseries.h"
             #include "qpiesliceprivate_p.h"
             #include "qpieseriesprivate_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QPieSeriesPrivate::QPieSeriesPrivate(QPieSeries *parent)
                 :QObject(parent),
                 q_ptr(parent),
                 m_pieRelativeHorPos(0.5),
                 m_pieRelativeVerPos(0.5),
                 m_pieRelativeSize(0.7),
                 m_pieStartAngle(0),
                 m_pieEndAngle(360),
                 m_total(0)
             {
             }
             QPieSeriesPrivate::~QPieSeriesPrivate()
             {
             }
             void QPieSeriesPrivate::updateDerivativeData()
             {
                 m_total = 0;
                 // nothing to do?
                 if (m_slices.count() == 0)
                     return;
                 // calculate total
                 foreach (QPieSlice* s, m_slices)
                     m_total += s->value();
                 // nothing to show..
                 if (qFuzzyIsNull(m_total))
                     return;
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
                 QVector<QPieSlice*> changed;
                 foreach (QPieSlice* s, m_slices) {
                     PieSliceData data = s->data_ptr()->m_data;
                     data.m_percentage = s->value() / m_total;
                     data.m_angleSpan = pieSpan * data.m_percentage;
                     data.m_startAngle = sliceAngle;
                     sliceAngle += data.m_angleSpan;
                     if (s->data_ptr()->m_data != data) {
                         s->data_ptr()->m_data = data;
                         changed << s;
                     }
                 }
                 // emit signals
                 foreach (QPieSlice* s, changed)
                     emit s->data_ptr()->changed();
             }
             void QPieSeriesPrivate::sliceChanged()
             {
                 Q_ASSERT(m_slices.contains(qobject_cast<QPieSlice *>(sender())));
                 updateDerivativeData();
             }
             void QPieSeriesPrivate::sliceClicked(Qt::MouseButtons buttons)
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->clicked(slice, buttons);
             }
             void QPieSeriesPrivate::sliceHoverEnter()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->hoverEnter(slice);
             }
             void QPieSeriesPrivate::sliceHoverLeave()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->hoverLeave(slice);
             }
             void QPieSeriesPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(bottomRight)
                 Q_Q(QPieSeries);
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     //        slices().at(topLeft.row())->setValue(m_model->data(m_model->index(topLeft.row(), topLeft.column()), Qt::DisplayRole).toDouble());
                     if (topLeft.column() == m_mapValues)
                         if (m_mapValues == m_mapLabels)
                         {
                             m_slices.at(topLeft.row())->setValue(q->m_model->data(topLeft, Qt::DisplayRole).toDouble());
                             m_slices.at(topLeft.row())->setLabel(q->m_model->data(topLeft, Qt::DisplayRole).toString());
                         }
                         else
                         {
                             m_slices.at(topLeft.row())->setValue(q->m_model->data(topLeft, Qt::DisplayRole).toDouble());
                         }
                     else if (topLeft.column() == m_mapLabels)
                         m_slices.at(topLeft.row())->setLabel(q->m_model->data(topLeft, Qt::DisplayRole).toString());
                 }
                 else
                 {
                     //        slices().at(topLeft.column())->setValue(m_model->data(m_model->index(topLeft.row(), topLeft.column()), Qt::DisplayRole).toDouble());
                     if (topLeft.row() == m_mapValues)
                         if (m_mapValues == m_mapLabels)
                         {
                             m_slices.at(topLeft.column())->setValue(q->m_model->data(topLeft, Qt::DisplayRole).toDouble());
                             m_slices.at(topLeft.column())->setLabel(q->m_model->data(topLeft, Qt::DisplayRole).toString());
                         }
                         else
                         {
                             m_slices.at(topLeft.column())->setValue(q->m_model->data(topLeft, Qt::DisplayRole).toDouble());
                         }
                     else if (topLeft.row() == m_mapLabels)
                         m_slices.at(topLeft.column())->setLabel(q->m_model->data(topLeft, Qt::DisplayRole).toString());
                 }
             }
             void QPieSeriesPrivate::modelDataAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 Q_Q(QPieSeries);
                 QPieSlice* newSlice = new QPieSlice;
                 newSlice->setLabelVisible(true);
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     newSlice->setValue(q->m_model->data(q->m_model->index(start, m_mapValues), Qt::DisplayRole).toDouble());
                     newSlice->setLabel(q->m_model->data(q->m_model->index(start, m_mapLabels), Qt::DisplayRole).toString());
                 }
                 else
                 {
                     newSlice->setValue(q->m_model->data(q->m_model->index(m_mapValues, start), Qt::DisplayRole).toDouble());
                     newSlice->setLabel(q->m_model->data(q->m_model->index(m_mapLabels, start), Qt::DisplayRole).toString());
                 }
                 q->insert(start, newSlice);
             }
             void QPieSeriesPrivate::modelDataRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 Q_Q(QPieSeries);
                 q->remove(m_slices.at(start));
             }
             /*!
                 \class QPieSeries
                 \brief Pie series API for QtCommercial Charts
                 The pie series defines a pie chart which consists of pie slices which are QPieSlice objects.
                 The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
                 The actual slice size is determined by that relative value.
                 By default the pie is defined as a full pie but it can be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent) :
                 QSeries(parent),
                 d_ptr(new QPieSeriesPrivate(this))
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QPieSeries::~QPieSeries()
             {
                 // NOTE: d_prt destroyed by QObject
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
             QSeries::QSeriesType QPieSeries::type() const
             {
                 return QSeries::SeriesTypePie;
             }
             /*!
                 Sets an array of \a slices to the series replacing the existing slices.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::replace(QList<QPieSlice*> slices)
             {
                 clear();
-                add(slices);
+                append(slices);
             }
             /*!
                 Adds an array of \a slices to the series.
                 Slice ownership is passed to the series.
             */
-            void QPieSeries::add(QList<QPieSlice*> slices)
+            void QPieSeries::append(QList<QPieSlice*> slices)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice* s, slices) {
                     s->setParent(this);
                     d->m_slices << s;
                 }
                 d->updateDerivativeData();
                 foreach (QPieSlice* s, slices) {
                     connect(s, SIGNAL(changed()), d, SLOT(sliceChanged()));
                     connect(s, SIGNAL(clicked(Qt::MouseButtons)), d, SLOT(sliceClicked(Qt::MouseButtons)));
                     connect(s, SIGNAL(hoverEnter()), d, SLOT(sliceHoverEnter()));
                     connect(s, SIGNAL(hoverLeave()), d, SLOT(sliceHoverLeave()));
                 }
                 emit added(slices);
             }
             /*!
                 Adds a single \a slice to the series.
                 Slice ownership is passed to the series.
             */
-            void QPieSeries::add(QPieSlice* slice)
+            void QPieSeries::append(QPieSlice* slice)
             {
-                add(QList<QPieSlice*>() << slice);
+                append(QList<QPieSlice*>() << slice);
             }
             /*!
                 Adds a single \a slice to the series and returns a reference to the series.
                 Slice ownership is passed to the series.
             */
             QPieSeries& QPieSeries::operator << (QPieSlice* slice)
             {
-                add(slice);
+                append(slice);
                 return *this;
             }
             /*!
                 Adds a single slice to the series with give \a value and \a name.
                 Slice ownership is passed to the series.
             */
-            QPieSlice* QPieSeries::add(qreal value, QString name)
+            QPieSlice* QPieSeries::append(qreal value, QString name)
             {
                 QPieSlice* slice = new QPieSlice(value, name);
-                add(slice);
+                append(slice);
                 return slice;
             }
             void QPieSeries::insert(int i, QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 Q_ASSERT(i <= d->m_slices.count());
                 slice->setParent(this);
                 d->m_slices.insert(i, slice);
                 d->updateDerivativeData();
                 connect(slice, SIGNAL(changed()), d, SLOT(sliceChanged()));
                 connect(slice, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                 connect(slice, SIGNAL(hoverEnter()), d, SLOT(sliceHoverEnter()));
                 connect(slice, SIGNAL(hoverLeave()), d, SLOT(sliceHoverLeave()));
                 emit added(QList<QPieSlice*>() << slice);
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference this pointer after this call.
             */
             void QPieSeries::remove(QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 if (!d->m_slices.removeOne(slice)) {
                     Q_ASSERT(0); // TODO: how should this be reported?
                     return;
                 }
                 d->updateDerivativeData();
                 emit removed(QList<QPieSlice*>() << slice);
                 delete slice;
                 slice = NULL;
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 Q_D(QPieSeries);
                 if (d->m_slices.count() == 0)
                     return;
                 QList<QPieSlice*> slices = d->m_slices;
                 foreach (QPieSlice* s, d->m_slices) {
                     d->m_slices.removeOne(s);
                     delete s;
                 }
                 d->updateDerivativeData();
                 emit removed(slices);
             }
             /*!
                 Counts the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.count();
             }
             /*!
                 Returns true is the series is empty.
             */
             bool QPieSeries::isEmpty() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.isEmpty();
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice*> QPieSeries::slices() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices;
             }
             /*!
                 Sets the center position of the pie by \a relativeHorizontalPosition and \a relativeVerticalPosition.
                 The factors are relative to the chart rectangle where:
                 \a relativeHorizontalPosition 0.0 means the absolute left.
                 \a relativeHorizontalPosition 1.0 means the absolute right.
                 \a relativeVerticalPosition 0.0 means the absolute top.
                 \a relativeVerticalPosition 1.0 means the absolute bottom.
                 By default both values are 0.5 which puts the pie in the middle of the chart rectangle.
                 \sa pieHorizontalPosition(), pieVerticalPosition(), setPieSize()
             */
             void QPieSeries::setPiePosition(qreal relativeHorizontalPosition, qreal relativeVerticalPosition)
             {
                 Q_D(QPieSeries);
                 if (relativeHorizontalPosition < 0.0 || relativeHorizontalPosition > 1.0 ||
                         relativeVerticalPosition < 0.0 || relativeVerticalPosition > 1.0)
                     return;
                 if (!qFuzzyIsNull(d->m_pieRelativeHorPos - relativeHorizontalPosition) ||
                     !qFuzzyIsNull(d->m_pieRelativeVerPos - relativeVerticalPosition)) {
                     d->m_pieRelativeHorPos = relativeHorizontalPosition;
                     d->m_pieRelativeVerPos = relativeVerticalPosition;
                     emit piePositionChanged();
                 }
             }
             /*!
                 Gets the horizontal position of the pie.
                 The returned value is relative to the chart rectangle where:
 .0 means the absolute left.
 .0 means the absolute right.
                 By default it is 0.5 which puts the pie in the horizontal middle of the chart rectangle.
                 \sa setPiePosition(), pieVerticalPosition(), setPieSize()
             */
             qreal QPieSeries::pieHorizontalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeHorPos;
             }
             /*!
                 Gets the vertical position position of the pie.
                 The returned value is relative to the chart rectangle where:
 .0 means the absolute top.
 .0 means the absolute bottom.
                 By default it is 0.5 which puts the pie in the vertical middle of the chart rectangle.
                 \sa setPiePosition(), pieHorizontalPosition(), setPieSize()
             */
             qreal QPieSeries::pieVerticalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeVerPos;
             }
             /*!
                 Sets the relative size of the pie.
                 The \a relativeSize is defined so that the 1.0 is the maximum that can fit the given chart rectangle.
                 Default value is 0.7.
                 \sa pieSize(), setPiePosition(), pieVerticalPosition(), pieHorizontalPosition()
             */
             void QPieSeries::setPieSize(qreal relativeSize)
             {
                 Q_D(QPieSeries);
                 if (relativeSize < 0.0 || relativeSize > 1.0)
                     return;
                 if (!qFuzzyIsNull(d->m_pieRelativeSize- relativeSize)) {
                     d->m_pieRelativeSize = relativeSize;
                     emit pieSizeChanged();
                 }
             }
             /*!
                 Gets the relative size of the pie.
                 The size is defined so that the 1.0 is the maximum that can fit the given chart rectangle.
                 Default value is 0.7.
                 \sa setPieSize(), setPiePosition(), pieVerticalPosition(), pieHorizontalPosition()
             */
             qreal QPieSeries::pieSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeSize;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be less than pie end angle. Default value is 0.
                 \sa pieStartAngle(), pieEndAngle(), setPieEndAngle()
             */
             void QPieSeries::setPieStartAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (angle < 0 || angle > 360 || angle > d->m_pieEndAngle)
                     return;
                 if (!qFuzzyIsNull(angle - d->m_pieStartAngle)) {
                     d->m_pieStartAngle = angle;
                     d->updateDerivativeData();
                 }
             }
             /*!
                 Gets the start angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock. Default value is 360.
                 \sa setPieStartAngle(), pieEndAngle(), setPieEndAngle()
             */
             qreal QPieSeries::pieStartAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieStartAngle;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be greater than start angle.
                 \sa pieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             void QPieSeries::setPieEndAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (angle < 0 || angle > 360 || angle < d->m_pieStartAngle)
                     return;
                 if (!qFuzzyIsNull(angle - d->m_pieEndAngle)) {
                     d->m_pieEndAngle = angle;
                     d->updateDerivativeData();
                 }
             }
             /*!
                 Returns the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \sa setPieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             qreal QPieSeries::pieEndAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieEndAngle;
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice* s, d->m_slices)
                     s->setLabelVisible(visible);
             }
             /*!
                 Returns the sum of all slice values in this series.
                 \sa QPieSlice::value(), QPieSlice::setValue()
             */
             qreal QPieSeries::total() const
             {
                 Q_D(const QPieSeries);
                 return d->m_total;
             }
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice)
                 This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
             /*!
                 \fn void QPieSeries::hoverEnter(QPieSlice* slice)
                 This signal is emitted when user has hovered over a \a slice.
                 \sa QPieSlice::hoverEnter()
             */
             /*!
                 \fn void QPieSeries::hoverLeave(QPieSlice* slice)
                 This signal is emitted when user has hovered away from a \a slice.
                 \sa QPieSlice::hoverLeave()
             */
             bool QPieSeries::setModel(QAbstractItemModel* model)
             {
                 Q_D(QPieSeries);
                 // disconnect signals from old model
                 if(m_model)
                 {
                     disconnect(m_model, 0, this, 0);
                     d->m_mapValues = -1;
                     d->m_mapLabels = -1;
                     d->m_mapOrientation = Qt::Vertical;
                 }
                 // set new model
                 if(model)
                 {
                     m_model = model;
                     return true;
                 }
                 else
                 {
                     m_model = NULL;
                     return false;
                 }
             }
             void QPieSeries::setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation)
             {
                 Q_D(QPieSeries);
                 if (m_model == NULL)
                     return;
                 d->m_mapValues = modelValuesLine;
                 d->m_mapLabels = modelLabelsLine;
                 d->m_mapOrientation = orientation;
                 // connect the signals
                 if (d->m_mapOrientation == Qt::Vertical) {
                     connect(m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                     connect(m_model, SIGNAL(rowsInserted(QModelIndex, int, int)), d, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), d, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 } else {
                     connect(m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                     connect(m_model, SIGNAL(columnsInserted(QModelIndex, int, int)), d, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(columnsRemoved(QModelIndex, int, int)), d, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 }
                 // create the initial slices set
                 if (d->m_mapOrientation == Qt::Vertical) {
                     for (int i = 0; i < m_model->rowCount(); i++)
-                        add(m_model->data(m_model->index(i, d->m_mapValues), Qt::DisplayRole).toDouble(), m_model->data(m_model->index(i, d->m_mapLabels), Qt::DisplayRole).toString());
+                        append(m_model->data(m_model->index(i, d->m_mapValues), Qt::DisplayRole).toDouble(), m_model->data(m_model->index(i, d->m_mapLabels), Qt::DisplayRole).toString());
                 } else {
                     for (int i = 0; i < m_model->columnCount(); i++)
-                        add(m_model->data(m_model->index(d->m_mapValues, i), Qt::DisplayRole).toDouble(), m_model->data(m_model->index(d->m_mapLabels, i), Qt::DisplayRole).toString());
+                        append(m_model->data(m_model->index(d->m_mapValues, i), Qt::DisplayRole).toDouble(), m_model->data(m_model->index(d->m_mapLabels, i), Qt::DisplayRole).toString());
                 }
             }
             #include "moc_qpieseries.cpp"
             #include "moc_qpieseriesprivate_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.h +3 -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$
             **
             ****************************************************************************/
             #ifndef PIESERIES_H
             #define PIESERIES_H
             #include <qseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSeriesPrivate;
             class QPieSlice;
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 QPieSeries(QObject *parent = 0);
                 virtual ~QPieSeries();
             public: // from QChartSeries
                 QSeriesType type() const;
             public:
                 // slice setters
-                void add(QPieSlice* slice);
+                void append(QPieSlice* slice);
-                void add(QList<QPieSlice*> slices);
+                void append(QList<QPieSlice*> slices);
                 void insert(int i, QPieSlice* slice);
                 void replace(QList<QPieSlice*> slices);
                 void remove(QPieSlice* slice);
                 void clear();
                 // slice getters
                 QList<QPieSlice*> slices() const;
                 // calculated data
                 int count() const;
                 bool isEmpty() const;
                 qreal total() const;
                 // pie customization
                 void setPiePosition(qreal relativeHorizontalPosition, qreal relativeVerticalPosition);
                 qreal pieHorizontalPosition() const;
                 qreal pieVerticalPosition() const;
                 void setPieSize(qreal relativeSize);
                 qreal pieSize() const;
                 void setPieStartAngle(qreal startAngle);
                 qreal pieStartAngle() const;
                 void setPieEndAngle(qreal endAngle);
                 qreal pieEndAngle() const;
                 // convenience function
                 QPieSeries& operator << (QPieSlice* slice);
-                QPieSlice* add(qreal value, QString name);
+                QPieSlice* append(qreal value, QString name);
                 void setLabelsVisible(bool visible = true);
                 // data from model
                 bool setModel(QAbstractItemModel* model);
                 void setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation = Qt::Vertical);
             Q_SIGNALS:
                 void clicked(QPieSlice* slice, Qt::MouseButtons buttons);
                 void hoverEnter(QPieSlice* slice);
                 void hoverLeave(QPieSlice* slice);
                 void added(QList<QPieSlice*> slices);
                 void removed(QList<QPieSlice*> slices);
                 void piePositionChanged();
                 void pieSizeChanged();
             private:
                 QPieSeriesPrivate * const d_ptr;
                 Q_DECLARE_PRIVATE(QPieSeries)
                 Q_DISABLE_COPY(QPieSeries)
             public:
                 typedef QPieSeriesPrivate * const DataPtr;
                 inline DataPtr &data_ptr() { return d_ptr; }
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

src/piechart/qpieslice.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 "qpieslice.h"
             #include "qpiesliceprivate_p.h"
             #include "qpieseries.h"
             #include "qpieseriesprivate_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSlice
                 \brief Defines a slice in pie series.
                 Holds all the data of a single slice in a QPieSeries and provides the means
                 to modify slice data and customize the visual appearance of the slice.
                 It also provides the means to customize user interaction with the slice by
                 providing signals for clicking and hover events.
             */
             /*!
                 \property QPieSlice::label
                 Label of the slice.
             */
             /*!
                 \property QPieSlice::value
                 Value of the slice.
             */
             /*!
                 Constructs an empty slice with a \a parent.
                 Note that QPieSeries takes ownership of the slice when it is set/added.
-                \sa QPieSeries::replace(), QPieSeries::add()
+                \sa QPieSeries::replace(), QPieSeries::append()
             */
             QPieSlice::QPieSlice(QObject *parent)
                 :QObject(parent),
                 d_ptr(new QPieSlicePrivate(this))
             {
             }
             /*!
                 Constructs an empty slice with given \a value, \a label and a \a parent.
                 Note that QPieSeries takes ownership of the slice when it is set/added.
-                \sa QPieSeries::replace(), QPieSeries::add()
+                \sa QPieSeries::replace(), QPieSeries::append()
             */
             QPieSlice::QPieSlice(qreal value, QString label, QObject *parent)
                 :QObject(parent),
                 d_ptr(new QPieSlicePrivate(this))
             {
                 Q_D(QPieSlice);
                 d->m_data.m_value = value;
                 d->m_data.m_labelText = label;
             }
             /*!
                 Destroys the slice.
                 User should not delete the slice if it has been added to the series.
             */
             QPieSlice::~QPieSlice()
             {
                 delete d_ptr;
             }
             /*!
                 Gets the value of the slice.
                 Note that all values in the series
                 \sa setValue()
             */
             qreal QPieSlice::value() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_value;
             }
             /*!
                 Gets the label of the slice.
                 \sa setLabel()
             */
             QString QPieSlice::label() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_labelText;
             }
             /*!
                 Returns true if label is set as visible.
                 \sa setLabelVisible()
             */
             bool QPieSlice::isLabelVisible() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_isLabelVisible;
             }
             /*!
                 Returns true if slice is exloded from the pie.
                 \sa setExploded(), setExplodeDistanceFactor()
             */
             bool QPieSlice::isExploded() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_isExploded;
             }
             /*!
                 Returns the explode distance factor.
                 The factor is relative to pie radius. For example:
 .0 means the distance is the same as the radius.
 .5 means the distance is half of the radius.
                 Default value is 0.15.
                 \sa setExplodeDistanceFactor()
             */
             qreal QPieSlice::explodeDistanceFactor() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_explodeDistanceFactor;
             }
             /*!
                 Returns the percentage of this slice compared to all slices in the same series.
                 The returned value ranges from 0 to 1.0.
                 Updated internally after the slice is added to the series.
             */
             qreal QPieSlice::percentage() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_percentage;
             }
             /*!
                 Returns the starting angle of this slice in the series it belongs to.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated internally after the slice is added to the series.
             */
             qreal QPieSlice::startAngle() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_startAngle;
             }
             /*!
                 Returns the end angle of this slice in the series it belongs to.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated internally after the slice is added to the series.
             */
             qreal QPieSlice::endAngle() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_startAngle + d->m_data.m_angleSpan;
             }
             /*!
                 Returns the pen used to draw this slice.
                 \sa setSlicePen()
             */
             QPen QPieSlice::pen() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_slicePen;
             }
             /*!
                 Returns the brush used to draw this slice.
                 \sa setSliceBrush()
             */
             QBrush QPieSlice::brush() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_sliceBrush;
             }
             /*!
                 Returns the pen used to draw the label in this slice.
                 \sa setLabelArmPen()
             */
             QPen QPieSlice::labelPen() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_labelPen;
             }
             /*!
                 Returns the font used to draw label in this slice.
                 \sa setLabelFont()
             */
             QFont QPieSlice::labelFont() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_labelFont;
             }
             /*!
                 Gets the label arm length factor.
                 The factor is relative to pie radius. For example:
 .0 means the length is the same as the radius.
 .5 means the length is half of the radius.
                 Default value is 0.15
                 \sa setLabelArmLengthFactor()
             */
             qreal QPieSlice::labelArmLengthFactor() const
             {
                 Q_D(const QPieSlice);
                 return d->m_data.m_labelArmLengthFactor;
             }
             /*!
                 \fn void QPieSlice::clicked()
                 This signal is emitted when user has clicked the slice.
                 \sa QPieSeries::clicked()
             */
             /*!
                 \fn void QPieSlice::hoverEnter()
                 This signal is emitted when user has hovered over the slice.
                 \sa QPieSeries::hoverEnter()
             */
             /*!
                 \fn void QPieSlice::hoverLeave()
                 This signal is emitted when user has hovered away from the slice.
                 \sa QPieSeries::hoverLeave()
             */
             /*!
                 \fn void QPieSlice::changed()
                 This signal emitted when something has changed in the slice.
                 \sa QPieSeries::changed()
             */
             /*!
                 Sets the \a value of this slice.
                 \sa value()
             */
             void QPieSlice::setValue(qreal value)
             {
                 Q_D(QPieSlice);
                 if (!qFuzzyIsNull(d->m_data.m_value - value)) {
                     d->m_data.m_value = value;
                     QPieSeries *series = qobject_cast<QPieSeries*>(parent());
                     if (series)
                         series->data_ptr()->updateDerivativeData(); // will emit changed()
                     else
                         emit changed();
                 }
             }
             /*!
                 Sets the \a label of the slice.
                 \sa label()
             */
             void QPieSlice::setLabel(QString label)
             {
                 Q_D(QPieSlice);
                 if (d->m_data.m_labelText != label) {
                     d->m_data.m_labelText = label;
                     emit changed();
                 }
             }
             /*!
                 Sets the label \a visible in this slice.
                 \sa isLabelVisible(), QPieSeries::setLabelsVisible()
             */
             void QPieSlice::setLabelVisible(bool visible)
             {
                 Q_D(QPieSlice);
                 if (d->m_data.m_isLabelVisible != visible) {
                     d->m_data.m_isLabelVisible = visible;
                     emit changed();
                 }
             }
             /*!
                 Sets this slice \a exploded.
                 \sa isExploded(), explodeDistanceFactor()
             */
             void QPieSlice::setExploded(bool exploded)
             {
                 Q_D(QPieSlice);
                 if (d->m_data.m_isExploded != exploded) {
                     d->m_data.m_isExploded = exploded;
                     emit changed();
                 }
             }
             /*!
                 Sets the explode distance \a factor.
                 The factor is relative to pie radius. For example:
 .0 means the distance is the same as the radius.
 .5 means the distance is half of the radius.
                 Default value is 0.15
                 \sa explodeDistanceFactor()
             */
             void QPieSlice::setExplodeDistanceFactor(qreal factor)
             {
                 Q_D(QPieSlice);
                 if (!qFuzzyIsNull(d->m_data.m_explodeDistanceFactor - factor)) {
                     d->m_data.m_explodeDistanceFactor = factor;
                     emit changed();
                 }
             }
             /*!
                 Sets the \a pen used to draw this slice.
                 Note that applying a theme will override this.
                 \sa slicePen()
             */
             void QPieSlice::setPen(const QPen &pen)
             {
                 Q_D(QPieSlice);
                 if (d->m_data.m_slicePen != pen) {
                     d->m_data.m_slicePen = pen;
                     d->m_data.m_slicePen.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the \a brush used to draw this slice.
                 Note that applying a theme will override this.
                 \sa sliceBrush()
             */
             void QPieSlice::setBrush(const QBrush &brush)
             {
                 Q_D(QPieSlice);
                 if (d->m_data.m_sliceBrush != brush) {
                     d->m_data.m_sliceBrush = brush;
                     d->m_data.m_sliceBrush.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the \a pen used to draw the label in this slice.
                 Note that applying a theme will override this.
                 \sa labelArmPen()
             */
             void QPieSlice::setLabelPen(const QPen &pen)
             {
                 Q_D(QPieSlice);
                 if (d->m_data.m_labelPen != pen) {
                     d->m_data.m_labelPen = pen;
                     d->m_data.m_labelPen.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the \a font used to draw the label in this slice.
                 Note that applying a theme will override this.
                 \sa labelFont()
             */
             void QPieSlice::setLabelFont(const QFont &font)
             {
                 Q_D(QPieSlice);
                 if (d->m_data.m_labelFont != font) {
                     d->m_data.m_labelFont = font;
                     d->m_data.m_labelFont.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the label arm length \a factor.
                 The factor is relative to pie radius. For example:
 .0 means the length is the same as the radius.
 .5 means the length is half of the radius.
                 Default value is 0.15
                 \sa labelArmLengthFactor()
             */
             void QPieSlice::setLabelArmLengthFactor(qreal factor)
             {
                 Q_D(QPieSlice);
                 if (!qFuzzyIsNull(d->m_data.m_labelArmLengthFactor - factor)) {
                     d->m_data.m_labelArmLengthFactor = factor;
                     emit changed();
                 }
             }
             #include "moc_qpieslice.cpp"
             #include "moc_qpiesliceprivate_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/qscatterseries.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 "qscatterseries.h"
             #include "qchart.h"
             /*!
                 \class QScatterSeries
                 \brief The QScatterSeries class is used for making scatter charts.
                 \mainclass
                 The scatter data is displayed as a collection of points on the chart. Each point determines the position on the horizontal axis
                 and the vertical axis.
                 \image scatterchart.png
                 Creating basic scatter chart is simple:
                 \code
                 QScatterSeries* series = new QScatterSeries();
-                series->add(0, 6);
+                series->append(0, 6);
-                series->add(2, 4);
+                series->append(2, 4);
                 ...
                 chartView->addSeries(series);
                 \endcode
             */
             /*!
                 \enum QScatterSeries::MarkerShape
                 This enum describes the shape used when rendering marker items.
                 \value MarkerShapeCircle
                 \value MarkerShapeRectangle
             */
             /*!
                 \fn QChartSeriesType QScatterSeries::type() const
                 \brief Returns QChartSeries::SeriesTypeScatter.
                 \sa QSeries, QSeriesType
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QScatterSeries::QScatterSeries(QObject *parent) :
                 QXYSeries(parent),
                 m_shape(QScatterSeries::MarkerShapeCircle),
                 m_size(15.0)
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QScatterSeries::~QScatterSeries()
             {
             }
             /*!
                 Returns the shape used for drawing markers.
             */
             QScatterSeries::MarkerShape QScatterSeries::shape() const
             {
                 return m_shape;
             }
             /*!
                 Overrides the default shape of the marker items with a user defined \a shape. The default shape
                 is defined by chart theme setting.
             */
             void QScatterSeries::setShape(MarkerShape shape)
             {
                 if (m_shape != shape) {
                     m_shape = shape;
                     emit QXYSeries::updated();
                 }
             }
             /*!
                 Returns the size of the marker items.
             */
             qreal QScatterSeries::size() const
             {
                 return m_size;
             }
             /*!
                 Set the \a size of the marker items. The default size is 9.0.
             */
             void QScatterSeries::setSize(qreal size)
             {
                 if (!qFuzzyIsNull(m_size - size)) {
                     m_size = size;
                     emit updated();
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.cpp +9 -9

             /****************************************************************************
             **
             ** 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"
             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::pointReplaced(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeries::pointAdded(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeries::pointRemoved(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeries::updated()
                 \brief \internal
             */
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transfered.
             */
             QXYSeries::QXYSeries(QObject *parent):QSeries(parent)
             {
                 m_mapX = -1;
                 m_mapY = -1;
                 m_mapFirst = 0;
                 m_mapCount = 0;
                 m_mapLimited = false;
                 m_mapOrientation = Qt::Vertical;
                 //    m_mapYOrientation = Qt::Vertical;
             }
             /*!
                 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::add(qreal x,qreal y)
+            void QXYSeries::append(qreal x,qreal y)
             {
                 Q_ASSERT(m_x.size() == m_y.size());
                 m_x<<x;
                 m_y<<y;
                 emit pointAdded(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::add(const QPointF &point)
+            void QXYSeries::append(const QPointF &point)
             {
-                add(point.x(),point.y());
+                append(point.x(),point.y());
             }
             /*!
                This is an overloaded function.
                Adds list of data \a points to the series. Points are connected with lines on the chart.
              */
-            void QXYSeries::add(const QList<QPointF> points)
+            void QXYSeries::append(const QList<QPointF> points)
             {
                 foreach(const QPointF& point , points) {
-                    add(point.x(),point.y());
+                    append(point.x(),point.y());
                 }
             }
             /*!
               Modifies \a y value for given \a x a value.
             */
             void QXYSeries::replace(qreal x,qreal y)
             {
                 int index = m_x.indexOf(x);
                 m_x[index] = x;
                 m_y[index] = y;
                 emit pointReplaced(index);
             }
             /*!
               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());
             }
             /*!
               Removes first \a x value and related y value.
             */
             void QXYSeries::remove(qreal x)
             {
                 int index = m_x.indexOf(x);
                 if (index == -1) return;
                 m_x.remove(index);
                 m_y.remove(index);
                 emit pointRemoved(index);
             }
             /*!
               Removes current \a x and \a y value.
             */
             void QXYSeries::remove(qreal x,qreal y)
             {
                 int index =-1;
                 do {
                     index = m_x.indexOf(x,index+1);
                 } while (index !=-1 && m_y.at(index)!=y);
                 if (index==-1) return;
                 m_x.remove(index);
                 m_y.remove(index);
                 emit 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());
             }
             /*!
                Removes all data points from the series.
             */
             void QXYSeries::removeAll()
             {
                 m_x.clear();
                 m_y.clear();
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::x(int pos) const
             {
                 if (m_model) {
                     if (m_mapOrientation == Qt::Vertical)
                         // consecutive data is read from model's column
                         return m_model->data(m_model->index(pos + m_mapFirst, m_mapX), Qt::DisplayRole).toDouble();
                     else
                         // consecutive data is read from model's row
                         return m_model->data(m_model->index(m_mapX, pos + m_mapFirst), Qt::DisplayRole).toDouble();
                 } else {
                     // model is not specified, return the data from series' internal data store
                     return m_x.at(pos);
                 }
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::y(int pos) const
             {
                 if (m_model) {
                     if (m_mapOrientation == Qt::Vertical)
                         // consecutive data is read from model's column
                         return m_model->data(m_model->index(pos + m_mapFirst, m_mapY), Qt::DisplayRole).toDouble();
                     else
                         // consecutive data is read from model's row
                         return m_model->data(m_model->index(m_mapY, pos + m_mapFirst), Qt::DisplayRole).toDouble();
                 } else {
                     // model is not specified, return the data from series' internal data store
                     return m_y.at(pos);
                 }
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_ASSERT(m_x.size() == m_y.size());
                 if (m_model) {
                     if (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 (m_mapLimited)
                             return qMin(m_mapCount, qMax(m_model->rowCount() - m_mapFirst, 0));
                         else
                             return qMax(m_model->rowCount() - 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 (m_mapLimited)
                             return qMin(m_mapCount, qMax(m_model->columnCount() - m_mapFirst, 0));
                         else
                             return qMax(m_model->columnCount() - m_mapFirst, 0);
                     }
                 }
                 // model is not specified, return the number of points in the series internal data store
                 return m_x.size();
             }
             /*!
                 Returns the data points of the series.
             */
             QList<QPointF> QXYSeries::data()
             {
                 QList<QPointF> data;
                 for (int i(0); i < m_x.count() && i < m_y.count(); i++)
                     data.append(QPointF(m_x.at(i), 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::setChartTheme()
             */
             void QXYSeries::setPen(const QPen &pen)
             {
                 if (pen != m_pen) {
                     m_pen = pen;
                     emit updated();
                 }
             }
             /*!
                 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::setChartTheme()
             */
             void QXYSeries::setBrush(const QBrush &brush)
             {
                 if (brush != m_brush) {
                     m_brush = brush;
                     emit updated();
                 }
             }
             /*!
                 Stream operator for adding a data \a point to the series.
-                \sa add()
+                \sa append()
             */
             QXYSeries& QXYSeries::operator<< (const QPointF &point)
             {
-                add(point);
+                append(point);
                 return *this;
             }
             /*!
                 Stream operator for adding a list of \a points to the series.
-                \sa add()
+                \sa append()
             */
             QXYSeries& QXYSeries::operator<< (const QList<QPointF> points)
             {
-                add(points);
+                append(points);
                 return *this;
             }
             void QXYSeries::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(bottomRight)
                 if (m_mapOrientation == Qt::Vertical) {
                     if (topLeft.row() >= m_mapFirst && (!m_mapLimited || topLeft.row() < m_mapFirst + m_mapCount))
                         emit pointReplaced(topLeft.row() - m_mapFirst);
                 } else {
                     if (topLeft.column() >= m_mapFirst && (!m_mapLimited || topLeft.column() < m_mapFirst + m_mapCount))
                         emit pointReplaced(topLeft.column() - m_mapFirst);
                 }
             }
             void QXYSeries::modelDataAboutToBeAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 //    Q_UNUSED(end)
                 if (m_mapLimited) {
                     if (start >= m_mapFirst + m_mapCount) {
                         // the added data is below mapped area
                         // therefore it has no relevance
                         return;
                     } else {
                         // the added data is in the mapped area or before it and update is needed
                         // check how many mapped items there is currently (before new items are added)
                         // if the number of items currently is equal the m_mapCount then some needs to be removed from xychartitem
                         // internal storage before new ones can be added
                         int itemsToRemove = qMin(count() - (start - m_mapFirst), end - start + 1);
                         if (m_mapCount == count()) {
                             for (int i = 0; i < itemsToRemove; i++)
                                 emit pointRemoved(count() - 1 - i);
                         }
                     }
                 } else {
                     // map is not limited (it includes all the items starting from m_mapFirst till the end of model)
                     // nothing to do
                     //        emit pointAdded(qMax(start - m_mapFirst, 0));
                 }
             }
             void QXYSeries::modelDataAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 //    Q_UNUSED(end)
                 if (m_mapLimited) {
                     if (start >= m_mapFirst + m_mapCount) {
                         // the added data is below mapped area
                         // therefore it has no relevance
                         return;
                     } else {
                         // the added data is in the mapped area or before it
                         // update needed
                         if (count() > 0) {
                             for (int i = 0; i < qMin(m_mapCount - (start - m_mapFirst), end - start + 1); i++)
                                 emit pointAdded(qMax(start + i - m_mapFirst, 0));
                         }
                     }
                 } else {
                     // map is not limited (it included all the items starting from m_mapFirst till the end of model)
                     for (int i = 0; i < end - start + 1; i++)
                         emit pointAdded(qMax(start + i - m_mapFirst, 0));
                 }
             }
             void QXYSeries::modelDataAboutToBeRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 //    Q_UNUSED(end)
                 if (m_mapLimited) {
                     if (start >= m_mapFirst + m_mapCount) {
                         // the removed data is below mapped area
                         // therefore it has no relevance
                         return;
                     } else {
                         // the removed data is in the mapped area or before it
                         // update needed
                         // check how many items need to be removed from the xychartitem storage
                         // the number equals the number of items that are removed and that lay before
                         // or in the mapped area. Items that lay beyond the map do not count
                         // the max is the current number of items in storage (count())
                         int itemsToRemove = qMin(count(), qMin(end, m_mapFirst + m_mapCount - 1) - start + 1);
                         for (int i = 0; i < itemsToRemove; i++)
                             emit pointRemoved(qMax(start - m_mapFirst, 0));
                     }
                 } else {
                     // map is not limited (it included all the items starting from m_mapFirst till the end of model)
                     for (int i = 0; i < end - start + 1; i++)
                         emit pointRemoved(qMax(start - m_mapFirst, 0));
                 }
             }
             void QXYSeries::modelDataRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 // how many items there were before data was removed
                 //    int oldCount = count() - 1;
                 if (m_mapLimited) {
                     if (start >= m_mapFirst + m_mapCount) {
                         // the removed data is below mapped area
                         // therefore it has no relevance
                         return;
                     } else {
                         // if the current items count in the whole model is bigger than the index of the last item
                         // that was removed than it means there are some extra items available
                         int extraItemsAvailable = 0;
                         if (m_mapOrientation == Qt::Vertical) {
                             extraItemsAvailable = qMax(m_model->rowCount() - end, 0);
                         } else {
                             extraItemsAvailable = qMax(m_model->columnCount() - end, 0);
                         }
                         // if there are excess items available (below the mapped area) use them to repopulate mapped area
                         int removedItemsCount = qMin(count(), qMin(end, m_mapFirst + m_mapCount - 1) - qMax(start, m_mapFirst) + 1);
                         int toBeAdded = qMin(extraItemsAvailable, removedItemsCount);
                         for (int k = 0; k < toBeAdded; k++)
                             emit pointAdded(qMax(start - m_mapFirst, m_mapFirst) + k);
                     }
                 } else {
                     // data was removed from XYSeries interal storage. Nothing more to do
                 }
             }
             bool QXYSeries::setModel(QAbstractItemModel *model) {
                 // disconnect signals from old model
                 if (m_model) {
                     disconnect(m_model, 0, this, 0);
                     m_mapX = -1;
                     m_mapY = -1;
                     m_mapFirst = 0;
                     m_mapCount = 0;
                     m_mapLimited = false;
                     m_mapOrientation = Qt::Vertical;
                 }
                 // set new model
                 if (model) {
                     m_model = model;
                     return true;
                 } else {
                     m_model = 0;
                     return false;
                 }
             }
             void QXYSeries::setModelMapping(int modelX, int modelY, Qt::Orientation orientation)
             {
                 if (m_model == 0)
                     return;
                 m_mapX = modelX;
                 m_mapY = modelY;
                 m_mapFirst = 0;
                 m_mapOrientation = orientation;
                 if (m_mapOrientation == Qt::Vertical) {
                     //        m_mapCount = m_model->rowCount();
                     connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                     connect(m_model,SIGNAL(rowsAboutToBeInserted(QModelIndex, int, int)), this, SLOT(modelDataAboutToBeAdded(QModelIndex,int,int)));
                     connect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(rowsAboutToBeRemoved(QModelIndex, int, int)), this, SLOT(modelDataAboutToBeRemoved(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 } else {
                     //        m_mapCount = m_model->columnCount();
                     connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                     connect(m_model,SIGNAL(columnsAboutToBeInserted(QModelIndex, int, int)), this, SLOT(modelDataAboutToBeAdded(QModelIndex,int,int)));
                     connect(m_model,SIGNAL(columnsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(columnsAboutToBeRemoved(QModelIndex, int, int)), this, SLOT(modelDataAboutToBeRemoved(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(columnsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 }
             }
             void QXYSeries::setModelMappingShift(int first, int count)
             {
                 m_mapFirst = first;
                 if (count == 0) {
                     m_mapLimited = false;
                 } else {
                     m_mapCount = count;
                     m_mapLimited = true;
                 }
             }
             #include "moc_qxyseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.h +3 -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$
             **
             ****************************************************************************/
             #ifndef QXYSERIES_H_
             #define QXYSERIES_H_
             #include <qchartglobal.h>
             #include <qseries.h>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QXYSeries : public QSeries
             {
                 Q_OBJECT
             protected:
                 QXYSeries(QObject *parent = 0);
                 virtual ~QXYSeries();
             public:
-                void add(qreal x, qreal y);
+                void append(qreal x, qreal y);
-                void add(const QPointF &point);
+                void append(const QPointF &point);
-                void add(const QList<QPointF> points);
+                void append(const QList<QPointF> points);
                 void replace(qreal x,qreal y);
                 void replace(const QPointF &point);
                 void remove(qreal x);
                 void remove(qreal x, qreal y);
                 void remove(const QPointF &point);
                 void removeAll();
                 int count() const;
                 qreal x(int pos) const;
                 qreal y(int pos) const;
                 QList<QPointF> data();
                 QXYSeries& operator << (const QPointF &point);
                 QXYSeries& operator << (const QList<QPointF> points);
                 void setPen(const QPen &pen);
                 QPen pen() const {return m_pen;}
                 void setBrush(const QBrush &brush);
                 QBrush brush() const {return m_brush;}
                 bool setModel(QAbstractItemModel *model);
                 QAbstractItemModel* model() const { return m_model; }
                 virtual void setModelMapping(int modelX, int modelY, Qt::Orientation orientation = Qt::Vertical);
                 virtual void setModelMappingShift(int first, int count = 0);
             private Q_SLOTS:
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelDataAboutToBeAdded(QModelIndex parent, int start, int end);
                 void modelDataAdded(QModelIndex parent, int start, int end);
                 void modelDataAboutToBeRemoved(QModelIndex parent, int start, int end);
                 void modelDataRemoved(QModelIndex parent, int start, int end);
             Q_SIGNALS:
                 void clicked(const QPointF &point);
                 void updated();
                 void pointReplaced(int index);
                 void pointRemoved(int index);
                 void pointAdded(int index);
             protected:
                 QVector<qreal> m_x;
                 QVector<qreal> m_y;
                 QPen m_pen;
                 QBrush m_brush;
                 int m_mapX;
                 int m_mapY;
                 int m_mapFirst;
                 int m_mapCount;
                 bool m_mapLimited;
                 Qt::Orientation m_mapOrientation;
                 int tempItemsRemoved;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages