HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1194:d962cd819f79

Renamed appendBarSet to append, removeBarSet to remove

sauimone -

r1194:d962cd819f79

parent child

Context file:

r1194:d962cd819f79

Collapse all files

demos/chartthemes/themewidget.cpp +1 -1

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

examples/barchart/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$
             ** 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 <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QBarSeries>
             #include <QBarSet>
             #include <QLegend>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 QBarCategories categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
             //![1]
             //![2]
                 QBarSet *set0 = new QBarSet("Jane");
                 QBarSet *set1 = new QBarSet("John");
                 QBarSet *set2 = new QBarSet("Axel");
                 QBarSet *set3 = new QBarSet("Mary");
                 QBarSet *set4 = new QBarSet("Samantha");
                 *set0 << QPointF(0.0, 1) << QPointF(1.0, 2) << QPointF(2.4, 3) << QPointF(3.0, 4) << QPointF(4.0, 5) << QPointF(5.0, 6);
                 *set1 << QPointF(0.1, 2) << QPointF(1.2, 3) << QPointF(2.45, 4) << QPointF(3.2, 5) << QPointF(4.2, 6) << QPointF(5.2, 7);
                 *set2 << QPointF(0.2, 3) << QPointF(1.4, 4) << QPointF(2.50, 5) << QPointF(3.4, 6) << QPointF(4.4, 7) << QPointF(5.4, 8);
                 *set3 << QPointF(0.3, 4) << QPointF(1.6, 5) << QPointF(2.55, 6) << QPointF(3.6, 7) << QPointF(4.6, 8) << QPointF(5.6, 9);
                 *set4 << QPointF(0.4, 5) << QPointF(1.8, 6) << QPointF(2.6, 7) << QPointF(3.8, 8) << QPointF(4.8, 9) << QPointF(5.8, 10);
             //![2]
             //![3]
                 QBarSeries* series = new QBarSeries();
                 series->setCategories(categories);
-                series->appendBarSet(set0);
+                series->append(set0);
-                series->appendBarSet(set1);
+                series->append(set1);
-                series->appendBarSet(set2);
+                series->append(set2);
-                series->appendBarSet(set3);
+                series->append(set3);
-                series->appendBarSet(set4);
+                series->append(set4);
             //![3]
             //![4]
                 QChart* chart = new QChart();
                 chart->addSeries(series);
                 chart->setTitle("Simple barchart example");
             //![4]
             //![5]
                 chart->legend()->setVisible(true);
                 chart->legend()->setAlignment(QLegend::AlignmentBottom);
                 chart->axisY()->setNiceNumbersEnabled(true);
             //![5]
             //![6]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![6]
             //![7]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![7]
                 return a.exec();
             }

examples/groupedbarchart/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$
             ** 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 <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QGroupedBarSeries>
             #include <QBarSet>
             #include <QLegend>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 QBarCategories categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
             //![1]
             //![2]
                 QBarSet *set0 = new QBarSet("Jane");
                 QBarSet *set1 = new QBarSet("John");
                 QBarSet *set2 = new QBarSet("Axel");
                 QBarSet *set3 = new QBarSet("Mary");
                 QBarSet *set4 = new QBarSet("Samantha");
                 *set0 << 1 << 2 << 3 << 4 << 5 << 6;
                 *set1 << 5 << 0 << 0 << 4 << 0 << 7;
                 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
                 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
                 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
             //![2]
             //![3]
                 QGroupedBarSeries* series = new QGroupedBarSeries();
                 series->setCategories(categories);
-                series->appendBarSet(set0);
+                series->append(set0);
-                series->appendBarSet(set1);
+                series->append(set1);
-                series->appendBarSet(set2);
+                series->append(set2);
-                series->appendBarSet(set3);
+                series->append(set3);
-                series->appendBarSet(set4);
+                series->append(set4);
             //![3]
             //![4]
                 QChart* chart = new QChart();
                 chart->addSeries(series);
                 chart->setTitle("Simple grouped barchart example");
             //![4]
             //![5]
                 chart->legend()->setVisible(true);
                 chart->legend()->setAlignment(QLegend::AlignmentBottom);
                 chart->axisY()->setNiceNumbersEnabled(true);
             //![5]
             //![6]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![6]
             //![7]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![7]
                 return a.exec();
             }

examples/percentbarchart/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$
             ** 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 <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QPercentBarSeries>
             #include <QBarSet>
             #include <QLegend>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 QBarCategories categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
             //![1]
             //![2]
                 QBarSet *set0 = new QBarSet("Jane");
                 QBarSet *set1 = new QBarSet("John");
                 QBarSet *set2 = new QBarSet("Axel");
                 QBarSet *set3 = new QBarSet("Mary");
                 QBarSet *set4 = new QBarSet("Samantha");
                 *set0 << 1 << 2 << 3 << 4 << 5 << 6;
                 *set1 << 5 << 0 << 0 << 4 << 0 << 7;
                 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
                 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
                 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
             //![2]
             //![3]
                 QPercentBarSeries* series = new QPercentBarSeries();
                 series->setCategories(categories);
-                series->appendBarSet(set0);
+                series->append(set0);
-                series->appendBarSet(set1);
+                series->append(set1);
-                series->appendBarSet(set2);
+                series->append(set2);
-                series->appendBarSet(set3);
+                series->append(set3);
-                series->appendBarSet(set4);
+                series->append(set4);
             //![3]
             //![4]
                 QChart* chart = new QChart();
                 chart->addSeries(series);
                 chart->setTitle("Simple percentbarchart example");
             //![4]
             //![5]
                 chart->legend()->setVisible(true);
                 chart->legend()->setAlignment(QLegend::AlignmentBottom);
             //![5]
             //![6]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![6]
             //![7]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![7]
                 return a.exec();
             }

examples/stackedbarchart/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$
             ** 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 <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QStackedBarSeries>
             #include <QBarSet>
             #include <QLegend>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 QBarCategories categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
             //![1]
             //![2]
                 QBarSet *set0 = new QBarSet("Jane");
                 QBarSet *set1 = new QBarSet("John");
                 QBarSet *set2 = new QBarSet("Axel");
                 QBarSet *set3 = new QBarSet("Mary");
                 QBarSet *set4 = new QBarSet("Samantha");
                 *set0 << 1 << 2 << 3 << 4 << 5 << 6;
                 *set1 << 5 << 0 << 0 << 4 << 0 << 7;
                 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
                 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
                 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
             //![2]
             //![3]
                 QStackedBarSeries* series = new QStackedBarSeries();
                 series->setCategories(categories);
-                series->appendBarSet(set0);
+                series->append(set0);
-                series->appendBarSet(set1);
+                series->append(set1);
-                series->appendBarSet(set2);
+                series->append(set2);
-                series->appendBarSet(set3);
+                series->append(set3);
-                series->appendBarSet(set4);
+                series->append(set4);
             //![3]
             //![4]
                 QChart* chart = new QChart();
                 chart->addSeries(series);
                 chart->setTitle("Simple stackedbarchart example");
             //![4]
             //![5]
                 chart->legend()->setVisible(true);
                 chart->legend()->setAlignment(QLegend::AlignmentBottom);
                 chart->axisY()->setNiceNumbersEnabled(true);
             //![5]
             //![6]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![6]
             //![7]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![7]
                 return a.exec();
             }

examples/stackedbarchartdrilldown/main.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 <QtGui/QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QBarSet>
             #include <QLegend>
             #include "drilldownseries.h"
             #include "drilldownchart.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
             //! [1]
                 QApplication a(argc, argv);
                 QMainWindow window;
             //! [1]
             //! [2]
                 DrilldownChart* drilldownChart =  new DrilldownChart();
                 drilldownChart->setTheme(QChart::ChartThemeBlueIcy);
                 drilldownChart->setAnimationOptions(QChart::SeriesAnimations);
             //! [2]
             //! [3]
                 // Define categories
                 QStringList months;
                 months << "May" << "Jun" << "Jul" << "Aug" << "Sep";
                 QStringList weeks;
                 weeks << "week 1" << "week 2" << "week 3" << "week 4";
                 QStringList plants;
                 plants << "Habanero" << "Lemon Drop" << "Starfish" << "Aji Amarillo";
             //! [3]
             //! [4]
                 // Create drilldown structure
                 DrilldownBarSeries* seasonSeries = new DrilldownBarSeries(months, drilldownChart);
                 seasonSeries->setName("Crop by month - Season");
                 // Each month in season series has drilldown series for weekly data
                 foreach (QString month, months) {
                     // Create drilldown series for every week
                     DrilldownBarSeries* weeklySeries = new DrilldownBarSeries(weeks, drilldownChart);
                     seasonSeries->mapDrilldownSeries(month, weeklySeries);
                     // Drilling down from weekly data brings us back to season data.
                     foreach (QString week, weeks) {
                         weeklySeries->mapDrilldownSeries(week, seasonSeries);
                         weeklySeries->setName(QString("Crop by week - " + month));
                     }
                     // Use right click signal to implement drilldown
                     QObject::connect(weeklySeries, SIGNAL(clicked(QBarSet*,QString)), drilldownChart, SLOT(handleClicked(QBarSet*,QString)));
                 }
                 // Enable drilldown from season series using right click.
                 QObject::connect(seasonSeries, SIGNAL(clicked(QBarSet*,QString)), drilldownChart, SLOT(handleClicked(QBarSet*,QString)));
             //! [4]
             //! [5]
                 // Fill monthly and weekly series with data
                 foreach (QString plant, plants) {
                     QBarSet* monthlyCrop = new QBarSet(plant);
                     foreach (QString month, months) {
                         QBarSet* weeklyCrop = new QBarSet(plant);
                         foreach (QString week, weeks )
                             *weeklyCrop << (qrand() % 20);
                         // Get the drilldown series from season series and add crop to it.
-                        seasonSeries->drilldownSeries(month)->appendBarSet(weeklyCrop);
+                        seasonSeries->drilldownSeries(month)->append(weeklyCrop);
                         *monthlyCrop << weeklyCrop->sum();
                     }
-                    seasonSeries->appendBarSet(monthlyCrop);
+                    seasonSeries->append(monthlyCrop);
                 }
             //! [5]
             //! [6]
                 // Show season series in initial view
                 drilldownChart->changeSeries(seasonSeries);
                 drilldownChart->setTitle(seasonSeries->name());
             //! [6]
             //! [7]
                 drilldownChart->axisX()->setGridLineVisible(false);
                 drilldownChart->axisY()->setNiceNumbersEnabled(true);
                 drilldownChart->legend()->setVisible(true);
                 drilldownChart->legend()->setAlignment(QLegend::AlignmentBottom);
             //! [7]
                 QChartView *chartView = new QChartView(drilldownChart);
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

src/barchart/qbarseries.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$
             ** 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 "qbarseries.h"
             #include "qbarseries_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "domain_p.h"
             #include "legendmarker_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include <QAbstractItemModel>
             #include <QModelIndex>
             #include <QBarModelMapper>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief part of QtCommercial chart API.
                 \mainclass
                 QBarSeries represents a series of data shown as bars. One QBarSeries can contain multiple
                 QBarSet data sets. QBarSeries groups the data from sets to categories, which are defined
                 by QStringList.
                 See the \l {BarChart Example} {bar chart example} to learn how to create a simple bar chart.
                 \image examples_barchart.png
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn void QBarSeries::clicked(QBarSet *barset, QString category)
                 The signal is emitted if the user clicks with a mouse on top of QBarSet \a barset of category \a category
                 contained by the series.
             */
             /*!
                 \fn void QBarSeries::hovered(QBarSet* barset, bool status)
                 The signal is emitted if mouse is hovered on top of series.
                 Parameter \a barset is the pointer of barset, where hover happened.
                 Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
             */
             /*!
                 Constructs empty QBarSeries. Parameter \a categories defines the categories for chart.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(/*QBarCategories categories,*/ QObject *parent) :
                 QAbstractSeries(*new QBarSeriesPrivate(/*categories,*/ this),parent)
             {
             }
             /*!
                 Destructs barseries and owned barsets.
             */
             QBarSeries::~QBarSeries()
             {
                 // NOTE: d_ptr destroyed by QObject
             }
             /*!
                 \internal
             */
             QBarSeries::QBarSeries(QBarSeriesPrivate &d, QObject *parent) :
                 QAbstractSeries(d,parent)
             {
             }
             /*!
                 Returns the type of series. Derived classes override this.
             */
             QAbstractSeries::SeriesType QBarSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeBar;
             }
             void QBarSeries::setCategories(QBarCategories categories)
             {
                 Q_D(QBarSeries);
                 d->setCategories(categories);
                 emit d->categoriesUpdated();
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set.
             */
-            bool QBarSeries::appendBarSet(QBarSet *set)
+            bool QBarSeries::append(QBarSet *set)
             {
                 Q_D(QBarSeries);
                 if ((d->m_barSets.contains(set)) || (set == 0)) {
                     // Fail if set is already in list or set is null.
                     return false;
                 }
                 d->m_barSets.append(set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), d, SLOT(barsetChanged()));
                 emit d->restructuredBars();
                 return true;
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesn't delete \a set.
             */
-            bool QBarSeries::removeBarSet(QBarSet *set)
+            bool QBarSeries::remove(QBarSet *set)
             {
                 Q_D(QBarSeries);
                 if (!d->m_barSets.contains(set)) {
                     // Fail if set is not in list
                     return false;
                 }
                 d->m_barSets.removeOne(set);
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), d, SLOT(barsetChanged()));
                 emit d->restructuredBars();
                 return true;
             }
             /*!
                 Adds a list of barsets to series. Takes ownership of \a sets.
             */
-            bool QBarSeries::appendBarSets(QList<QBarSet* > sets)
+            bool QBarSeries::append(QList<QBarSet* > sets)
             {
                 Q_D(QBarSeries);
                 foreach (QBarSet* set, sets) {
                     if ((set == 0) || (d->m_barSets.contains(set))) {
                         // Fail if any of the sets is null or is already appended.
                         return false;
                     }
                     if (sets.count(set) != 1) {
                         // Also fail if same set is more than once in given list.
                         return false;
                     }
                 }
                 foreach (QBarSet* set, sets) {
                     d->m_barSets.append(set);
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), d, SLOT(barsetChanged()));
                 }
                 emit d->restructuredBars();
                 return true;
             }
             /*!
                 Removes a list of barsets from series. Releases ownership of \a sets. Doesn't delete \a sets.
             */
-            bool QBarSeries::removeBarSets(QList<QBarSet* > sets)
+            bool QBarSeries::remove(QList<QBarSet* > sets)
             {
                 Q_D(QBarSeries);
                 bool setsRemoved = false;
                 foreach (QBarSet* set, sets) {
                     if (d->m_barSets.contains(set)) {
                         d->m_barSets.removeOne(set);
                         QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), d, SLOT(barsetChanged()));
                         setsRemoved = true;
                     }
                 }
                 if (setsRemoved) {
                     emit d->restructuredBars();
                 }
                 return setsRemoved;
             }
             /*!
                 Returns number of sets in series.
             */
             int QBarSeries::barsetCount() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets.count();
             }
             /*!
                 Returns number of categories in series
             */
             int QBarSeries::categoryCount() const
             {
                 Q_D(const QBarSeries);
                 return d->m_categories.count();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets() const
             {
                 Q_D(const QBarSeries);
                 return d->m_barSets;
             }
             /*!
                  \fn bool QBarSeries::setModel(QAbstractItemModel *model)
                  Sets the \a model to be used as a data source
              */
             void QBarSeries::setModel(QAbstractItemModel *model)
             {
                 Q_D(QBarSeries);
                 // disconnect signals from old model
                 if(d->m_model)
                 {
                     disconnect(d->m_model, 0, this, 0);
                 }
                 // set new model
                 if(model)
                 {
                     d->m_model = model;
                     // connect the signals
                     connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                     connect(d->m_model, SIGNAL(rowsInserted(QModelIndex,int,int)), d, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)), d, SLOT(modelDataRemoved(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), d, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), d, SLOT(modelDataRemoved(QModelIndex,int,int)));
                     if (d->m_mapper)
                         d->initializeDataFromModel();
                 }
                 else
                 {
                     d->m_model = 0;
                 }
             }
             void QBarSeries::setModelMapper(QBarModelMapper *mapper)
             {
                 Q_D(QBarSeries);
                 // disconnect signals from old mapper
                 if (d->m_mapper) {
                     QObject::disconnect(d->m_mapper, 0, this, 0);
                 }
                 if (mapper) {
                     d->m_mapper = mapper;
                     // connect the signal from the mapper
                     connect(d->m_mapper, SIGNAL(updated()), d, SLOT(initializeDataFromModel()));
                     if (d->m_model)
                         d->initializeDataFromModel();
                 } else {
                     d->m_mapper = 0;
                 }
             }
             QBarModelMapper* QBarSeries::modelMapper() const
             {
                 Q_D(const QBarSeries);
                 return d->m_mapper;
             }
             /*!
                 Returns the bar categories of the series.
             */
             QBarCategories QBarSeries::categories() const
             {
                 Q_D(const QBarSeries);
                 return d->m_categories;
             }
             /*!
                 Sets the visibility of labels in series to \a visible
             */
             void QBarSeries::setLabelsVisible(bool visible)
             {
                 foreach (QBarSet* s, barSets()) {
                     s->setLabelsVisible(visible);
                 }
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSeriesPrivate::QBarSeriesPrivate(QBarSeries *q) :
                 QAbstractSeriesPrivate(q),
                 m_barMargin(0.05),  // Default value is 5% of category width
                 m_mapper(0)
                 //    m_categories(categories),
             {
             }
             void QBarSeriesPrivate::setCategories(QBarCategories categories)
             {
                 m_categories = categories;
             }
             void QBarSeriesPrivate::setBarMargin(qreal margin)
             {
                 if (margin > 1.0) {
                     margin = 1.0;
                 } else if (margin < 0.0) {
                     margin = 0.0;
                 }
                 m_barMargin = margin;
                 emit updatedBars();
             }
             qreal QBarSeriesPrivate::barMargin()
             {
                 return m_barMargin;
             }
             QBarSet* QBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
             QString QBarSeriesPrivate::categoryName(int category)
             {
                 return m_categories.at(category);
             }
             qreal QBarSeriesPrivate::min()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j).y();
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal QBarSeriesPrivate::max()
             {
                 if (m_barSets.count() <= 0) {
                     return 0;
                 }
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                     int categoryCount = m_barSets.at(i)->count();
                     for (int j = 0; j < categoryCount; j++) {
                         qreal temp = m_barSets.at(i)->at(j).y();
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal QBarSeriesPrivate::valueAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 return m_barSets.at(set)->at(category).y();
             }
             qreal QBarSeriesPrivate::percentageAt(int set, int category)
             {
                 if ((set < 0) || (set >= m_barSets.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 qreal value = m_barSets.at(set)->at(category).y();
                 qreal sum = categorySum(category);
                 if ( qFuzzyIsNull(sum) ) {
                     return 0;
                 }
                 return value / sum;
             }
             qreal QBarSeriesPrivate::categorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += m_barSets.at(set)->at(category).y();
                 }
                 return sum;
             }
             qreal QBarSeriesPrivate::absoluteCategorySum(int category)
             {
                 qreal sum(0);
                 int count = m_barSets.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_barSets.at(set)->count())
                         sum += qAbs(m_barSets.at(set)->at(category).y());
                 }
                 return sum;
             }
             qreal QBarSeriesPrivate::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = m_categories.count();
                 for (int i = 0; i < count; i++) {
                     qreal sum = categorySum(i);
                     if (sum > max)
                         max = sum;
                 }
                 return max;
             }
             void QBarSeriesPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 if (m_model == 0 || m_mapper == 0)
                     return;
                 for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
                     for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
                         if (m_mapper->orientation() == Qt::Vertical)
                         {
                             // model update is relevant to BarSeries if the change was made to the part of the model that was mapped to BarSeries
                             if ( row >= m_mapper->first() && (m_mapper->count() == - 1 || row < m_mapper->first() + m_mapper->count())) {
                                 if (column >= m_mapper->mapBarBottom() && column <= m_mapper->mapBarTop())
                                     barsetAt(column - m_mapper->mapBarBottom())->replace(row - m_mapper->first(), m_model->data(topLeft, Qt::DisplayRole).toDouble());
                                 //                    if (column == m_mapper->mapCategories());// TODO:
                             }
                         }
                         else
                         {
                             // model update is relevant to BarSeries if the change was made to the part of the model that was mapped to BarSeries
                             if (column >= m_mapper->first() && (m_mapper->count() == - 1 || column < m_mapper->first() + m_mapper->count())) {
                                 if (row >= m_mapper->mapBarBottom() && row <= m_mapper->mapBarTop())
                                     barsetAt(row - m_mapper->mapBarBottom())->replace(column - m_mapper->first(), m_model->data(topLeft, Qt::DisplayRole).toDouble());
                                 //                    if (row == m_mapper->mapCategories());// TODO:
                             }
                         }
                     }
                 }
             }
             void QBarSeriesPrivate::modelDataAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(start);
                 Q_UNUSED(end);
                 initializeDataFromModel();
             }
             void QBarSeriesPrivate::modelDataRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(start);
                 Q_UNUSED(end);
                 initializeDataFromModel();
             }
             void QBarSeriesPrivate::initializeDataFromModel()
             {
                 Q_Q(QBarSeries);
                 // create the initial bars
                 m_categories.clear();
                 m_barSets.clear();
                 if (m_model == 0 || m_mapper == 0)
                     return;
                 // check if mappings are set
                 if (m_mapper->mapBarBottom() == -1 || m_mapper->mapBarTop() == -1 || m_mapper->mapCategories() == -1)
                     return;
                 //    emit restructuredBars();
                 if (m_mapper->orientation() == Qt::Vertical) {
                     if (m_mapCategories >= m_model->columnCount())
                         return;
                     int rowCount = 0;
                     if(m_mapper->count() == -1)
                         rowCount = m_model->rowCount() - m_mapper->first();
                     else
                         rowCount = qMin(m_mapper->count(), m_model->rowCount() - m_mapper->first());
                     for (int k = m_mapper->first(); k < m_mapper->first() + rowCount; k++) {
                         m_categories << m_model->data(m_model->index(k, m_mapper->mapCategories()), Qt::DisplayRole).toString();
                     }
                     int lastAvailableBarSet = qMin(m_model->columnCount() - 1, m_mapper->mapBarTop());
                     for (int i = m_mapper->mapBarBottom(); i <= lastAvailableBarSet; i++) {
             //        for (int i = m_mapper->mapBarBottom(); i <= m_mapper->mapBarTop(); i++) {
                         QBarSet* barSet = new QBarSet(m_model->headerData(i, Qt::Horizontal, Qt::DisplayRole).toString());
                         for(int m = m_mapper->first(); m < m_mapper->first() + rowCount; m++)
                             *barSet << m_model->data(m_model->index(m, i), Qt::DisplayRole).toDouble();
-                        q->appendBarSet(barSet);
+                        q->append(barSet);
                     }
                 } else {
                     if (m_mapCategories >= m_model->rowCount())
                         return;
                     int columnCount = 0;
                     if(m_mapper->count() == -1)
                         columnCount = m_model->columnCount() - m_mapper->first();
                     else
                         columnCount = qMin(m_mapper->count(), m_model->columnCount() - m_mapper->first());
                     for (int k = m_mapper->first(); k < m_mapper->first() + columnCount; k++) {
                         m_categories << m_model->data(m_model->index(m_mapper->mapCategories(), k), Qt::DisplayRole).toString();
                     }
                     int lastAvailableBarSet = qMin(m_model->rowCount() - 1, m_mapper->mapBarTop());
                     for (int i = m_mapper->mapBarBottom(); i <= lastAvailableBarSet; i++) {
             //        for (int i = m_mapper->mapBarBottom(); i <= m_mapper->mapBarTop(); i++) {
                         QBarSet* barSet = new QBarSet(m_model->headerData(i, Qt::Vertical, Qt::DisplayRole).toString());
                         for(int m = m_mapper->first(); m < m_mapper->first() + columnCount; m++)
                             *barSet << m_model->data(m_model->index(i, m), Qt::DisplayRole).toDouble();
-                        q->appendBarSet(barSet);
+                        q->append(barSet);
                     }
                 }
                 emit restructuredBars();
                 //    emit updatedBars();
             }
             void QBarSeriesPrivate::insertCategory(int index, const QString category)
             {
                 m_categories.insert(index, category);
                 emit categoriesUpdated();
             }
             void QBarSeriesPrivate::removeCategory(int index)
             {
                 m_categories.removeAt(index);
                 emit categoriesUpdated();
             }
             void QBarSeriesPrivate::barsetChanged()
             {
                 emit updatedBars();
             }
             void QBarSeriesPrivate::scaleDomain(Domain& domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
                 int tickXCount(domain.tickXCount());
                 int tickYCount(domain.tickYCount());
                 qreal x = m_categories.count();
                 qreal y = max();
                 minX = qMin(minX, x);
                 minY = qMin(minY, y);
                 maxX = qMax(maxX, x);
                 maxY = qMax(maxY, y);
                 tickXCount = x+1;
                 domain.setRange(minX,maxX,minY,maxY,tickXCount,tickYCount);
             }
             Chart* QBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QBarSeries);
                 BarChartItem* bar = new BarChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(bar);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }
             QList<LegendMarker*> QBarSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QBarSeries);
                 QList<LegendMarker*> markers;
                 foreach(QBarSet* set, q->barSets()) {
                     BarLegendMarker* marker = new BarLegendMarker(q,set,legend);
                     markers << marker;
                 }
                 return markers;
             }
             #include "moc_qbarseries.cpp"
             #include "moc_qbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.h +4 -4

             /****************************************************************************
             **
             ** 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 BARSERIES_H
             #define BARSERIES_H
             #include <qabstractseries.h>
             #include <QStringList>
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             typedef QStringList QBarCategories;
             class QBarSet;
             class BarCategory;
             class QBarSeriesPrivate;
             class QBarModelMapper;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT QBarSeries : public QAbstractSeries
             {
                 Q_OBJECT
             public:
                 explicit QBarSeries(QObject *parent = 0);
                 virtual ~QBarSeries();
                 QAbstractSeries::SeriesType type() const;
                 void setCategories(QBarCategories categories);
-                bool appendBarSet(QBarSet *set);            // Takes ownership of set
+                bool append(QBarSet *set);            // Takes ownership of set
-                bool removeBarSet(QBarSet *set);            // Releases ownership, doesn't delete set
+                bool remove(QBarSet *set);            // Releases ownership, doesn't delete set
-                bool appendBarSets(QList<QBarSet* > sets);
+                bool append(QList<QBarSet* > sets);
-                bool removeBarSets(QList<QBarSet* > sets);
+                bool remove(QList<QBarSet* > sets);
                 int barsetCount() const;
                 int categoryCount() const;
                 QList<QBarSet*> barSets() const;
                 QBarCategories categories() const;
                 void setLabelsVisible(bool visible = true);
                 void setModel(QAbstractItemModel *model);
                 void setModelMapper(QBarModelMapper *mapper);
                 QBarModelMapper* modelMapper() const;
             protected:
                 explicit QBarSeries(QBarSeriesPrivate &d,QObject *parent = 0);
             Q_SIGNALS:
                 void clicked(QBarSet *barset, QString category);
                 void hovered(QBarSet* barset, bool status);
             protected:
                 Q_DECLARE_PRIVATE(QBarSeries)
                 friend class BarChartItem;
                 friend class PercentBarChartItem;
                 friend class StackedBarChartItem;
                 friend class GroupedBarChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

test/auto/qbarseries/tst_qbarseries.cpp +42 -42

             /****************************************************************************
             **
             ** 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 <QtTest/QtTest>
             #include <qbarseries.h>
             #include <qbarset.h>
             #include <qchartview.h>
             #include <qchart.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QBarSet*)
             class tst_QBarSeries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qbarseries_data();
                 void qbarseries();
                 void type_data();
                 void type();
                 void setCategories_data();
                 void setCategories();
-                void appendBarSet_data();
+                void append_data();
-                void appendBarSet();
+                void append();
-                void removeBarSet_data();
+                void remove_data();
-                void removeBarSet();
+                void remove();
-                void appendBarSets_data();
+                void appendList_data();
-                void appendBarSets();
+                void appendList();
-                void removeBarSets_data();
+                void removeList_data();
-                void removeBarSets();
+                void removeList();
                 void barsetCount_data();
                 void barsetCount();
                 void categoryCount_data();
                 void categoryCount();
                 void barSets_data();
                 void barSets();
                 void categories_data();
                 void categories();
                 void setLabelsVisible_data();
                 void setLabelsVisible();
                 void mouseclicked_data();
                 void mouseclicked();
                 void mousehovered_data();
                 void mousehovered();
             private:
                 QBarSeries* m_barseries;
                 QBarSeries* m_barseries_with_sets;
                 QList<QBarSet*> m_testSets;
                 QBarCategories m_categories;
             };
             void tst_QBarSeries::initTestCase()
             {
                 qRegisterMetaType<QBarSet*>("QBarSet*");
             }
             void tst_QBarSeries::cleanupTestCase()
             {
             }
             void tst_QBarSeries::init()
             {
                 m_categories << "category0" << "category1" << "category2";
                 m_barseries = new QBarSeries();
                 m_barseries->setCategories(m_categories);
                 m_barseries_with_sets = new QBarSeries();
                 m_barseries_with_sets->setCategories(m_categories);
                 for (int i=0; i<5; i++) {
                     m_testSets.append(new QBarSet("testset"));
-                    m_barseries_with_sets->appendBarSet(m_testSets.at(i));
+                    m_barseries_with_sets->append(m_testSets.at(i));
                 }
             }
             void tst_QBarSeries::cleanup()
             {
                 foreach(QBarSet* s, m_testSets) {
-                    m_barseries_with_sets->removeBarSet(s);
+                    m_barseries_with_sets->remove(s);
                     delete s;
                 }
                 m_testSets.clear();
                 delete m_barseries;
                 m_barseries = 0;
                 delete m_barseries_with_sets;
                 m_barseries_with_sets = 0;
                 m_categories.clear();
             }
             void tst_QBarSeries::qbarseries_data()
             {
                 QTest::addColumn<QBarCategories> ("categories");
                 QBarCategories c;
                 c << "category0" << "category1" << "category2";
                 QTest::newRow("categories") << c;
             }
             void tst_QBarSeries::qbarseries()
             {
                 QFETCH(QBarCategories, categories);
                 QBarSeries *barseries = new QBarSeries();
                 QVERIFY(barseries != 0);
                 barseries->setCategories(categories);
                 QBarCategories verifyCategories = barseries->categories();
                 QVERIFY(verifyCategories.count() == categories.count());
                 for (int i=0; i<categories.count(); i++) {
                     QVERIFY(verifyCategories.at(i).compare(categories.at(i)) == 0);
                 }
             }
             void tst_QBarSeries::type_data()
             {
             }
             void tst_QBarSeries::type()
             {
                 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeBar);
             }
             void tst_QBarSeries::setCategories_data()
             {
                 QTest::addColumn<QBarCategories> ("categories");
                 QBarCategories categories;
                 categories << "c1" << "c2" << "c3" << "c4" << "c5" << "c6";
                 QTest::newRow("cat") << categories;
             }
             void tst_QBarSeries::setCategories()
             {
                 QVERIFY(m_barseries->categories().count() == m_categories.count());
                 QFETCH(QBarCategories, categories);
                 m_barseries->setCategories(categories);
                 QVERIFY(m_barseries->categories().count() == categories.count());
                 for (int i=0; i<categories.count(); i++) {
                     QVERIFY(m_barseries->categories().at(i).compare(categories.at(i)) == 0);
                 }
             }
-            void tst_QBarSeries::appendBarSet_data()
+            void tst_QBarSeries::append_data()
             {
             }
-            void tst_QBarSeries::appendBarSet()
+            void tst_QBarSeries::append()
             {
                 QVERIFY(m_barseries->barsetCount() == 0);
                 bool ret = false;
                 // Try adding barset
                 QBarSet *barset = new QBarSet("testset");
-                ret = m_barseries->appendBarSet(barset);
+                ret = m_barseries->append(barset);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->barsetCount() == 1);
                 // Try adding another set
                 QBarSet *barset2 = new QBarSet("testset2");
-                ret = m_barseries->appendBarSet(barset2);
+                ret = m_barseries->append(barset2);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->barsetCount() == 2);
                 // Try adding same set again
-                ret = m_barseries->appendBarSet(barset2);
+                ret = m_barseries->append(barset2);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->barsetCount() == 2);
                 // Try adding null set
-                ret = m_barseries->appendBarSet(0);
+                ret = m_barseries->append(0);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->barsetCount() == 2);
             }
-            void tst_QBarSeries::removeBarSet_data()
+            void tst_QBarSeries::remove_data()
             {
             }
-            void tst_QBarSeries::removeBarSet()
+            void tst_QBarSeries::remove()
             {
                 int count = m_testSets.count();
                 QVERIFY(m_barseries_with_sets->barsetCount() == count);
                 // Try to remove null pointer (should not remove, should not crash)
                 bool ret = false;
-                ret = m_barseries_with_sets->removeBarSet(0);
+                ret = m_barseries_with_sets->remove(0);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->barsetCount() == count);
                 // Try to remove invalid pointer (should not remove, should not crash)
-                ret = m_barseries_with_sets->removeBarSet((QBarSet*) (m_testSets.at(0) + 1) );
+                ret = m_barseries_with_sets->remove((QBarSet*) (m_testSets.at(0) + 1) );
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->barsetCount() == count);
                 // remove some sets
-                ret = m_barseries_with_sets->removeBarSet(m_testSets.at(2));
+                ret = m_barseries_with_sets->remove(m_testSets.at(2));
                 QVERIFY(ret == true);
-                ret = m_barseries_with_sets->removeBarSet(m_testSets.at(3));
+                ret = m_barseries_with_sets->remove(m_testSets.at(3));
                 QVERIFY(ret == true);
-                ret = m_barseries_with_sets->removeBarSet(m_testSets.at(4));
+                ret = m_barseries_with_sets->remove(m_testSets.at(4));
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries_with_sets->barsetCount() == 2);
                 QList<QBarSet*> verifysets = m_barseries_with_sets->barSets();
                 QVERIFY(verifysets.at(0) == m_testSets.at(0));
                 QVERIFY(verifysets.at(1) == m_testSets.at(1));
                 // Try removing all sets again (should be ok, even if some sets have already been removed)
                 ret = false;
                 for (int i=0; i<count; i++) {
-                    ret |= m_barseries_with_sets->removeBarSet(m_testSets.at(i));
+                    ret |= m_barseries_with_sets->remove(m_testSets.at(i));
                 }
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries_with_sets->barsetCount() == 0);
             }
-            void tst_QBarSeries::appendBarSets_data()
+            void tst_QBarSeries::appendList_data()
             {
             }
-            void tst_QBarSeries::appendBarSets()
+            void tst_QBarSeries::appendList()
             {
                 int count = 5;
                 QVERIFY(m_barseries->barsetCount() == 0);
                 QList<QBarSet*> sets;
                 for (int i=0; i<count; i++) {
                     sets.append(new QBarSet("testset"));
                 }
                 // Append new sets (should succeed, count should match the count of sets)
                 bool ret = false;
-                ret = m_barseries->appendBarSets(sets);
+                ret = m_barseries->append(sets);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->barsetCount() == count);
                 // Append same sets again (should fail, count should remain same)
-                ret = m_barseries->appendBarSets(sets);
+                ret = m_barseries->append(sets);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->barsetCount() == count);
                 // Try append empty list (should succeed, but count should remain same)
                 QList<QBarSet*> invalidList;
-                ret = m_barseries->appendBarSets(invalidList);
+                ret = m_barseries->append(invalidList);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries->barsetCount() == count);
                 // Try append list with one new and one existing set (should fail, count remains same)
                 invalidList.append(new QBarSet("ok set"));
                 invalidList.append(sets.at(0));
-                ret = m_barseries->appendBarSets(invalidList);
+                ret = m_barseries->append(invalidList);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->barsetCount() == count);
                 // Try append list with null pointers (should fail, count remains same)
                 QList<QBarSet*> invalidList2;
                 invalidList2.append(0);
                 invalidList2.append(0);
                 invalidList2.append(0);
-                ret = m_barseries->appendBarSets(invalidList2);
+                ret = m_barseries->append(invalidList2);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries->barsetCount() == count);
             }
-            void tst_QBarSeries::removeBarSets_data()
+            void tst_QBarSeries::removeList_data()
             {
             }
-            void tst_QBarSeries::removeBarSets()
+            void tst_QBarSeries::removeList()
             {
                 int count = m_testSets.count();
                 QVERIFY(m_barseries_with_sets->barsetCount() == count);
                 // Try removing empty list of sets (should return false, since no barsets were removed)
                 bool ret = false;
                 QList<QBarSet*> invalidList;
-                ret = m_barseries_with_sets->removeBarSets(invalidList);
+                ret = m_barseries_with_sets->remove(invalidList);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->barsetCount() == count);
                 // Add some null pointers to list
                 invalidList.append(0);
                 invalidList.append(0);
                 invalidList.append(0);
                 // Try removing null pointers from list (should return false, should not crash, should not remove anything)
-                ret = m_barseries_with_sets->removeBarSets(invalidList);
+                ret = m_barseries_with_sets->remove(invalidList);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->barsetCount() == count);
                 // remove all sets (should return true, since sets were removed)
-                ret = m_barseries_with_sets->removeBarSets(m_testSets);
+                ret = m_barseries_with_sets->remove(m_testSets);
                 QVERIFY(ret == true);
                 QVERIFY(m_barseries_with_sets->barsetCount() == 0);
                 // Try removing invalid list again (should return false, since no barsets were removed)
-                ret = m_barseries_with_sets->removeBarSets(invalidList);
+                ret = m_barseries_with_sets->remove(invalidList);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->barsetCount() == 0);
                 // remove all sets again (should return false, since barsets were already removed)
-                ret = m_barseries_with_sets->removeBarSets(m_testSets);
+                ret = m_barseries_with_sets->remove(m_testSets);
                 QVERIFY(ret == false);
                 QVERIFY(m_barseries_with_sets->barsetCount() == 0);
             }
             void tst_QBarSeries::barsetCount_data()
             {
             }
             void tst_QBarSeries::barsetCount()
             {
                 QVERIFY(m_barseries->barsetCount() == 0);
                 QVERIFY(m_barseries_with_sets->barsetCount() == m_testSets.count());
             }
             void tst_QBarSeries::categoryCount_data()
             {
             }
             void tst_QBarSeries::categoryCount()
             {
                 QVERIFY(m_barseries->categoryCount() == m_categories.count());
                 QVERIFY(m_barseries_with_sets->categoryCount() == m_categories.count());
             }
             void tst_QBarSeries::barSets_data()
             {
             }
             void tst_QBarSeries::barSets()
             {
                 QVERIFY(m_barseries->barSets().count() == 0);
                 QList<QBarSet*> sets = m_barseries_with_sets->barSets();
                 QVERIFY(sets.count() == m_testSets.count());
                 for (int i=0; i<m_testSets.count(); i++) {
                     QVERIFY(sets.at(i) == m_testSets.at(i));
                 }
             }
             void tst_QBarSeries::categories_data()
             {
             }
             void tst_QBarSeries::categories()
             {
                 QBarCategories categories = m_barseries->categories();
                 QVERIFY(categories.count() == m_categories.count());
                 for (int i=0; i<m_categories.count(); i++) {
                     QVERIFY(categories.at(i).compare(m_categories.at(i)) == 0);
                 }
             }
             void tst_QBarSeries::setLabelsVisible_data()
             {
             }
             void tst_QBarSeries::setLabelsVisible()
             {
                 // labels should be invisible by default
                 foreach (QBarSet* s, m_testSets) {
                     QVERIFY(s->labelsVisible() == false);
                 }
                 // turn labels to visible
                 m_barseries_with_sets->setLabelsVisible(true);
                 foreach (QBarSet* s, m_testSets) {
                     QVERIFY(s->labelsVisible() == true);
                 }
                 // turn labels to invisible
                 m_barseries_with_sets->setLabelsVisible(false);
                 foreach (QBarSet* s, m_testSets) {
                     QVERIFY(s->labelsVisible() == false);
                 }
                 // without parameter, should turn labels to visible
                 m_barseries_with_sets->setLabelsVisible();
                 foreach (QBarSet* s, m_testSets) {
                     QVERIFY(s->labelsVisible() == true);
                 }
             }
             void tst_QBarSeries::mouseclicked_data()
             {
             }
             void tst_QBarSeries::mouseclicked()
             {
                 QBarSeries* series = new QBarSeries();
                 QBarCategories categories;
                 categories << "test1" << "test2" << "test3";
                 series->setCategories(categories);
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << QPointF(0,10) << QPointF(1,10) << QPointF(2,10);
-                series->appendBarSet(set1);
+                series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << QPointF(0.5,10) << QPointF(1.5,10) << QPointF(2.5,10);
-                series->appendBarSet(set2);
+                series->append(set2);
                 QSignalSpy setSpy1(set1, SIGNAL(clicked(QString)));
                 QSignalSpy setSpy2(set2, SIGNAL(clicked(QString)));
                 QSignalSpy seriesSpy(series,SIGNAL(clicked(QBarSet*,QString)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
             //====================================================================================
             // barset 1, category test1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(75,180));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test1")) == 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //====================================================================================
             // barset 1, category test2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(160,180));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test2")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //====================================================================================
             // barset 1, category test3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(255,180));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test3")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //====================================================================================
             // barset 2, category test1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(115,180));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test1")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
             //====================================================================================
             // barset 2, category test2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(205,180));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test2")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
             //====================================================================================
             // barset 2, category test3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(300,180));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test3")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
             //====================================================================================
             // no event cases
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(1,1));     // Outside of both sets
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(1,1));    // Right mouse button outside and inside sets
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(75,180)); // barset 1, category test1
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(160,180)); // barset 1, category test2
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(255,180)); // barset 1, category test3
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(115,180)); // barset 2, category test1
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(205,180)); // barset 2, category test2
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(300,180)); // barset 2, category test3
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 0);
             }
             void tst_QBarSeries::mousehovered_data()
             {
             }
             void tst_QBarSeries::mousehovered()
             {
                 QBarSeries* series = new QBarSeries();
                 QBarCategories categories;
                 categories << "test1" << "test2" << "test3";
                 series->setCategories(categories);
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << QPointF(0.1,10) << QPointF(1.1,10) << QPointF(2.1,10);
-                series->appendBarSet(set1);
+                series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << QPointF(0.4,10) << QPointF(1.4,10) << QPointF(2.4,10);
-                series->appendBarSet(set2);
+                series->append(set2);
                 QSignalSpy setSpy1(set1, SIGNAL(hovered(bool)));
                 QSignalSpy setSpy2(set2, SIGNAL(hovered(bool)));
                 QSignalSpy seriesSpy(series,SIGNAL(hovered(QBarSet*,bool)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
             //=======================================================================
             // move mouse to left border
                 QTest::mouseMove(view.viewport(), QPoint(0, 180));
                 QVERIFY(setSpy1.count() == 0);
                 QVERIFY(setSpy2.count() == 0);
                 QVERIFY(seriesSpy.count() == 0);
             //=======================================================================
             // move mouse on top of set1
                 QTest::mouseMove(view.viewport(), QPoint(75,180));
                 QVERIFY(setSpy1.count() == 1);
                 QVERIFY(setSpy2.count() == 0);
                 QVERIFY(seriesSpy.count() == 1);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == true);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //=======================================================================
             // move mouse from top of set1 to top of set2
                 QTest::mouseMove(view.viewport(), QPoint(105,180));
                 QVERIFY(setSpy1.count() == 1);
                 QVERIFY(setSpy2.count() == 1);
                 QVERIFY(seriesSpy.count() == 2);
                 // should leave set1
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == false);
                 // should enter set2
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == true);
                 // should leave set1
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
                 QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(1).toBool() == false);
                 // should enter set2
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
                 QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(1).toBool() == true);
             //=======================================================================
             // move mouse from top of set2 to background
                 QTest::mouseMove(view.viewport(), QPoint(135,180));
                 QVERIFY(setSpy1.count() == 0);
                 QVERIFY(setSpy2.count() == 1);
                 QVERIFY(seriesSpy.count() == 1);
                 // should leave set2 (event via set)
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == false);
                 // should leave set2 (event via series)
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
                 QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(1).toBool() == false);
             }
             /*
             bool setModel(QAbstractItemModel *model);
             void setModelMapping(int categories, int bottomBoundary, int topBoundary, Qt::Orientation orientation = Qt::Vertical);
             void setModelMappingRange(int first, int count = -1);
             */
             QTEST_MAIN(tst_QBarSeries)
             #include "tst_qbarseries.moc"

test/auto/qgroupedbarseries/tst_qgroupedbarseries.cpp +4 -4

             /****************************************************************************
             **
             ** 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 <QtTest/QtTest>
             #include <qgroupedbarseries.h>
             #include <qbarset.h>
             #include <qchartview.h>
             #include <qchart.h>
             #include <QBarModelMapper>
             #include <QStandardItemModel>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QBarSet*)
             class tst_QGroupedBarSeries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qgroupedbarseries_data();
                 void qgroupedbarseries();
                 void type_data();
                 void type();
                 void mouseclicked_data();
                 void mouseclicked();
                 void mousehovered_data();
                 void mousehovered();
                 void model();
             private:
                 QGroupedBarSeries* m_barseries;
             };
             void tst_QGroupedBarSeries::initTestCase()
             {
                 qRegisterMetaType<QBarSet*>("QBarSet*");
             }
             void tst_QGroupedBarSeries::cleanupTestCase()
             {
             }
             void tst_QGroupedBarSeries::init()
             {
                 m_barseries = new QGroupedBarSeries();
             }
             void tst_QGroupedBarSeries::cleanup()
             {
                 delete m_barseries;
                 m_barseries = 0;
             }
             void tst_QGroupedBarSeries::qgroupedbarseries_data()
             {
             }
             void tst_QGroupedBarSeries::qgroupedbarseries()
             {
                 QGroupedBarSeries *barseries = new QGroupedBarSeries();
                 QVERIFY(barseries != 0);
             }
             void tst_QGroupedBarSeries::type_data()
             {
             }
             void tst_QGroupedBarSeries::type()
             {
                 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeGroupedBar);
             }
             void tst_QGroupedBarSeries::mouseclicked_data()
             {
             }
             void tst_QGroupedBarSeries::mouseclicked()
             {
                 QGroupedBarSeries* series = new QGroupedBarSeries();
                 QBarCategories categories;
                 categories << "test1" << "test2" << "test3";
                 series->setCategories(categories);
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
-                series->appendBarSet(set1);
+                series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
-                series->appendBarSet(set2);
+                series->append(set2);
                 QSignalSpy setSpy1(set1, SIGNAL(clicked(QString)));
                 QSignalSpy setSpy2(set2, SIGNAL(clicked(QString)));
                 QSignalSpy seriesSpy(series,SIGNAL(clicked(QBarSet*,QString)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
             //====================================================================================
             // barset 1, category test1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(100,180));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test1")) == 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //====================================================================================
             // barset 1, category test2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(190,180));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test2")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //====================================================================================
             // barset 1, category test3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(280,180));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test3")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //====================================================================================
             // barset 2, category test1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(130,180));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test1")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
             //====================================================================================
             // barset 2, category test2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(220,180));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test2")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
             //====================================================================================
             // barset 2, category test3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(310,180));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test3")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
             //====================================================================================
             // no event cases
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(1,1));     // Outside of both sets
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(1,1));    // Right mouse button outside and inside sets
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(100,180)); // barset 1, category test1
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(190,180)); // barset 1, category test2
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(280,180)); // barset 1, category test3
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(130,180)); // barset 2, category test1
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(220,180)); // barset 2, category test2
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(310,180)); // barset 2, category test3
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 0);
             }
             void tst_QGroupedBarSeries::mousehovered_data()
             {
             }
             void tst_QGroupedBarSeries::mousehovered()
             {
                 QGroupedBarSeries* series = new QGroupedBarSeries();
                 QBarCategories categories;
                 categories << "test1" << "test2" << "test3";
                 series->setCategories(categories);
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
-                series->appendBarSet(set1);
+                series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
-                series->appendBarSet(set2);
+                series->append(set2);
                 QSignalSpy setSpy1(set1, SIGNAL(hovered(bool)));
                 QSignalSpy setSpy2(set2, SIGNAL(hovered(bool)));
                 QSignalSpy seriesSpy(series,SIGNAL(hovered(QBarSet*,bool)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 //this is hack since view does not get events otherwise
                 view.setMouseTracking(true);
             //=======================================================================
             // move mouse to left border
                 QTest::mouseMove(view.viewport(), QPoint(0, 180));
                 QVERIFY(setSpy1.count() == 0);
                 QVERIFY(setSpy2.count() == 0);
                 QVERIFY(seriesSpy.count() == 0);
             //=======================================================================
             // move mouse on top of set1
                 QTest::mouseMove(view.viewport(), QPoint(100,180));
                 QVERIFY(setSpy1.count() == 1);
                 QVERIFY(setSpy2.count() == 0);
                 QVERIFY(seriesSpy.count() == 1);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == true);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //=======================================================================
             // move mouse from top of set1 to top of set2
                 QTest::mouseMove(view.viewport(), QPoint(130,180));
                 QVERIFY(setSpy1.count() == 1);
                 QVERIFY(setSpy2.count() == 1);
                 QVERIFY(seriesSpy.count() == 2);
                 // should leave set1
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == false);
                 // should enter set2
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == true);
                 // should leave set1
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
                 QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(1).toBool() == false);
                 // should enter set2
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
                 QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(1).toBool() == true);
             //=======================================================================
             // move mouse from top of set2 to background
                 QTest::mouseMove(view.viewport(), QPoint(160,180));
                 QVERIFY(setSpy1.count() == 0);
                 QVERIFY(setSpy2.count() == 1);
                 QVERIFY(seriesSpy.count() == 1);
                 // should leave set2 (event via set)
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == false);
                 // should leave set2 (event via series)
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
                 QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(1).toBool() == false);
             }
             void tst_QGroupedBarSeries::model()
             {
                 QGroupedBarSeries *series = new QGroupedBarSeries;
                 QChart *chart = new QChart;
                 chart->addSeries(series);
                 QChartView *chartView = new QChartView(chart);
                 chartView->show();
                 int rowCount = 12;
                 int columnCount = 5;
                 QStandardItemModel *stdModel = new QStandardItemModel(rowCount, columnCount);
                 series->setModel(stdModel);
                 QVERIFY2((series->model()) == stdModel, "Model should be stdModel");
                 for (int row = 0; row < rowCount; ++row) {
                     for (int column = 0; column < columnCount; column++) {
                         QStandardItem *item = new QStandardItem(row * column);
                         stdModel->setItem(row, column, item);
                     }
                 }
                 // data has been added to the model, but mapper is not set the number of slices should still be 0
                 QVERIFY2(series->barsetCount() == 0, "Mapper has not been set, so the number of slices should be 0");
                 // set the mapper
                 QBarModelMapper *mapper = new QBarModelMapper;
                 mapper->setMapCategories(0);
                 mapper->setMapBarBottom(1);
                 mapper->setMapBarTop(3);
                 series->setModelMapper(mapper); // this should cause the Pie to get initialized from the model, since there is now both the model and the mapper defined
                 QCOMPARE(series->barsetCount(), 3);
                 // set the mappings to be outside of the model
                 mapper->setMapBarBottom(6);
                 mapper->setMapBarTop(7);
                 QCOMPARE(series->barsetCount(), 0); // Mappings are invalid, so the number of slices should be 0
                 // set back to correct ones
                 mapper->setMapBarBottom(1);
                 mapper->setMapBarTop(3);
                 QCOMPARE(series->barsetCount(), 3);
                 // reset the mappings
                 mapper->reset();
                 QCOMPARE(series->barsetCount(), 0); // Mappings have been reset and are invalid, so the number of slices should be 0
                 // unset the model and the mapper
                 series->setModel(0);
                 series->setModelMapper(0);
                 QVERIFY(series->model() == 0); // Model should be unset
                 QVERIFY(series->modelMapper() == 0); // Model mapper should be unset
             }
             /*
             bool setModel(QAbstractItemModel *model);
             void setModelMapping(int categories, int bottomBoundary, int topBoundary, Qt::Orientation orientation = Qt::Vertical);
             void setModelMappingRange(int first, int count = -1);
             */
             QTEST_MAIN(tst_QGroupedBarSeries)
             #include "tst_qgroupedbarseries.moc"

test/auto/qpercentbarseries/tst_qpercentbarseries.cpp +4 -4

             /****************************************************************************
             **
             ** 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 <QtTest/QtTest>
             #include <qpercentbarseries.h>
             #include <qbarset.h>
             #include <qchartview.h>
             #include <qchart.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QBarSet*)
             class tst_QPercentBarSeries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qpercentbarseries_data();
                 void qpercentbarseries();
                 void type_data();
                 void type();
                 void mouseclicked_data();
                 void mouseclicked();
                 void mousehovered_data();
                 void mousehovered();
             private:
                 QPercentBarSeries* m_barseries;
             };
             void tst_QPercentBarSeries::initTestCase()
             {
                 qRegisterMetaType<QBarSet*>("QBarSet*");
             }
             void tst_QPercentBarSeries::cleanupTestCase()
             {
             }
             void tst_QPercentBarSeries::init()
             {
                 m_barseries = new QPercentBarSeries();
             }
             void tst_QPercentBarSeries::cleanup()
             {
                 delete m_barseries;
                 m_barseries = 0;
             }
             void tst_QPercentBarSeries::qpercentbarseries_data()
             {
             }
             void tst_QPercentBarSeries::qpercentbarseries()
             {
                 QPercentBarSeries *barseries = new QPercentBarSeries();
                 QVERIFY(barseries != 0);
             }
             void tst_QPercentBarSeries::type_data()
             {
             }
             void tst_QPercentBarSeries::type()
             {
                 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypePercentBar);
             }
             void tst_QPercentBarSeries::mouseclicked_data()
             {
             }
             void tst_QPercentBarSeries::mouseclicked()
             {
                 QPercentBarSeries* series = new QPercentBarSeries();
                 QBarCategories categories;
                 categories << "test1" << "test2" << "test3";
                 series->setCategories(categories);
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
-                series->appendBarSet(set1);
+                series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
-                series->appendBarSet(set2);
+                series->append(set2);
                 QSignalSpy setSpy1(set1, SIGNAL(clicked(QString)));
                 QSignalSpy setSpy2(set2, SIGNAL(clicked(QString)));
                 QSignalSpy seriesSpy(series,SIGNAL(clicked(QBarSet*,QString)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
             //====================================================================================
             // barset 1, category test1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(115,230));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test1")) == 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //====================================================================================
             // barset 1, category test2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(205,230));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test2")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //====================================================================================
             // barset 1, category test3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(300,230));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test3")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //====================================================================================
             // barset 2, category test1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(115,140));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test1")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
             //====================================================================================
             // barset 2, category test2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(205,140));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test2")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
             //====================================================================================
             // barset 2, category test3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(300,140));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test3")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
             //====================================================================================
             // no event cases
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(1,1));     // Outside of both sets
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(1,1));    // Right mouse button outside and inside sets
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(115,230)); // barset 1, category test1
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(205,230)); // barset 1, category test2
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(300,230)); // barset 1, category test3
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(115,140)); // barset 2, category test1
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(205,140)); // barset 2, category test2
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(300,140)); // barset 2, category test3
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 0);
             }
             void tst_QPercentBarSeries::mousehovered_data()
             {
             }
             void tst_QPercentBarSeries::mousehovered()
             {
                 QPercentBarSeries* series = new QPercentBarSeries();
                 QBarCategories categories;
                 categories << "test1" << "test2" << "test3";
                 series->setCategories(categories);
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
-                series->appendBarSet(set1);
+                series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
-                series->appendBarSet(set2);
+                series->append(set2);
                 QSignalSpy setSpy1(set1, SIGNAL(hovered(bool)));
                 QSignalSpy setSpy2(set2, SIGNAL(hovered(bool)));
                 QSignalSpy seriesSpy(series,SIGNAL(hovered(QBarSet*,bool)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
             //=======================================================================
             // move mouse to left border
                 QTest::mouseMove(view.viewport(), QPoint(0, 230));
                 QVERIFY(setSpy1.count() == 0);
                 QVERIFY(setSpy2.count() == 0);
                 QVERIFY(seriesSpy.count() == 0);
             //=======================================================================
             // move mouse on top of set1
                 QTest::mouseMove(view.viewport(), QPoint(115,230));
                 QVERIFY(setSpy1.count() == 1);
                 QVERIFY(setSpy2.count() == 0);
                 QVERIFY(seriesSpy.count() == 1);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == true);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //=======================================================================
             // move mouse from top of set1 to top of set2
                 QTest::mouseMove(view.viewport(), QPoint(115,140));
                 QVERIFY(setSpy1.count() == 1);
                 QVERIFY(setSpy2.count() == 1);
                 QVERIFY(seriesSpy.count() == 2);
                 // should leave set1
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == false);
                 // should enter set2
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == true);
                 // should leave set1
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
                 QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(1).toBool() == false);
                 // should enter set2
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
                 QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(1).toBool() == true);
             //=======================================================================
             // move mouse from top of set2 to background
                 QTest::mouseMove(view.viewport(), QPoint(0,140));
                 QVERIFY(setSpy1.count() == 0);
                 QVERIFY(setSpy2.count() == 1);
                 QVERIFY(seriesSpy.count() == 1);
                 // should leave set2 (event via set)
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == false);
                 // should leave set2 (event via series)
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
                 QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(1).toBool() == false);
             }
             /*
             bool setModel(QAbstractItemModel *model);
             void setModelMapping(int categories, int bottomBoundary, int topBoundary, Qt::Orientation orientation = Qt::Vertical);
             void setModelMappingRange(int first, int count = -1);
             */
             QTEST_MAIN(tst_QPercentBarSeries)
             #include "tst_qpercentbarseries.moc"

test/auto/qstackedbarseries/tst_qstackedbarseries.cpp +4 -4

             /****************************************************************************
             **
             ** 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 <QtTest/QtTest>
             #include <qstackedbarseries.h>
             #include <qbarset.h>
             #include <qchartview.h>
             #include <qchart.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QBarSet*)
             class tst_QStackedBarSeries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qstackedbarseries_data();
                 void qstackedbarseries();
                 void type_data();
                 void type();
                 void mouseclicked_data();
                 void mouseclicked();
                 void mousehovered_data();
                 void mousehovered();
             private:
                 QStackedBarSeries* m_barseries;
             };
             void tst_QStackedBarSeries::initTestCase()
             {
                 qRegisterMetaType<QBarSet*>("QBarSet*");
             }
             void tst_QStackedBarSeries::cleanupTestCase()
             {
             }
             void tst_QStackedBarSeries::init()
             {
                 m_barseries = new QStackedBarSeries();
             }
             void tst_QStackedBarSeries::cleanup()
             {
                 delete m_barseries;
                 m_barseries = 0;
             }
             void tst_QStackedBarSeries::qstackedbarseries_data()
             {
             }
             void tst_QStackedBarSeries::qstackedbarseries()
             {
                 QStackedBarSeries *barseries = new QStackedBarSeries();
                 QVERIFY(barseries != 0);
             }
             void tst_QStackedBarSeries::type_data()
             {
             }
             void tst_QStackedBarSeries::type()
             {
                 QVERIFY(m_barseries->type() == QAbstractSeries::SeriesTypeStackedBar);
             }
             void tst_QStackedBarSeries::mouseclicked_data()
             {
             }
             void tst_QStackedBarSeries::mouseclicked()
             {
                 QStackedBarSeries* series = new QStackedBarSeries();
                 QBarCategories categories;
                 categories << "test1" << "test2" << "test3";
                 series->setCategories(categories);
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
-                series->appendBarSet(set1);
+                series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
-                series->appendBarSet(set2);
+                series->append(set2);
                 QSignalSpy setSpy1(set1, SIGNAL(clicked(QString)));
                 QSignalSpy setSpy2(set2, SIGNAL(clicked(QString)));
                 QSignalSpy seriesSpy(series,SIGNAL(clicked(QBarSet*,QString)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
             //====================================================================================
             // barset 1, category test1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(115,230));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 1);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test1")) == 0);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //====================================================================================
             // barset 1, category test2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(205,230));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test2")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //====================================================================================
             // barset 1, category test3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(300,230));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 1);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test3")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //====================================================================================
             // barset 2, category test1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(115,140));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test1")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
             //====================================================================================
             // barset 2, category test2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(205,140));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test2")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
             //====================================================================================
             // barset 2, category test3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(300,140));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 1);
                 QCOMPARE(seriesSpy.count(), 1);
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::String);
                 QVERIFY(setSpyArg.at(0).toString().compare(QString("test3")) == 0);
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
             //====================================================================================
             // no event cases
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, QPoint(1,1));     // Outside of both sets
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(1,1));    // Right mouse button outside and inside sets
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(115,230)); // barset 1, category test1
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(205,230)); // barset 1, category test2
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(300,230)); // barset 1, category test3
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(115,140)); // barset 2, category test1
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(205,140)); // barset 2, category test2
                 QTest::mouseClick(view.viewport(), Qt::RightButton, 0, QPoint(300,140)); // barset 2, category test3
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(setSpy1.count(), 0);
                 QCOMPARE(setSpy2.count(), 0);
                 QCOMPARE(seriesSpy.count(), 0);
             }
             void tst_QStackedBarSeries::mousehovered_data()
             {
             }
             void tst_QStackedBarSeries::mousehovered()
             {
                 QStackedBarSeries* series = new QStackedBarSeries();
                 QBarCategories categories;
                 categories << "test1" << "test2" << "test3";
                 series->setCategories(categories);
                 QBarSet* set1 = new QBarSet(QString("set 1"));
                 *set1 << 10 << 10 << 10;
-                series->appendBarSet(set1);
+                series->append(set1);
                 QBarSet* set2 = new QBarSet(QString("set 2"));
                 *set2 << 10 << 10 << 10;
-                series->appendBarSet(set2);
+                series->append(set2);
                 QSignalSpy setSpy1(set1, SIGNAL(hovered(bool)));
                 QSignalSpy setSpy2(set2, SIGNAL(hovered(bool)));
                 QSignalSpy seriesSpy(series,SIGNAL(hovered(QBarSet*,bool)));
                 QChartView view(new QChart());
                 view.resize(400,300);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
             //=======================================================================
             // move mouse to left border
                 QTest::mouseMove(view.viewport(), QPoint(0, 230));
                 QVERIFY(setSpy1.count() == 0);
                 QVERIFY(setSpy2.count() == 0);
                 QVERIFY(seriesSpy.count() == 0);
             //=======================================================================
             // move mouse on top of set1
                 QTest::mouseMove(view.viewport(), QPoint(115,230));
                 QVERIFY(setSpy1.count() == 1);
                 QVERIFY(setSpy2.count() == 0);
                 QVERIFY(seriesSpy.count() == 1);
                 QList<QVariant> setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == true);
                 QList<QVariant> seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
             //=======================================================================
             // move mouse from top of set1 to top of set2
                 QTest::mouseMove(view.viewport(), QPoint(115,140));
                 QVERIFY(setSpy1.count() == 1);
                 QVERIFY(setSpy2.count() == 1);
                 QVERIFY(seriesSpy.count() == 2);
                 // should leave set1
                 setSpyArg = setSpy1.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == false);
                 // should enter set2
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == true);
                 // should leave set1
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set1);
                 QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(1).toBool() == false);
                 // should enter set2
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
                 QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(1).toBool() == true);
             //=======================================================================
             // move mouse from top of set2 to background
                 QTest::mouseMove(view.viewport(), QPoint(0,140));
                 QVERIFY(setSpy1.count() == 0);
                 QVERIFY(setSpy2.count() == 1);
                 QVERIFY(seriesSpy.count() == 1);
                 // should leave set2 (event via set)
                 setSpyArg = setSpy2.takeFirst();
                 QVERIFY(setSpyArg.at(0).type() == QVariant::Bool);
                 QVERIFY(setSpyArg.at(0).toBool() == false);
                 // should leave set2 (event via series)
                 seriesSpyArg = seriesSpy.takeFirst();
                 QCOMPARE(qvariant_cast<QBarSet*>(seriesSpyArg.at(0)), set2);
                 QVERIFY(seriesSpyArg.at(1).type() == QVariant::Bool);
                 QVERIFY(seriesSpyArg.at(1).toBool() == false);
             }
             /*
             bool setModel(QAbstractItemModel *model);
             void setModelMapping(int categories, int bottomBoundary, int topBoundary, Qt::Orientation orientation = Qt::Vertical);
             void setModelMappingRange(int first, int count = -1);
             */
             QTEST_MAIN(tst_QStackedBarSeries)
             #include "tst_qstackedbarseries.moc"

test/chartwidgettest/mainwidget.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "mainwidget.h"
             #include "dataseriedialog.h"
             #include "qchartview.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qlineseries.h"
             #include <qareaseries.h>
             #include <qsplineseries.h>
             #include <qbarset.h>
             #include <qbarseries.h>
             #include <qstackedbarseries.h>
             #include <qpercentbarseries.h>
             #include <QPushButton>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGridLayout>
             #include <QHBoxLayout>
             #include <QLabel>
             #include <QSpacerItem>
             #include <QMessageBox>
             #include <cmath>
             #include <QDebug>
             #include <QStandardItemModel>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent),
                 m_addSerieDialog(0),
                 m_chart(0)
             {
                 m_chart = new QChart();
                 // Grid layout for the controls for configuring the chart widget
                 QGridLayout *grid = new QGridLayout();
                 QPushButton *addSeriesButton = new QPushButton("Add series");
                 connect(addSeriesButton, SIGNAL(clicked()), this, SLOT(addSeries()));
                 grid->addWidget(addSeriesButton, 0, 1);
                 initBackroundCombo(grid);
                 initScaleControls(grid);
                 initThemeCombo(grid);
                 initCheckboxes(grid);
                 // add row with empty label to make all the other rows static
                 grid->addWidget(new QLabel(""), grid->rowCount(), 0);
                 grid->setRowStretch(grid->rowCount() - 1, 1);
                 // Create chart view with the chart
                 m_chartView = new QChartView(m_chart, this);
                 m_chartView->setRubberBand(QChartView::HorizonalRubberBand);
                 // Another grid layout as a main layout
                 QGridLayout *mainLayout = new QGridLayout();
                 mainLayout->addLayout(grid, 0, 0);
                 mainLayout->addWidget(m_chartView, 0, 1, 3, 1);
                 setLayout(mainLayout);
             }
             // Combo box for selecting the chart's background
             void MainWidget::initBackroundCombo(QGridLayout *grid)
             {
                 QComboBox *backgroundCombo = new QComboBox(this);
                 backgroundCombo->addItem("Color");
                 backgroundCombo->addItem("Gradient");
                 backgroundCombo->addItem("Image");
                 connect(backgroundCombo, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(backgroundChanged(int)));
                 grid->addWidget(new QLabel("Background:"), grid->rowCount(), 0);
                 grid->addWidget(backgroundCombo, grid->rowCount() - 1, 1);
             }
             // Scale related controls (auto-scale vs. manual min-max values)
             void MainWidget::initScaleControls(QGridLayout *grid)
             {
                 m_autoScaleCheck = new QCheckBox("Automatic scaling");
                 connect(m_autoScaleCheck, SIGNAL(stateChanged(int)), this, SLOT(autoScaleChanged(int)));
                 // Allow setting also non-sense values (like -2147483648 and 2147483647)
                 m_xMinSpin = new QSpinBox();
                 m_xMinSpin->setMinimum(INT_MIN);
                 m_xMinSpin->setMaximum(INT_MAX);
                 m_xMinSpin->setValue(0);
                 connect(m_xMinSpin, SIGNAL(valueChanged(int)), this, SLOT(xMinChanged(int)));
                 m_xMaxSpin = new QSpinBox();
                 m_xMaxSpin->setMinimum(INT_MIN);
                 m_xMaxSpin->setMaximum(INT_MAX);
                 m_xMaxSpin->setValue(10);
                 connect(m_xMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(xMaxChanged(int)));
                 m_yMinSpin = new QSpinBox();
                 m_yMinSpin->setMinimum(INT_MIN);
                 m_yMinSpin->setMaximum(INT_MAX);
                 m_yMinSpin->setValue(0);
                 connect(m_yMinSpin, SIGNAL(valueChanged(int)), this, SLOT(yMinChanged(int)));
                 m_yMaxSpin = new QSpinBox();
                 m_yMaxSpin->setMinimum(INT_MIN);
                 m_yMaxSpin->setMaximum(INT_MAX);
                 m_yMaxSpin->setValue(10);
                 connect(m_yMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(yMaxChanged(int)));
                 grid->addWidget(m_autoScaleCheck, grid->rowCount(), 0);
                 grid->addWidget(new QLabel("x min:"), grid->rowCount(), 0);
                 grid->addWidget(m_xMinSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("x max:"), grid->rowCount(), 0);
                 grid->addWidget(m_xMaxSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("y min:"), grid->rowCount(), 0);
                 grid->addWidget(m_yMinSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("y max:"), grid->rowCount(), 0);
                 grid->addWidget(m_yMaxSpin, grid->rowCount() - 1, 1);
                 m_autoScaleCheck->setChecked(true);
             }
             // Combo box for selecting theme
             void MainWidget::initThemeCombo(QGridLayout *grid)
             {
                 QComboBox *chartTheme = new QComboBox();
                 chartTheme->addItem("Default");
                 chartTheme->addItem("Light");
                 chartTheme->addItem("Blue Cerulean");
                 chartTheme->addItem("Dark");
                 chartTheme->addItem("Brown Sand");
                 chartTheme->addItem("Blue NCS");
                 chartTheme->addItem("High Contrast");
                 chartTheme->addItem("Blue Icy");
                 connect(chartTheme, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(changeChartTheme(int)));
                 grid->addWidget(new QLabel("Chart theme:"), 8, 0);
                 grid->addWidget(chartTheme, 8, 1);
             }
             // Different check boxes for customizing chart
             void MainWidget::initCheckboxes(QGridLayout *grid)
             {
                 // TODO: setZoomEnabled slot has been removed from QChartView -> Re-implement zoom on/off
                 QCheckBox *zoomCheckBox = new QCheckBox("Drag'n drop Zoom");
             //    connect(zoomCheckBox, SIGNAL(toggled(bool)), m_chartView, SLOT(setZoomEnabled(bool)));
                 zoomCheckBox->setChecked(true);
                 grid->addWidget(zoomCheckBox, grid->rowCount(), 0);
                 QCheckBox *aliasCheckBox = new QCheckBox("Anti-alias");
                 connect(aliasCheckBox, SIGNAL(toggled(bool)), this, SLOT(antiAliasToggled(bool)));
                 aliasCheckBox->setChecked(false);
                 grid->addWidget(aliasCheckBox, grid->rowCount(), 0);
             }
             void MainWidget::antiAliasToggled(bool enabled)
             {
                 m_chartView->setRenderHint(QPainter::Antialiasing, enabled);
             }
             void MainWidget::addSeries()
             {
                 if (!m_addSerieDialog) {
                     m_addSerieDialog = new DataSerieDialog(this);
                     connect(m_addSerieDialog, SIGNAL(accepted(QString,int,int,QString,bool)),
                             this, SLOT(addSeries(QString,int,int,QString,bool)));
                 }
                 m_addSerieDialog->exec();
             }
             QList<RealList> MainWidget::generateTestData(int columnCount, int rowCount, QString dataCharacteristics)
             {
                 // TODO: dataCharacteristics
                 QList<RealList> testData;
                 for (int j(0); j < columnCount; j++) {
                     QList <qreal> newColumn;
                     for (int i(0); i < rowCount; i++) {
                         if (dataCharacteristics == "Sin") {
                             newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100));
                         } else if (dataCharacteristics == "Sin + random") {
                             newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100) + (rand() % 5));
                         } else if (dataCharacteristics == "Random") {
                             newColumn.append(rand() % 10 + (qreal) rand() / (qreal) RAND_MAX);
                         } else if (dataCharacteristics == "Linear") {
                             //newColumn.append(i * (j + 1.0));
                             // TODO: temporary hack to make pie work; prevent zero values:
                             newColumn.append(i * (j + 1.0) + 0.1);
                         } else { // "constant"
                             newColumn.append((j + 1.0));
                         }
                     }
                     testData.append(newColumn);
                 }
                 return testData;
             }
             QStringList MainWidget::generateLabels(int count)
             {
                 QStringList result;
                 for (int i(0); i < count; i++)
                     result.append("label" + QString::number(i));
                 return result;
             }
             void MainWidget::addSeries(QString seriesName, int columnCount, int rowCount, QString dataCharacteristics, bool labelsEnabled)
             {
                 qDebug() << "addSeries: " << seriesName
                          << " columnCount: " << columnCount
                          << " rowCount: " << rowCount
                          << " dataCharacteristics: " << dataCharacteristics
                          << " labels enabled: " << labelsEnabled;
                 m_defaultSeriesName = seriesName;
                 QList<RealList> data = generateTestData(columnCount, rowCount, dataCharacteristics);
                 // Line series and scatter series use similar data
                 if (seriesName == "Line") {
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QLineSeries *series = new QLineSeries();
                         series->setName("line" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             series->append(i, column.at(i));
                         m_chart->addSeries(series);
                     }
                 } else if (seriesName == "Area") {
                     // TODO: lower series for the area?
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QLineSeries *lineSeries = new QLineSeries();
                         for (int i(0); i < column.count(); i++)
                             lineSeries->append(i, column.at(i));
                         QAreaSeries *areaSeries = new QAreaSeries(lineSeries);
                         areaSeries->setName("area" + QString::number(j));
                         m_chart->addSeries(areaSeries);
                     }
                 } else if (seriesName == "Scatter") {
                     for (int j(0); j < data.count(); j++) {
                         QList<qreal> column = data.at(j);
                         QScatterSeries *series = new QScatterSeries();
                         series->setName("scatter" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             series->append(i, column.at(i));
                         m_chart->addSeries(series);
                     }
                 } else if (seriesName == "Pie") {
                     QStringList labels = generateLabels(rowCount);
                     for (int j(0); j < data.count(); j++) {
                         QPieSeries *series = new QPieSeries();
                         QList<qreal> column = data.at(j);
                         for (int i(0); i < column.count(); i++)
                             series->append(column.at(i), labels.at(i));
                         m_chart->addSeries(series);
                     }
                 } else if (seriesName == "Bar"
                            || seriesName == "Stacked bar"
                            || seriesName == "Percent bar") {
                     QStringList category;
                     QStringList labels = generateLabels(rowCount);
                     foreach(QString label, labels)
                         category << label;
                     QBarSeries* series = 0;
                     if (seriesName == "Bar") {
                         series = new QBarSeries(this);
                         series->setCategories(category);
                     } else if (seriesName == "Stacked bar") {
                         series = new QStackedBarSeries(this);
                         series->setCategories(category);
                     } else {
                         series = new QPercentBarSeries(this);
                         series->setCategories(category);
                     }
                     for (int j(0); j < data.count(); j++) {
                         QList<qreal> column = data.at(j);
                         QBarSet *set = new QBarSet("set" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             *set << column.at(i);
-                        series->appendBarSet(set);
+                        series->append(set);
                     }
                     m_chart->addSeries(series);
                 } else if (seriesName == "Spline") {
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QSplineSeries *series = new QSplineSeries();
                         for (int i(0); i < column.count(); i++)
                             series->append(i, column.at(i));
                         m_chart->addSeries(series);
                     }
                 }
             }
             void MainWidget::backgroundChanged(int itemIndex)
             {
                 qDebug() << "backgroundChanged: " << itemIndex;
             }
             void MainWidget::autoScaleChanged(int value)
             {
                 if (value) {
                     // TODO: enable auto scaling
                 } else {
                     // TODO: set scaling manually (and disable auto scaling)
                 }
                 m_xMinSpin->setEnabled(!value);
                 m_xMaxSpin->setEnabled(!value);
                 m_yMinSpin->setEnabled(!value);
                 m_yMaxSpin->setEnabled(!value);
             }
             void MainWidget::xMinChanged(int value)
             {
                 qDebug() << "xMinChanged: " << value;
             }
             void MainWidget::xMaxChanged(int value)
             {
                 qDebug() << "xMaxChanged: " << value;
             }
             void MainWidget::yMinChanged(int value)
             {
                 qDebug() << "yMinChanged: " << value;
             }
             void MainWidget::yMaxChanged(int value)
             {
                 qDebug() << "yMaxChanged: " << value;
             }
             void MainWidget::changeChartTheme(int themeIndex)
             {
                 qDebug() << "changeChartTheme: " << themeIndex;
                 m_chart->setTheme((QChart::ChartTheme) themeIndex);
             }

test/gdpbarchart/widget.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "widget.h"
             #include <QChart>
             #include <QScatterSeries>
             #include <QAxis>
             #include <QBarSet>
             #include <QBarSeries>
             #include <QLegend>
             #include <QGridLayout>
             #include <QPushButton>
             #include <QLabel>
             #include <QListWidget>
             #include <QPrinter>
             #include <QPrintDialog>
             #include <QRadioButton>
             #include <QStringList>
             #include <QSqlQuery>
             #include <QDebug>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Widget::Widget(QWidget *parent)
                 : QWidget(parent)
             {
                 setGeometry(100, 100, 1000, 600);
                 // right panel layout
                 barChartRadioButton = new QRadioButton(tr("Bar chart"));
                 barChartRadioButton->setChecked(true);
                 scatterChartRadioButton = new QRadioButton(tr("Scatter chart"));
                 scatterChartRadioButton->setChecked(false);
                 countrieslist = new QListWidget;
                 countrieslist->setSelectionMode(QAbstractItemView::MultiSelection);
                 //list of years widget
                 yearslist = new QListWidget;
                 yearslist->setSelectionMode(QAbstractItemView::ExtendedSelection);
                 for (int i = 1990; i < 2011; i++)
                     yearslist->addItem(QString("%1").arg(i));
                 QPushButton* refreshButton = new QPushButton(tr("Refresh"));
                 connect(refreshButton, SIGNAL(clicked()), this, SLOT(refreshChart()));
                 QPushButton* printButton = new QPushButton(tr("Print to pdf"));
                 connect(printButton, SIGNAL(clicked()), this, SLOT(printChart()));
                 QVBoxLayout* rightPanelLayout = new QVBoxLayout;
                 rightPanelLayout->addWidget(barChartRadioButton);
                 rightPanelLayout->addWidget(scatterChartRadioButton);
                 rightPanelLayout->addWidget(countrieslist);
                 rightPanelLayout->addWidget(yearslist);
                 rightPanelLayout->addWidget(refreshButton);
                 rightPanelLayout->addWidget(printButton);
                 rightPanelLayout->setStretch(0, 1);
                 rightPanelLayout->setStretch(1, 0);
                 QChart *chart = new QChart();
                 chart->setTitle("GDP by country");
                 chart->legend()->setVisible(true);
                 // main layout
                 chartView = new QChartView(chart);
                 QGridLayout* mainLayout = new QGridLayout;
                 mainLayout->addWidget(chartView, 0, 0);
                 mainLayout->addLayout(rightPanelLayout, 0, 1);
                 mainLayout->setColumnStretch(0,1);
                 setLayout(mainLayout);
                 // connect to the database
                 db = QSqlDatabase::addDatabase("QSQLITE");
                 db.setDatabaseName("gdpData");
                 if(!db.open())
                 {
                     qDebug() << "could not open database. SQLite db file missing (?)";
                     return;
                 }
                 // get the list of all countires and regions.
                 QSqlQuery query;
                 query.exec("SELECT DISTINCT country FROM gdp2");
                 // add the countries to the country filter
                 while (query.next()) {
                     countrieslist->addItem(query.value(0).toString());
                 }
             }
             Widget::~Widget()
             {
                 //
                 db.close();
             }
             /*!
                 refreshes the chart
             */
             void Widget::refreshChart()
             {
                 chartView->chart()->removeAllSeries();
                 // selected countries items list is not sorted. copy the values to QStringlist and sort them.
                 QStringList selectedCountriesStrings;
                 QList<QListWidgetItem*> selectedCountriesItems = countrieslist->selectedItems();
                 for (int i = 0; i < selectedCountriesItems.size(); i++)
                     selectedCountriesStrings.append(selectedCountriesItems[i]->text());
                 selectedCountriesStrings.sort();
                 QSqlQuery query;
                 // selected years items list is not sorted. copy the values to QList<int> and sort them.
                 QList<int> selectedYearsInts;
                 QList<QListWidgetItem*> selectedYearsItems = yearslist->selectedItems();
                 for (int i = 0; i < selectedYearsItems.size(); i++)
                     selectedYearsInts.append(selectedYearsItems[i]->text().toInt());
                 qSort(selectedYearsInts.begin(), selectedYearsInts.end());
                 if (barChartRadioButton->isChecked())
                 {
                     // use the sorted selected coutries list to initialize BarCategory
                     QStringList category;
                     for (int i = 0; i < selectedCountriesStrings.size(); i++)
                         category << selectedCountriesStrings[i];
                     QBarSeries* series0 = new QBarSeries();
                     series0->setCategories(category);
             //        series0 = new QBarSeries(category);
                     // prepare the selected counries SQL query
                     QString countriesQuery = "country IN (";
                     for (int i = 0; i < selectedCountriesStrings.size(); i++)
                     {
                         countriesQuery.append("'" + selectedCountriesStrings[i] + "'");
                         if ( i < selectedCountriesStrings.size() - 1)
                             countriesQuery.append(",");
                         else
                             countriesQuery.append(")");
                     }
                     // perform a query for each selected year
                     for (int i = 0; i < selectedYearsInts.size(); i++)
                     {
                         query.exec("SELECT country,gdpvalue FROM gdp2 where year=" + QString("%1").arg(selectedYearsInts[i]) + " AND " + countriesQuery);
                         QBarSet* barSet = new QBarSet(QString::number(selectedYearsInts[i]));
                         //        while (query.next()) {
                         //            qDebug() << query.value(0).toString() << " : " << query.value(1).toString();
                         //        }
                         query.first();
                         // the data for some of the coutries for some years might be missing.
                         // QBarChart needs bars to have same size
                         for (int k = 0; k < selectedCountriesStrings.size(); k++)
                         {
                             if (selectedCountriesStrings[k] == query.value(0).toString())
                             {
                                 *barSet << query.value(1).toReal();
                                 qDebug() << query.value(0).toString() << query.value(1).toReal() << " : " << QString("%1").arg(selectedYearsInts[i]);
                                 query.next();
                             }
                             else
                             {
                                 // data missing, put 0
                                 *barSet << 0.0f;
                                 qDebug() << "Putting 0 for the missing data" << " : " << QString("%1").arg(selectedYearsInts[i]);
                             }
                         }
-                        series0->appendBarSet(barSet);
+                        series0->append(barSet);
                     }
                     // add the serie to the chart
                     chartView->chart()->addSeries(series0);
                 }
                 else if (scatterChartRadioButton->isChecked())
                 {
                     QString yearsQuery = "year IN (";
                     for (int i = 0; i < selectedYearsInts.size(); i++)
                     {
                         yearsQuery.append("'" + QString("%1").arg(selectedYearsInts[i]) + "'");
                         if ( i < selectedYearsInts.size() - 1)
                             yearsQuery.append(",");
                         else
                             yearsQuery.append(")");
                     }
                     // perform a query for each selected country
                     for (int i = 0; i < selectedCountriesStrings.size(); i++)
                     {
                         query.exec("SELECT year,gdpvalue FROM gdp2 where country='" + selectedCountriesStrings[i] + "' AND " + yearsQuery);
                         query.first();
                         QScatterSeries* series = new QScatterSeries;
                         series->setName(selectedCountriesStrings[i]);
                         // the data for some of the coutries for some years might be missing.
                         for (int k = 0; k < selectedYearsInts.size(); k++)
                         {
                             if (selectedYearsInts[k] == query.value(0).toInt())
                             {
                                 *series << QPointF(query.value(0).toInt() , query.value(1).toReal());
                                 qDebug() << query.value(0).toString() << query.value(1).toReal() << " : " << QString("%1").arg(selectedYearsInts[k]);
                                 query.next();
                             }
                             else
                             {
                                 // data missing, put 0
                                 *series << QPointF(selectedYearsInts[k] , 0.0f);
                                 qDebug() << "Putting 0 for the missing data" << " : " << QString("%1").arg(selectedYearsInts[i]) << " " << query.value(0).toInt();
                             }
                         }
                         //            chartArea->axisX()->setRange(selectedYearsInts[selectedYearsInts.size() - 1] + 1, selectedYearsInts[0] - 1);
                         chartView->chart()->addSeries(series);
                     }
                     chartView->chart()->axisX()->setRange(selectedYearsInts[selectedYearsInts.size() - 1] - 1, selectedYearsInts[0] + 1);
                 }
             }
             void Widget::printChart()
             {
                 QPrinter printer;
                 //    QPrinter printer(QPrinter::HighResolution);
                 printer.setOutputFormat(QPrinter::PdfFormat);
                 printer.setOrientation(QPrinter::Landscape);
                 printer.setOutputFileName("print.pdf");
                 QPainter painter;
                 painter.begin(&printer);
                 chartView->render(&painter);
             }

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