HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1206:080b090a9a03

pie: change the order of parameters when creating slices to be more intuitive

Jani Honkonen -

r1206:080b090a9a03

parent child

Context file:

r1206:080b090a9a03

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->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);
+                        QPieSlice *slice = series->append(data.second, data.first.y());
                         if (data == m_dataTable[i].first()) {
                             slice->setLabelVisible();
                             slice->setExploded();
                         }
                     }
                     qreal hPos = (pieSize / 2) + (i / (qreal) m_dataTable.count());
                     series->setPieSize(pieSize);
                     series->setHorizontalPosition(hPos);
                     series->setVerticalPosition(0.5);
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createSplineChart() const
             { // spine chart
                 QChart* chart = new QChart();
                 chart->axisX()->setNiceNumbersEnabled(true);
                 chart->axisY()->setNiceNumbersEnabled(true);
                 chart->setTitle("Spline chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QSplineSeries *series = new QSplineSeries(chart);
                     foreach (Data data, list)
                         series->append(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createScatterChart() const
             { // scatter chart
                 QChart* chart = new QChart();
                 chart->axisX()->setNiceNumbersEnabled(true);
                 chart->axisY()->setNiceNumbersEnabled(true);
                 chart->setTitle("Scatter chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 foreach (DataList list, m_dataTable) {
                     QScatterSeries *series = new QScatterSeries(chart);
                     foreach (Data data, list)
                         series->append(data.first);
                     series->setName(name + QString::number(nameIndex));
                     nameIndex++;
                     chart->addSeries(series);
                 }
                 return chart;
             }
             void ThemeWidget::updateUI()
             {
                 QChart::ChartTheme theme = (QChart::ChartTheme) m_themeComboBox->itemData(m_themeComboBox->currentIndex()).toInt();
                 if (m_charts.at(0)->chart()->theme() != theme) {
                     foreach (QChartView *chartView, m_charts)
                         chartView->chart()->setTheme(theme);
                     QPalette pal = window()->palette();
                     if (theme == QChart::ChartThemeLight) {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeDark) {
                         pal.setColor(QPalette::Window, QRgb(0x121218));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBlueCerulean) {
                         pal.setColor(QPalette::Window, QRgb(0x40434a));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBrownSand) {
                         pal.setColor(QPalette::Window, QRgb(0x9e8965));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeBlueNcs) {
                         pal.setColor(QPalette::Window, QRgb(0x018bba));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeHighContrast) {
                         pal.setColor(QPalette::Window, QRgb(0xffab03));
                         pal.setColor(QPalette::WindowText, QRgb(0x181818));
                     } else if (theme == QChart::ChartThemeBlueIcy) {
                         pal.setColor(QPalette::Window, QRgb(0xcee7f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     }
                     window()->setPalette(pal);
                 }
                 bool checked = m_antialiasCheckBox->isChecked();
                 foreach (QChartView *chart, m_charts)
                     chart->setRenderHint(QPainter::Antialiasing, checked);
                 QChart::AnimationOptions options(m_animatedComboBox->itemData(m_animatedComboBox->currentIndex()).toInt());
                 if (m_charts.at(0)->chart()->animationOptions() != options) {
                     foreach (QChartView *chartView, m_charts)
                         chartView->chart()->setAnimationOptions(options);
                 }
                 QLegend::Alignments alignment(m_legendComboBox->itemData(m_legendComboBox->currentIndex()).toInt());
                 if (!alignment) {
                     foreach (QChartView *chartView, m_charts) {
                         chartView->chart()->legend()->hide();
                     }
                 } else {
                     foreach (QChartView *chartView, m_charts) {
                         chartView->chart()->legend()->setAlignment(alignment);
                         chartView->chart()->legend()->show();
                     }
                 }
             }

demos/piechartcustomization/customslice.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 "customslice.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
-            CustomSlice::CustomSlice(qreal value, QString label)
+            CustomSlice::CustomSlice(QString label, qreal value)
-                :QPieSlice(value, label)
+                :QPieSlice(label, value)
             {
                 connect(this, SIGNAL(hovered(bool)), this, SLOT(showHighlight(bool)));
             }
             QBrush CustomSlice::originalBrush()
             {
                 return m_originalBrush;
             }
             void CustomSlice::showHighlight(bool show)
             {
                 if (show) {
                     QBrush brush = this->brush();
                     m_originalBrush = brush;
                     brush.setColor(brush.color().lighter());
                     setBrush(brush);
                 } else {
                     setBrush(m_originalBrush);
                 }
             }
             #include "moc_customslice.cpp"

demos/piechartcustomization/customslice.h +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$
             **
             ****************************************************************************/
             #ifndef CUSTOMSLICE_H
             #define CUSTOMSLICE_H
             #include <QPieSlice>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class CustomSlice : public QPieSlice
             {
                 Q_OBJECT
             public:
-                CustomSlice(qreal value, QString label);
+                CustomSlice(QString label, qreal value);
             public:
                 QBrush originalBrush();
             public Q_SLOTS:
                 void showHighlight(bool show);
             private:
                 QBrush m_originalBrush;
             };
             #endif // CUSTOMSLICE_H

demos/piechartcustomization/mainwidget.cpp +7 -7

             /****************************************************************************
             **
             ** 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 "customslice.h"
             #include "pentool.h"
             #include "brushtool.h"
             #include <QPushButton>
             #include <QComboBox>
             #include <QCheckBox>
             #include <QLabel>
             #include <QGroupBox>
             #include <QDoubleSpinBox>
             #include <QFormLayout>
             #include <QFontDialog>
             #include <QChartView>
             #include <QPieSeries>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWidget::MainWidget(QWidget* parent)
                 :QWidget(parent),
                 m_slice(0)
             {
                 // create chart
                 QChart *chart = new QChart;
                 chart->setTitle("Piechart customization");
                 chart->setAnimationOptions(QChart::AllAnimations);
                 // create series
                 m_series = new QPieSeries();
-                *m_series << new CustomSlice(10.0, "Slice 1");
+                *m_series << new CustomSlice("Slice 1", 10.0);
-                *m_series << new CustomSlice(20.0, "Slice 2");
+                *m_series << new CustomSlice("Slice 2", 20.0);
-                *m_series << new CustomSlice(30.0, "Slice 3");
+                *m_series << new CustomSlice("Slice 3", 30.0);
-                *m_series << new CustomSlice(40.0, "Slice 4");
+                *m_series << new CustomSlice("Slice 4", 40.0);
-                *m_series << new CustomSlice(50.0, "Slice 5");
+                *m_series << new CustomSlice("Slice 5", 50.0);
                 m_series->setLabelsVisible();
                 chart->addSeries(m_series);
                 connect(m_series, SIGNAL(clicked(QPieSlice*)), this, SLOT(handleSliceClicked(QPieSlice*)));
                 // chart settings
                 m_themeComboBox = new QComboBox();
                 m_themeComboBox->addItem("Light", QChart::ChartThemeLight);
                 m_themeComboBox->addItem("BlueCerulean", QChart::ChartThemeBlueCerulean);
                 m_themeComboBox->addItem("Dark", QChart::ChartThemeDark);
                 m_themeComboBox->addItem("BrownSand", QChart::ChartThemeBrownSand);
                 m_themeComboBox->addItem("BlueNcs", QChart::ChartThemeBlueNcs);
                 m_themeComboBox->addItem("High Contrast", QChart::ChartThemeHighContrast);
                 m_themeComboBox->addItem("Blue Icy", QChart::ChartThemeBlueIcy);
                 m_aaCheckBox = new QCheckBox();
                 m_animationsCheckBox = new QCheckBox();
                 m_animationsCheckBox->setCheckState(Qt::Checked);
                 m_legendCheckBox = new QCheckBox();
                 QFormLayout* chartSettingsLayout = new QFormLayout();
                 chartSettingsLayout->addRow("Theme", m_themeComboBox);
                 chartSettingsLayout->addRow("Antialiasing", m_aaCheckBox);
                 chartSettingsLayout->addRow("Animations", m_animationsCheckBox);
                 chartSettingsLayout->addRow("Legend", m_legendCheckBox);
                 QGroupBox* chartSettings = new QGroupBox("Chart");
                 chartSettings->setLayout(chartSettingsLayout);
                 connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this ,SLOT(updateChartSettings()));
                 connect(m_aaCheckBox, SIGNAL(toggled(bool)), this ,SLOT(updateChartSettings()));
                 connect(m_animationsCheckBox, SIGNAL(toggled(bool)), this ,SLOT(updateChartSettings()));
                 connect(m_legendCheckBox, SIGNAL(toggled(bool)), this ,SLOT(updateChartSettings()));
                 // series settings
                 m_hPosition = new QDoubleSpinBox();
                 m_hPosition->setMinimum(0.0);
                 m_hPosition->setMaximum(1.0);
                 m_hPosition->setSingleStep(0.1);
                 m_hPosition->setValue(m_series->horizontalPosition());
                 m_vPosition = new QDoubleSpinBox();
                 m_vPosition->setMinimum(0.0);
                 m_vPosition->setMaximum(1.0);
                 m_vPosition->setSingleStep(0.1);
                 m_vPosition->setValue(m_series->verticalPosition());
                 m_sizeFactor = new QDoubleSpinBox();
                 m_sizeFactor->setMinimum(0.0);
                 m_sizeFactor->setMaximum(1.0);
                 m_sizeFactor->setSingleStep(0.1);
                 m_sizeFactor->setValue(m_series->pieSize());
                 m_startAngle = new QDoubleSpinBox();
                 m_startAngle->setMinimum(0.0);
                 m_startAngle->setMaximum(360);
                 m_startAngle->setValue(m_series->pieStartAngle());
                 m_startAngle->setSingleStep(1);
                 m_endAngle = new QDoubleSpinBox();
                 m_endAngle->setMinimum(0.0);
                 m_endAngle->setMaximum(360);
                 m_endAngle->setValue(m_series->pieEndAngle());
                 m_endAngle->setSingleStep(1);
                 QPushButton *appendSlice = new QPushButton("Append slice");
                 QPushButton *insertSlice = new QPushButton("Insert slice");
                 QFormLayout* seriesSettingsLayout = new QFormLayout();
                 seriesSettingsLayout->addRow("Horizontal position", m_hPosition);
                 seriesSettingsLayout->addRow("Vertical position", m_vPosition);
                 seriesSettingsLayout->addRow("Size factor", m_sizeFactor);
                 seriesSettingsLayout->addRow("Start angle", m_startAngle);
                 seriesSettingsLayout->addRow("End angle", m_endAngle);
                 seriesSettingsLayout->addRow(appendSlice);
                 seriesSettingsLayout->addRow(insertSlice);
                 QGroupBox* seriesSettings = new QGroupBox("Series");
                 seriesSettings->setLayout(seriesSettingsLayout);
                 connect(m_vPosition, SIGNAL(valueChanged(double)), this, SLOT(updateSerieSettings()));
                 connect(m_hPosition, SIGNAL(valueChanged(double)), this, SLOT(updateSerieSettings()));
                 connect(m_sizeFactor, SIGNAL(valueChanged(double)), this, SLOT(updateSerieSettings()));
                 connect(m_startAngle, SIGNAL(valueChanged(double)), this, SLOT(updateSerieSettings()));
                 connect(m_endAngle, SIGNAL(valueChanged(double)), this, SLOT(updateSerieSettings()));
                 connect(appendSlice, SIGNAL(clicked()), this, SLOT(appendSlice()));
                 connect(insertSlice, SIGNAL(clicked()), this, SLOT(insertSlice()));
                 // slice settings
                 m_sliceName = new QLabel("<click a slice>");
                 m_sliceValue = new QDoubleSpinBox();
                 m_sliceValue->setMaximum(1000);
                 m_sliceLabelVisible = new QCheckBox();
                 m_sliceLabelArmFactor = new QDoubleSpinBox();
                 m_sliceLabelArmFactor->setSingleStep(0.01);
                 m_sliceExploded = new QCheckBox();
                 m_sliceExplodedFactor = new QDoubleSpinBox();
                 m_sliceExplodedFactor->setSingleStep(0.01);
                 m_pen = new QPushButton();
                 m_penTool = new PenTool("Slice pen", this);
                 m_brush = new QPushButton();
                 m_brushTool = new BrushTool("Slice brush", this);
                 m_font = new QPushButton();
                 m_labelPen = new QPushButton();
                 m_labelPenTool = new PenTool("Label pen", this);
                 QPushButton *removeSlice = new QPushButton("Remove slice");
                 QFormLayout* sliceSettingsLayout = new QFormLayout();
                 sliceSettingsLayout->addRow("Selected", m_sliceName);
                 sliceSettingsLayout->addRow("Value", m_sliceValue);
                 sliceSettingsLayout->addRow("Pen", m_pen);
                 sliceSettingsLayout->addRow("Brush", m_brush);
                 sliceSettingsLayout->addRow("Label visible", m_sliceLabelVisible);
                 sliceSettingsLayout->addRow("Label font", m_font);
                 sliceSettingsLayout->addRow("Label pen", m_labelPen);
                 sliceSettingsLayout->addRow("Label arm length", m_sliceLabelArmFactor);
                 sliceSettingsLayout->addRow("Exploded", m_sliceExploded);
                 sliceSettingsLayout->addRow("Explode distance", m_sliceExplodedFactor);
                 sliceSettingsLayout->addRow(removeSlice);
                 QGroupBox* sliceSettings = new QGroupBox("Slice");
                 sliceSettings->setLayout(sliceSettingsLayout);
                 connect(m_sliceValue, SIGNAL(valueChanged(double)), this, SLOT(updateSliceSettings()));
                 connect(m_pen, SIGNAL(clicked()), m_penTool, SLOT(show()));
                 connect(m_penTool, SIGNAL(changed()), this, SLOT(updateSliceSettings()));
                 connect(m_brush, SIGNAL(clicked()), m_brushTool, SLOT(show()));
                 connect(m_brushTool, SIGNAL(changed()), this, SLOT(updateSliceSettings()));
                 connect(m_font, SIGNAL(clicked()), this, SLOT(showFontDialog()));
                 connect(m_labelPen, SIGNAL(clicked()), m_labelPenTool, SLOT(show()));
                 connect(m_labelPenTool, SIGNAL(changed()), this, SLOT(updateSliceSettings()));
                 connect(m_sliceLabelVisible, SIGNAL(toggled(bool)), this, SLOT(updateSliceSettings()));
                 connect(m_sliceLabelVisible, SIGNAL(toggled(bool)), this, SLOT(updateSliceSettings()));
                 connect(m_sliceLabelArmFactor, SIGNAL(valueChanged(double)), this, SLOT(updateSliceSettings()));
                 connect(m_sliceExploded, SIGNAL(toggled(bool)), this, SLOT(updateSliceSettings()));
                 connect(m_sliceExplodedFactor, SIGNAL(valueChanged(double)), this, SLOT(updateSliceSettings()));
                 connect(removeSlice, SIGNAL(clicked()), this, SLOT(removeSlice()));
                 // create chart view
                 m_chartView = new QChartView(chart);
                 // create main layout
                 QVBoxLayout *settingsLayout = new QVBoxLayout();
                 settingsLayout->addWidget(chartSettings);
                 settingsLayout->addWidget(seriesSettings);
                 settingsLayout->addWidget(sliceSettings);
                 settingsLayout->addStretch();
                 QGridLayout* baseLayout = new QGridLayout();
                 baseLayout->addLayout(settingsLayout, 0, 0);
                 baseLayout->addWidget(m_chartView, 0, 1);
                 setLayout(baseLayout);
                 updateSerieSettings();
             }
             void MainWidget::updateChartSettings()
             {
                 QChart::ChartTheme theme = (QChart::ChartTheme) m_themeComboBox->itemData(m_themeComboBox->currentIndex()).toInt();
                 m_chartView->chart()->setTheme(theme);
                 m_chartView->setRenderHint(QPainter::Antialiasing, m_aaCheckBox->isChecked());
                 if (m_animationsCheckBox->checkState() == Qt::Checked)
                     m_chartView->chart()->setAnimationOptions(QChart::AllAnimations);
                 else
                     m_chartView->chart()->setAnimationOptions(QChart::NoAnimation);
                 if (m_legendCheckBox->checkState() == Qt::Checked)
                     m_chartView->chart()->legend()->show();
                 else
                     m_chartView->chart()->legend()->hide();
             }
             void MainWidget::updateSerieSettings()
             {
                 m_series->setHorizontalPosition(m_hPosition->value());
                 m_series->setVerticalPosition(m_vPosition->value());
                 m_series->setPieSize(m_sizeFactor->value());
                 m_series->setPieStartAngle(m_startAngle->value());
                 m_series->setPieEndAngle(m_endAngle->value());
             }
             void MainWidget::updateSliceSettings()
             {
                 if (!m_slice)
                     return;
                 m_slice->setValue(m_sliceValue->value());
                 m_slice->setPen(m_penTool->pen());
                 m_slice->setBrush(m_brushTool->brush());
                 m_slice->setLabelPen(m_labelPenTool->pen());
                 m_slice->setLabelVisible(m_sliceLabelVisible->isChecked());
                 m_slice->setLabelArmLengthFactor(m_sliceLabelArmFactor->value());
                 m_slice->setExploded(m_sliceExploded->isChecked());
                 m_slice->setExplodeDistanceFactor(m_sliceExplodedFactor->value());
             }
             void MainWidget::handleSliceClicked(QPieSlice* slice)
             {
                 m_slice = static_cast<CustomSlice*>(slice);
                 // name
                 m_sliceName->setText(slice->label());
                 // value
                 m_sliceValue->blockSignals(true);
                 m_sliceValue->setValue(slice->value());
                 m_sliceValue->blockSignals(false);
                 // pen
                 m_pen->setText(PenTool::name(m_slice->pen()));
                 m_penTool->setPen(m_slice->pen());
                 // brush
                 m_brush->setText(m_slice->originalBrush().color().name());
                 m_brushTool->setBrush(m_slice->originalBrush());
                 // label
                 m_labelPen->setText(PenTool::name(m_slice->labelPen()));
                 m_labelPenTool->setPen(m_slice->labelPen());
                 m_font->setText(slice->labelFont().toString());
                 m_sliceLabelVisible->blockSignals(true);
                 m_sliceLabelVisible->setChecked(slice->isLabelVisible());
                 m_sliceLabelVisible->blockSignals(false);
                 m_sliceLabelArmFactor->blockSignals(true);
                 m_sliceLabelArmFactor->setValue(slice->labelArmLengthFactor());
                 m_sliceLabelArmFactor->blockSignals(false);
                 // exploded
                 m_sliceExploded->blockSignals(true);
                 m_sliceExploded->setChecked(slice->isExploded());
                 m_sliceExploded->blockSignals(false);
                 m_sliceExplodedFactor->blockSignals(true);
                 m_sliceExplodedFactor->setValue(slice->explodeDistanceFactor());
                 m_sliceExplodedFactor->blockSignals(false);
             }
             void MainWidget::showFontDialog()
             {
                 if (!m_slice)
                     return;
                 QFontDialog dialog(m_slice->labelFont());
                 dialog.show();
                 dialog.exec();
                 m_slice->setLabelFont(dialog.currentFont());
                 m_font->setText(dialog.currentFont().toString());
             }
             void MainWidget::appendSlice()
             {
-                *m_series << new CustomSlice(10.0, "Slice " + QString::number(m_series->count()+1));
+                *m_series << new CustomSlice("Slice " + QString::number(m_series->count()+1), 10.0);
             }
             void MainWidget::insertSlice()
             {
                 if (!m_slice)
                     return;
                 int i = m_series->slices().indexOf(m_slice);
-                m_series->insert(i, new CustomSlice(10.0, "Slice " + QString::number(m_series->count()+1)));
+                m_series->insert(i, new CustomSlice("Slice " + QString::number(m_series->count()+1), 10.0));
             }
             void MainWidget::removeSlice()
             {
                 if (!m_slice)
                     return;
                 m_sliceName->setText("<click a slice>");
                 m_series->remove(m_slice);
                 m_slice = 0;
             }
             #include "moc_mainwidget.cpp"

examples/piechart/main.cpp +5 -5

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** 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 <QPieSeries>
             #include <QPieSlice>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 QPieSeries *series = new QPieSeries();
-                series->append(1, "Jane");
+                series->append("Jane", 1);
-                series->append(2, "Joe");
+                series->append("Joe", 2);
-                series->append(3, "Andy");
+                series->append("Andy", 3);
-                series->append(4, "Barbara");
+                series->append("Barbara", 4);
-                series->append(5, "Axel");
+                series->append("Axel", 5);
             //![1]
             //![2]
                 QPieSlice *slice = series->slices().at(1);
                 slice->setExploded();
                 slice->setLabelVisible();
                 slice->setPen(QPen(Qt::darkGreen, 2));
                 slice->setBrush(Qt::green);
             //![2]
             //![3]
                 QChart* chart = new QChart();
                 chart->addSeries(series);
                 chart->setTitle("Simple piechart example");
             //![3]
             //![4]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![4]
             //![5]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![5]
                 return a.exec();
             }

plugins/declarative/declarativepieseries.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 "declarativepieseries.h"
             #include "declarativechart.h"
             #include "qchart.h"
             #include <qdeclarativelist.h>
             #include "qpiemodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativePieSeries::DeclarativePieSeries(QObject *parent) :
                 QPieSeries(parent)
             {
                 // TODO: set default model on init?
             //    setModel(new DeclarativeTableModel());
                 // TODO: Set default mapper parameters to allow easy to use PieSeries api?
                 QPieModelMapper *mapper = modelMapper();//new QPieModelMapper();
                 mapper->setMapLabels(0);
                 mapper->setMapValues(1);
                 mapper->setOrientation(Qt::Vertical);
                 mapper->setFirst(0);
                 mapper->setCount(-1);
             //    setModelMapper(mapper);
             }
             void DeclarativePieSeries::classBegin()
             {
             }
             void DeclarativePieSeries::componentComplete()
             {
                 foreach(QObject *child, children()) {
                     if (qobject_cast<QPieSlice *>(child)) {
                         QPieSeries::append(qobject_cast<QPieSlice *>(child));
                     }
                 }
             }
             QDeclarativeListProperty<QPieSlice> DeclarativePieSeries::initialSlices()
             {
                 return QDeclarativeListProperty<QPieSlice>(this, 0, &DeclarativePieSeries::appendInitialSlices);
             }
             QPieSlice *DeclarativePieSeries::at(int index)
             {
                 QList<QPieSlice*> sliceList = slices();
                 if (index < sliceList.count())
                     return sliceList[index];
                 return 0;
             }
             QPieSlice* DeclarativePieSeries::find(QString label)
             {
                 foreach (QPieSlice *slice, slices()) {
                     if (slice->label() == label)
                         return slice;
                 }
                 return 0;
             }
             QPieSlice* DeclarativePieSeries::append(QString name, qreal value)
             {
                 // TODO: parameter order is wrong, switch it:
-                return QPieSeries::append(value, name);
+                return QPieSeries::append(name, value);
             }
             void DeclarativePieSeries::setPieModel(DeclarativeTableModel *model)
             {
                 QAbstractItemModel *m = qobject_cast<QAbstractItemModel *>(model);
                 if (m) {
                     QPieSeries::setModel(m);
                 } else {
                     qWarning("DeclarativePieSeries: Illegal model");
                 }
             }
             DeclarativeTableModel *DeclarativePieSeries::pieModel()
             {
                 return qobject_cast<DeclarativeTableModel *>(model());
             }
             #include "moc_declarativepieseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.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 "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qpieslice.h"
             #include "pieslicedata_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "legendmarker_p.h"
             #include <QAbstractItemModel>
             #include "qpiemodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries
                 \brief Pie series API for QtCommercial Charts
                 The pie series defines a pie chart which consists of pie slices which are defined as QPieSlice objects.
                 The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
                 The actual slice size is determined by that relative value.
                 Pie size and position on the chart is controlled by using relative values which range from 0.0 to 1.0
                 These relate to the actual chart rectangle.
                 By default the pie is defined as a full pie but it can also be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
                 Full pie is 360 degrees where 0 is at 12 a'clock.
                 See the \l {PieChart Example} {pie chart example} to learn how to create a simple pie chart.
                 \image examples_piechart.png
             */
             /*!
                 \property QPieSeries::horizontalPosition
                 \brief Defines the horizontal position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute left.
                 \o 1.0 is the absolute right.
                 \endlist
                 Default value is 0.5 (center).
             */
             /*!
                 \property QPieSeries::verticalPosition
                 \brief Defines the vertical position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute top.
                 \o 1.0 is the absolute bottom.
                 \endlist
                 Default value is 0.5 (center).
             */
             /*!
                 \property QPieSeries::size
                 \brief Defines the pie size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (pie not drawn).
                 \o 1.0 is the maximum size that can fit the chart.
                 \endlist
                 Default value is 0.7.
             */
             /*!
                 \property QPieSeries::startAngle
                 \brief Defines the starting angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 0.
             */
             /*!
                 \property QPieSeries::endAngle
                 \brief Defines the ending angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 360.
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent) :
                 QAbstractSeries(*new QPieSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destroys the series and its slices.
             */
             QPieSeries::~QPieSeries()
             {
                 // NOTE: d_prt destroyed by QObject
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
             QAbstractSeries::SeriesType QPieSeries::type() const
             {
                 return QAbstractSeries::SeriesTypePie;
             }
             /*!
                 Appends an array of \a slices to the series.
                 Slice ownership is passed to the series.
             */
             bool QPieSeries::append(QList<QPieSlice*> slices)
             {
                 Q_D(QPieSeries);
                 if (slices.count() == 0)
                     return false;
                 foreach (QPieSlice* s, slices) {
                     if (!s || d->m_slices.contains(s))
                         return false;
                 }
                 foreach (QPieSlice* s, slices) {
                     s->setParent(this);
                     d->m_slices << s;
                 }
                 d->updateDerivativeData();
                 foreach (QPieSlice* s, slices) {
                     connect(s, SIGNAL(changed()), d, SLOT(sliceChanged()));
                     connect(s, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                     connect(s, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                 }
                 emit d->added(slices);
                 return true;
             }
             /*!
                 Appends a single \a slice to the series.
                 Slice ownership is passed to the series.
             */
             bool QPieSeries::append(QPieSlice* slice)
             {
                 return append(QList<QPieSlice*>() << slice);
             }
             /*!
                 Appends a single \a slice to the series and returns a reference to the series.
                 Slice ownership is passed to the series.
             */
             QPieSeries& QPieSeries::operator << (QPieSlice* slice)
             {
                 append(slice);
                 return *this;
             }
             /*!
-                Appends a single slice to the series with give \a value and \a name.
+                Appends a single slice to the series with give \a value and \a label.
                 Slice ownership is passed to the series.
             */
-            QPieSlice* QPieSeries::append(qreal value, QString name)
+            QPieSlice* QPieSeries::append(QString label, qreal value)
             {
-                QPieSlice* slice = new QPieSlice(value, name);
+                QPieSlice* slice = new QPieSlice(label, value);
                 append(slice);
                 return slice;
             }
             /*!
                 Inserts a single \a slice to the series before the slice at \a index position.
                 Slice ownership is passed to the series.
             */
             bool QPieSeries::insert(int index, QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 if (index < 0 || index > d->m_slices.count())
                     return false;
                 if (!slice || d->m_slices.contains(slice))
                     return false;
                 slice->setParent(this);
                 d->m_slices.insert(index, slice);
                 d->updateDerivativeData();
                 connect(slice, SIGNAL(changed()), d, SLOT(sliceChanged()));
                 connect(slice, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                 connect(slice, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                 emit d->added(QList<QPieSlice*>() << slice);
                 return true;
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference the pointer after this call.
             */
             bool QPieSeries::remove(QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 if (!d->m_slices.removeOne(slice))
                     return false;
                 d->updateDerivativeData();
                 emit d->removed(QList<QPieSlice*>() << slice);
                 delete slice;
                 slice = 0;
                 return true;
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 Q_D(QPieSeries);
                 if (d->m_slices.count() == 0)
                     return;
                 QList<QPieSlice*> slices = d->m_slices;
                 foreach (QPieSlice* s, d->m_slices) {
                     d->m_slices.removeOne(s);
                     delete s;
                 }
                 d->updateDerivativeData();
                 emit d->removed(slices);
             }
             /*!
                 returns the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.count();
             }
             /*!
                 Returns true is the series is empty.
             */
             bool QPieSeries::isEmpty() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.isEmpty();
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice*> QPieSeries::slices() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices;
             }
             void QPieSeries::setHorizontalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieRelativeHorPos, relativePosition, 1.0))
                     emit d->piePositionChanged();
             }
             void QPieSeries::setVerticalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieRelativeVerPos, relativePosition, 1.0))
                     emit d->piePositionChanged();
             }
             qreal QPieSeries::horizontalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeHorPos;
             }
             qreal QPieSeries::verticalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeVerPos;
             }
             void QPieSeries::setPieSize(qreal relativeSize)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieRelativeSize, relativeSize, 1.0))
                     emit d->pieSizeChanged();
             }
             qreal QPieSeries::pieSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeSize;
             }
             void QPieSeries::setPieStartAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieStartAngle, angle, d->m_pieEndAngle))
                     d->updateDerivativeData();
             }
             qreal QPieSeries::pieStartAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieStartAngle;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be greater than start angle.
                 \sa pieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             void QPieSeries::setPieEndAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieEndAngle, angle, 360.0, d->m_pieStartAngle))
                     d->updateDerivativeData();
             }
             /*!
                 Returns the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \sa setPieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             qreal QPieSeries::pieEndAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieEndAngle;
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice* s, d->m_slices)
                     s->setLabelVisible(visible);
             }
             /*!
                 Returns the sum of all slice values in this series.
                 \sa QPieSlice::value(), QPieSlice::setValue(), QPieSlice::percentage()
             */
             qreal QPieSeries::sum() const
             {
                 Q_D(const QPieSeries);
                 return d->m_sum;
             }
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice)
                 This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
             /*!
                 \fn void QPieSeries::hovered(QPieSlice* slice, bool state)
                 This signal is emitted when user has hovered over or away from the \a slice.
                 \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
                 \sa QPieSlice::hovered()
             */
             /*!
                  \fn bool QPieSeries::setModel(QAbstractItemModel *model)
                  Sets the \a model to be used as a data source
              */
             void QPieSeries::setModel(QAbstractItemModel* model)
             {
                 Q_D(QPieSeries);
                 // 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 signals from the model
                     connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                     connect(d->m_model, SIGNAL(rowsInserted(QModelIndex,int,int)), d, SLOT(modelRowsAdded(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)), d, SLOT(modelRowsRemoved(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), d, SLOT(modelColumnsAdded(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), d, SLOT(modelColumnsRemoved(QModelIndex,int,int)));
                     if (d->m_mapper)
                         d->initializePieFromModel();
                 }
                 else
                 {
                     d->m_model = 0;
                 }
             }
             void QPieSeries::setModelMapper(QPieModelMapper *mapper)
             {
                 Q_D(QPieSeries);
                 // 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(initializePieFromModel()));
                     if (d->m_model)
                         d->initializePieFromModel();
                 } else {
                     d->m_mapper = 0;
                 }
             }
             QPieModelMapper* QPieSeries::modelMapper() const
             {
                 Q_D(const QPieSeries);
                 return d->m_mapper;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPieSeriesPrivate::QPieSeriesPrivate(QPieSeries *parent) :
                 QAbstractSeriesPrivate(parent),
                 m_pieRelativeHorPos(0.5),
                 m_pieRelativeVerPos(0.5),
                 m_pieRelativeSize(0.7),
                 m_pieStartAngle(0),
                 m_pieEndAngle(360),
                 m_sum(0),
                 m_mapper(0)
             {
             }
             QPieSeriesPrivate::~QPieSeriesPrivate()
             {
             }
             void QPieSeriesPrivate::updateDerivativeData()
             {
                 m_sum = 0;
                 // nothing to do?
                 if (m_slices.count() == 0)
                     return;
                 // calculate sum of all slices
                 foreach (QPieSlice* s, m_slices)
                     m_sum += s->value();
                 // nothing to show..
                 if (qFuzzyIsNull(m_sum))
                     return;
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
                 QVector<QPieSlice*> changed;
                 foreach (QPieSlice* s, m_slices) {
                     PieSliceData data = PieSliceData::data(s);
                     data.m_percentage = s->value() / m_sum;
                     data.m_angleSpan = pieSpan * data.m_percentage;
                     data.m_startAngle = sliceAngle;
                     sliceAngle += data.m_angleSpan;
                     if (PieSliceData::data(s) != data) {
                         PieSliceData::data(s) = data;
                         changed << s;
                     }
                 }
                 // emit signals
                 foreach (QPieSlice* s, changed)
                     PieSliceData::data(s).emitChangedSignal(s);
             }
             QPieSeriesPrivate* QPieSeriesPrivate::seriesData(QPieSeries &series)
             {
                 return series.d_func();
             }
             void QPieSeriesPrivate::sliceChanged()
             {
                 Q_ASSERT(m_slices.contains(qobject_cast<QPieSlice *>(sender())));
                 updateDerivativeData();
             }
             void QPieSeriesPrivate::sliceClicked()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->clicked(slice);
             }
             void QPieSeriesPrivate::sliceHovered(bool state)
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->hovered(slice, state);
             }
             void QPieSeriesPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 if (m_mapper) {
                     for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
                         for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
                             if (m_mapper->orientation() == Qt::Vertical)
                             {
                                 if ( topLeft.row() >= m_mapper->first() && (m_mapper->count() == - 1 || topLeft.row() < m_mapper->first() + m_mapper->count())) {
                                     if (topLeft.column() == m_mapper->mapValues())
                                         m_slices.at(topLeft.row() - m_mapper->first())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                                     if (topLeft.column() == m_mapper->mapLabels())
                                         m_slices.at(topLeft.row() - m_mapper->first())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                                 }
                             }
                             else
                             {
                                 if (topLeft.column() >= m_mapper->first() && (m_mapper->count() == - 1 || topLeft.column() < m_mapper->first() + m_mapper->count())) {
                                     if (topLeft.row() == m_mapper->mapValues())
                                         m_slices.at(topLeft.column() - m_mapper->first())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                                     if (topLeft.row() == m_mapper->mapLabels())
                                         m_slices.at(topLeft.column() - m_mapper->first())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                                 }
                             }
                         }
                     }
                 }
             }
             void QPieSeriesPrivate::modelRowsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_mapper) {
                     if (m_mapper->orientation() == Qt::Vertical)
                         insertData(start, end);
                     else if (start <= m_mapper->mapValues() || start <= m_mapper->mapLabels()) // if the changes affect the map - reinitialize the pie
                         initializePieFromModel();
                 }
             }
             void QPieSeriesPrivate::modelRowsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_mapper) {
                     if (m_mapper->orientation() == Qt::Vertical)
                         removeData(start, end);
                     else if (start <= m_mapper->mapValues() || start <= m_mapper->mapLabels()) // if the changes affect the map - reinitialize the pie
                         initializePieFromModel();
                 }
             }
             void QPieSeriesPrivate::modelColumnsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_mapper) {
                     if (m_mapper->orientation() == Qt::Horizontal)
                         insertData(start, end);
                     else if (start <= m_mapper->mapValues() || start <= m_mapper->mapLabels()) // if the changes affect the map - reinitialize the pie
                         initializePieFromModel();
                 }
             }
             void QPieSeriesPrivate::modelColumnsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_mapper) {
                     if (m_mapper->orientation() == Qt::Horizontal)
                         removeData(start, end);
                     else if (start <= m_mapper->mapValues() || start <= m_mapper->mapLabels()) // if the changes affect the map - reinitialize the pie
                         initializePieFromModel();
                 }
             }
             void QPieSeriesPrivate::insertData(int start, int end)
             {
                 Q_Q(QPieSeries);
                 if (m_mapper) {
                     if (m_mapper->count() != -1 && start >= m_mapper->first() + m_mapper->count()) {
                         return;
                     } else {
                         int addedCount = end - start + 1;
                         if (m_mapper->count() != -1 && addedCount > m_mapper->count())
                             addedCount = m_mapper->count();
                         int first = qMax(start, m_mapper->first());
                         int last = qMin(first + addedCount - 1, m_mapper->orientation() == Qt::Vertical ? m_model->rowCount() - 1 : m_model->columnCount() - 1);
                         for (int i = first; i <= last; i++) {
                             QPieSlice *slice = new QPieSlice;
                             if (m_mapper->orientation() == Qt::Vertical) {
                                 slice->setValue(m_model->data(m_model->index(i, m_mapper->mapValues()), Qt::DisplayRole).toDouble());
                                 slice->setLabel(m_model->data(m_model->index(i, m_mapper->mapLabels()), Qt::DisplayRole).toString());
                             } else {
                                 slice->setValue(m_model->data(m_model->index(m_mapper->mapValues(), i), Qt::DisplayRole).toDouble());
                                 slice->setLabel(m_model->data(m_model->index(m_mapper->mapLabels(), i), Qt::DisplayRole).toString());
                             }
                             slice->setLabelVisible();
                             q->insert(i - m_mapper->first(), slice);
                         }
                         if (m_mapper->count() != -1 && m_slices.size() > m_mapper->count())
                             for (int i = m_slices.size() - 1; i >= m_mapper->count(); i--)
                                 q->remove(q->slices().at(i));
                     }
                 }
             }
             void QPieSeriesPrivate::removeData(int start, int end)
             {
                 Q_Q(QPieSeries);
                 if (m_mapper) {
                     int removedCount = end - start + 1;
                     if (m_mapper->count() != -1 && start >= m_mapper->first() + m_mapper->count()) {
                         return;
                     } else {
                         int toRemove = qMin(m_slices.size(), removedCount);     // first find how many items can actually be removed
                         int first = qMax(start, m_mapper->first());    // get the index of the first item that will be removed.
                         int last = qMin(first + toRemove - 1, m_slices.size() + m_mapper->first() - 1);    // get the index of the last item that will be removed.
                         for (int i = last; i >= first; i--)
                             q->remove(q->slices().at(i - m_mapper->first()));
                         if (m_mapper->count() != -1) {
                             int itemsAvailable;     // check how many are available to be added
                             if (m_mapper->orientation() == Qt::Vertical)
                                 itemsAvailable = m_model->rowCount() - m_mapper->first() - m_slices.size();
                             else
                                 itemsAvailable = m_model->columnCount() - m_mapper->first() - m_slices.size();
                             int toBeAdded = qMin(itemsAvailable, m_mapper->count() - m_slices.size());     // add not more items than there is space left to be filled.
                             int currentSize = m_slices.size();
                             if (toBeAdded > 0)
                                 for (int i = m_slices.size(); i < currentSize + toBeAdded; i++) {
                                     QPieSlice *slice = new QPieSlice;
                                     if (m_mapper->orientation() == Qt::Vertical) {
                                         slice->setValue(m_model->data(m_model->index(i + m_mapper->first(), m_mapper->mapValues()), Qt::DisplayRole).toDouble());
                                         slice->setLabel(m_model->data(m_model->index(i + m_mapper->first(), m_mapper->mapLabels()), Qt::DisplayRole).toString());
                                     } else {
                                         slice->setValue(m_model->data(m_model->index(m_mapper->mapValues(), i + m_mapper->first()), Qt::DisplayRole).toDouble());
                                         slice->setLabel(m_model->data(m_model->index(m_mapper->mapLabels(), i + m_mapper->first()), Qt::DisplayRole).toString());
                                     }
                                     slice->setLabelVisible();
                                     q->insert(i, slice);
                                 }
                         }
                     }
                 }
             }
             void QPieSeriesPrivate::initializePieFromModel()
             {
                 Q_Q(QPieSeries);
                 // clear current content
                 q->clear();
                 if (m_model == 0 || m_mapper == 0)
                     return;
                 // check if mappings are set
                 if (m_mapper->mapValues() == -1 || m_mapper->mapLabels() == -1)
                     return;
                 // create the initial slices set
                 if (m_mapper->orientation() == Qt::Vertical) {
                     if (m_mapper->mapValues() >= m_model->columnCount() || m_mapper->mapLabels() >= m_model->columnCount())
                         return;   // mapped columns are not existing
                     int sliceCount = 0;
                     if(m_mapper->count() == -1)
                         sliceCount = m_model->rowCount() - m_mapper->first();
                     else
                         sliceCount = qMin(m_mapper->count(), m_model->rowCount() - m_mapper->first());
                     for (int i = m_mapper->first(); i < m_mapper->first() + sliceCount; i++)
-                        q->append(m_model->data(m_model->index(i, m_mapper->mapValues()), Qt::DisplayRole).toDouble(), m_model->data(m_model->index(i, m_mapper->mapLabels()), Qt::DisplayRole).toString());
+                        q->append(m_model->data(m_model->index(i, m_mapper->mapLabels()), Qt::DisplayRole).toString(), m_model->data(m_model->index(i, m_mapper->mapValues()), Qt::DisplayRole).toDouble());
                 } else {
                     if (m_mapper->mapValues() >= m_model->rowCount() || m_mapper->mapLabels() >= m_model->rowCount())
                         return;   // mapped columns are not existing
                     int sliceCount = 0;
                     if(m_mapper->count() == -1)
                         sliceCount = m_model->columnCount() - m_mapper->first();
                     else
                         sliceCount = qMin(m_mapper->count(), m_model->columnCount() - m_mapper->first());
                     for (int i = m_mapper->first(); i < m_mapper->first() + sliceCount; i++)
-                        q->append(m_model->data(m_model->index(m_mapper->mapValues(), i), Qt::DisplayRole).toDouble(), m_model->data(m_model->index(m_mapper->mapLabels(), i), Qt::DisplayRole).toString());
+                        q->append(m_model->data(m_model->index(m_mapper->mapLabels(), i), Qt::DisplayRole).toString(), m_model->data(m_model->index(m_mapper->mapValues(), i), Qt::DisplayRole).toDouble());
                 }
                 q->setLabelsVisible(true);
             }
             bool QPieSeriesPrivate::setRealValue(qreal &value, qreal newValue, qreal max, qreal min)
             {
                 // Remove rounding errors
                 qreal roundedValue = newValue;
                 if (qFuzzyIsNull(min) && qFuzzyIsNull(newValue))
                     roundedValue = 0.0;
                 else if (qFuzzyCompare(newValue, max))
                     roundedValue = max;
                 else if (qFuzzyCompare(newValue, min))
                     roundedValue = min;
                 // Check if the position is valid after removing the rounding errors
                 if (roundedValue < min || roundedValue > max) {
                     qWarning("QPieSeries: Illegal value");
                     return false;
                 }
                 if (!qFuzzyIsNull(value - roundedValue)) {
                     value = roundedValue;
                     return true;
                 }
                 // The change was so small it is considered a rounding error
                 return false;
             }
             void QPieSeriesPrivate::scaleDomain(Domain& domain)
             {
                 Q_UNUSED(domain);
                 // does not apply to pie
             }
             Chart* QPieSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QPieSeries);
                 PieChartItem* pie = new PieChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(pie);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return pie;
             }
             QList<LegendMarker*> QPieSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QPieSeries);
                 QList<LegendMarker*> markers;
                 foreach(QPieSlice* slice, q->slices()) {
                     PieLegendMarker* marker = new PieLegendMarker(q,slice,legend);
                     markers << marker;
                 }
                 return markers;
             }
             #include "moc_qpieseries.cpp"
             #include "moc_qpieseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.h +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$
             **
             ****************************************************************************/
             #ifndef PIESERIES_H
             #define PIESERIES_H
             #include <qabstractseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSeriesPrivate;
             class QPieSlice;
             class QPieModelMapper;
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QAbstractSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(qreal horizontalPosition READ horizontalPosition WRITE setHorizontalPosition)
                 Q_PROPERTY(qreal verticalPosition READ verticalPosition WRITE setVerticalPosition)
                 Q_PROPERTY(qreal size READ pieSize WRITE setPieSize)
                 Q_PROPERTY(qreal startAngle READ pieStartAngle WRITE setPieStartAngle)
                 Q_PROPERTY(qreal endAngle READ pieEndAngle WRITE setPieEndAngle)
                 Q_PROPERTY(int count READ count)
                 Q_PROPERTY(QPieModelMapper *modelMapper READ modelMapper)
             public:
                 explicit QPieSeries(QObject *parent = 0);
                 virtual ~QPieSeries();
                 QAbstractSeries::SeriesType type() const;
                 bool append(QPieSlice* slice);
                 bool append(QList<QPieSlice*> slices);
                 QPieSeries& operator << (QPieSlice* slice);
-                QPieSlice* append(qreal value, QString name);
+                QPieSlice* append(QString label, qreal value);
                 bool insert(int index, QPieSlice* slice);
                 bool remove(QPieSlice* slice);
                 void clear();
                 QList<QPieSlice*> slices() const;
                 int count() const;
                 bool isEmpty() const;
                 qreal sum() const;
                 void setHorizontalPosition(qreal relativePosition);
                 qreal horizontalPosition() const;
                 void setVerticalPosition(qreal relativePosition);
                 qreal verticalPosition() const;
                 void setPieSize(qreal relativeSize);
                 qreal pieSize() const;
                 void setPieStartAngle(qreal startAngle);
                 qreal pieStartAngle() const;
                 void setPieEndAngle(qreal endAngle);
                 qreal pieEndAngle() const;
                 void setLabelsVisible(bool visible = true);
                 void setModel(QAbstractItemModel* model);
                 void setModelMapper(QPieModelMapper *mapper);
                 QPieModelMapper* modelMapper() const;
             Q_SIGNALS:
                 void clicked(QPieSlice* slice);
                 void hovered(QPieSlice* slice, bool state);
             private:
                 Q_DECLARE_PRIVATE(QPieSeries)
                 Q_DISABLE_COPY(QPieSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

src/piechart/qpieslice.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 "qpieslice.h"
             #include "pieslicedata_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSlice
                 \brief Defines a slice in pie series.
                 This object defines the properties of a single slice in a QPieSeries.
                 In addition to the obvious value and label properties the user can also control
                 the visual appearance of a slice. By modifying the visual appearance also means that
                 the user is overriding the default appearance set by the theme. Even if the theme is
                 changed users settings will persist.
                 To enable user interaction customization with the slices some basic signals
                 are provided about clicking and hovering.
             */
             /*!
                 \property QPieSlice::label
                 Label of the slice.
             */
             /*!
                 \property QPieSlice::value
                 Value of the slice.
                 \sa percentage(), QPieSeries::sum()
             */
             /*!
                 Constructs an empty slice with a \a parent.
                 \sa QPieSeries::append(), QPieSeries::insert()
             */
             QPieSlice::QPieSlice(QObject *parent)
                 :QObject(parent),
                 d(new PieSliceData())
             {
             }
             /*!
                 Constructs an empty slice with given \a value, \a label and a \a parent.
                 \sa QPieSeries::append(), QPieSeries::insert()
             */
-            QPieSlice::QPieSlice(qreal value, QString label, QObject *parent)
+            QPieSlice::QPieSlice(QString label, qreal value, QObject *parent)
                 :QObject(parent),
                 d(new PieSliceData())
             {
                 d->m_value = value;
                 d->m_labelText = label;
             }
             /*!
                 Destroys the slice.
                 User should not delete the slice if it has been added to the series.
             */
             QPieSlice::~QPieSlice()
             {
                 delete d;
             }
             /*!
                 Gets the value of the slice.
                 Note that all values in the series
                 \sa setValue()
             */
             qreal QPieSlice::value() const
             {
                 return d->m_value;
             }
             /*!
                 Gets the label of the slice.
                 \sa setLabel()
             */
             QString QPieSlice::label() const
             {
                 return d->m_labelText;
             }
             /*!
                 Returns true if label is set as visible.
                 \sa setLabelVisible()
             */
             bool QPieSlice::isLabelVisible() const
             {
                 return d->m_isLabelVisible;
             }
             /*!
                 Returns true if slice is exloded from the pie.
                 \sa setExploded(), explodeDistanceFactor(), setExplodeDistanceFactor()
             */
             bool QPieSlice::isExploded() const
             {
                 return d->m_isExploded;
             }
             /*!
                 Returns the explode distance factor.
                 The factor is relative to pie radius. For example:
 .0 means the distance is the same as the radius.
 .5 means the distance is half of the radius.
                 Default value is 0.15.
                 \sa setExplodeDistanceFactor(), isExploded(), setExploded()
             */
             qreal QPieSlice::explodeDistanceFactor() const
             {
                 return d->m_explodeDistanceFactor;
             }
             /*!
                 Returns the percentage of this slice compared to the sum of all slices in the same series.
                 The returned value ranges from 0 to 1.0.
                 Updated internally after the slice is added to the series.
                 \sa QPieSeries::sum()
             */
             qreal QPieSlice::percentage() const
             {
                 return d->m_percentage;
             }
             /*!
                 Returns the starting angle of this slice in the series it belongs to.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated internally after the slice is added to the series.
             */
             qreal QPieSlice::startAngle() const
             {
                 return d->m_startAngle;
             }
             /*!
                 Returns the end angle of this slice in the series it belongs to.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated internally after the slice is added to the series.
             */
             qreal QPieSlice::endAngle() const
             {
                 return d->m_startAngle + d->m_angleSpan;
             }
             /*!
                 Returns the pen used to draw this slice.
                 \sa setPen()
             */
             QPen QPieSlice::pen() const
             {
                 return d->m_slicePen;
             }
             /*!
                 Returns the brush used to draw this slice.
                 \sa setBrush()
             */
             QBrush QPieSlice::brush() const
             {
                 return d->m_sliceBrush;
             }
             /*!
                 Returns the pen used to draw the label in this slice.
                 \sa setLabelPen()
             */
             QPen QPieSlice::labelPen() const
             {
                 return d->m_labelPen;
             }
             /*!
                 Returns the font used to draw label in this slice.
                 \sa setLabelFont()
             */
             QFont QPieSlice::labelFont() const
             {
                 return d->m_labelFont;
             }
             /*!
                 Gets the label arm length factor.
                 The factor is relative to pie radius. For example:
 .0 means the length is the same as the radius.
 .5 means the length is half of the radius.
                 Default value is 0.15
                 \sa setLabelArmLengthFactor()
             */
             qreal QPieSlice::labelArmLengthFactor() const
             {
                 return d->m_labelArmLengthFactor;
             }
             /*!
                 \fn void QPieSlice::clicked()
                 This signal is emitted when user has clicked the slice.
                 \sa QPieSeries::clicked()
             */
             /*!
                 \fn void QPieSlice::hovered(bool state)
                 This signal is emitted when user has hovered over or away from the slice.
                 \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
                 \sa QPieSeries::hovered()
             */
             /*!
                 \fn void QPieSlice::changed()
                 This signal emitted when something has changed in the slice.
             */
             /*!
                 Sets the \a value of this slice.
                 \sa value()
             */
             void QPieSlice::setValue(qreal value)
             {
                 if (!qFuzzyIsNull(d->m_value - value)) {
                     d->m_value = value;
                     emit changed();
                 }
             }
             /*!
                 Sets the \a label of the slice.
                 \sa label()
             */
             void QPieSlice::setLabel(QString label)
             {
                 if (d->m_labelText != label) {
                     d->m_labelText = label;
                     emit changed();
                 }
             }
             /*!
                 Sets the label \a visible in this slice.
                 \sa isLabelVisible(), QPieSeries::setLabelsVisible()
             */
             void QPieSlice::setLabelVisible(bool visible)
             {
                 if (d->m_isLabelVisible != visible) {
                     d->m_isLabelVisible = visible;
                     emit changed();
                 }
             }
             /*!
                 Sets this slices \a exploded state.
                 If the slice is exploded it is moved away from the pie center. The distance is defined by the explode distance factor.
                 \sa isExploded(), explodeDistanceFactor(), setExplodeDistanceFactor()
             */
             void QPieSlice::setExploded(bool exploded)
             {
                 if (d->m_isExploded != exploded) {
                     d->m_isExploded = exploded;
                     emit changed();
                 }
             }
             /*!
                 Sets the explode distance \a factor.
                 The factor is relative to pie radius. For example:
 .0 means the distance is the same as the radius.
 .5 means the distance is half of the radius.
                 Default value is 0.15
                 \sa explodeDistanceFactor(), isExploded(), setExploded()
             */
             void QPieSlice::setExplodeDistanceFactor(qreal factor)
             {
                 if (!qFuzzyIsNull(d->m_explodeDistanceFactor - factor)) {
                     d->m_explodeDistanceFactor = factor;
                     emit changed();
                 }
             }
             /*!
                 Sets the \a pen used to draw this slice.
                 Overrides the pen set by the theme.
                 \sa pen()
             */
             void QPieSlice::setPen(const QPen &pen)
             {
                 if (d->m_slicePen != pen) {
                     d->m_slicePen = pen;
                     d->m_slicePen.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the \a brush used to draw this slice.
                 Overrides the brush set by the theme.
                 \sa brush()
             */
             void QPieSlice::setBrush(const QBrush &brush)
             {
                 if (d->m_sliceBrush != brush) {
                     d->m_sliceBrush = brush;
                     d->m_sliceBrush.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the \a pen used to draw the label in this slice.
                 Overrides the pen set by the theme.
                 \sa labelPen()
             */
             void QPieSlice::setLabelPen(const QPen &pen)
             {
                 if (d->m_labelPen != pen) {
                     d->m_labelPen = pen;
                     d->m_labelPen.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the \a font used to draw the label in this slice.
                 Overrides the font set by the theme.
                 \sa labelFont()
             */
             void QPieSlice::setLabelFont(const QFont &font)
             {
                 if (d->m_labelFont != font) {
                     d->m_labelFont = font;
                     d->m_labelFont.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the label arm length \a factor.
                 The factor is relative to pie radius. For example:
 .0 means the length is the same as the radius.
 .5 means the length is half of the radius.
                 Default value is 0.15
                 \sa labelArmLengthFactor()
             */
             void QPieSlice::setLabelArmLengthFactor(qreal factor)
             {
                 if (!qFuzzyIsNull(d->m_labelArmLengthFactor - factor)) {
                     d->m_labelArmLengthFactor = factor;
                     emit changed();
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             #include "moc_qpieslice.cpp"

src/piechart/qpieslice.h +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$
             **
             ****************************************************************************/
             #ifndef QPIESLICE_H
             #define QPIESLICE_H
             #include <qchartglobal.h>
             #include <QObject>
             #include <QPen>
             #include <QBrush>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieSliceData;
             class QTCOMMERCIALCHART_EXPORT QPieSlice : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QString label READ label WRITE setLabel)
                 Q_PROPERTY(qreal value READ value WRITE setValue)
                 Q_PROPERTY(bool exploded READ isExploded WRITE setExploded)
             public:
                 explicit QPieSlice(QObject *parent = 0);
-                QPieSlice(qreal value, QString label, QObject *parent = 0);
+                QPieSlice(QString label, qreal value, QObject *parent = 0);
                 virtual ~QPieSlice();
                 void setValue(qreal value);
                 qreal value() const;
                 void setLabel(QString label);
                 QString label() const;
                 void setLabelVisible(bool visible = true);
                 bool isLabelVisible() const;
                 void setExploded(bool exploded = true);
                 bool isExploded() const;
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setLabelPen(const QPen &pen);
                 QPen labelPen() const;
                 void setLabelFont(const QFont &font);
                 QFont labelFont() const;
                 void setLabelArmLengthFactor(qreal factor);
                 qreal labelArmLengthFactor() const;
                 void setExplodeDistanceFactor(qreal factor);
                 qreal explodeDistanceFactor() const;
                 qreal percentage() const;
                 qreal startAngle() const;
                 qreal endAngle() const;
             Q_SIGNALS:
                 void clicked();
                 void hovered(bool state);
                 void changed();
             private:
                 friend class PieSliceData;
                 PieSliceData * const d;
                 Q_DISABLE_COPY(QPieSlice)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIESLICE_H

tests/auto/qpieseries/tst_qpieseries.cpp +22 -22

             /****************************************************************************
             **
             ** 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 <qchartview.h>
             #include <qchart.h>
             #include <qpieseries.h>
             #include <qpieslice.h>
             #include <qpiemodelmapper.h>
             #include <QStandardItemModel>
             #include <tst_definitions.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QPieSlice*)
             class tst_qpieseries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void construction();
                 void append();
                 void insert();
                 void remove();
                 void calculatedValues();
                 void clickedSignal();
                 void hoverSignal();
                 void model();
                 void modelCustomMap();
                 void modelUpdate();
             private:
                 void verifyCalculatedData(const QPieSeries &series, bool *ok);
             private:
             };
             void tst_qpieseries::initTestCase()
             {
                 qRegisterMetaType<QPieSlice*>("QPieSlice*");
             }
             void tst_qpieseries::cleanupTestCase()
             {
             }
             void tst_qpieseries::init()
             {
             }
             void tst_qpieseries::cleanup()
             {
             }
             void tst_qpieseries::construction()
             {
                 // verify default values
                 QPieSeries s;
                 QVERIFY(s.type() == QAbstractSeries::SeriesTypePie);
                 QVERIFY(s.count() == 0);
                 QVERIFY(s.isEmpty());
                 QCOMPARE(s.sum(), 0.0);
                 QCOMPARE(s.horizontalPosition(), 0.5);
                 QCOMPARE(s.verticalPosition(), 0.5);
                 QCOMPARE(s.pieSize(), 0.7);
                 QCOMPARE(s.pieStartAngle(), 0.0);
                 QCOMPARE(s.pieEndAngle(), 360.0);
             }
             void tst_qpieseries::append()
             {
                 QPieSeries s;
                 // append pointer
                 QPieSlice *slice1 = 0;
                 QVERIFY(!s.append(slice1));
-                slice1 = new QPieSlice(1, "slice 1");
+                slice1 = new QPieSlice("slice 1", 1);
                 QVERIFY(s.append(slice1));
                 QVERIFY(!s.append(slice1));
                 QCOMPARE(s.count(), 1);
                 // append pointer list
                 QList<QPieSlice *> list;
                 QVERIFY(!s.append(list));
                 list << (QPieSlice *) 0;
                 QVERIFY(!s.append(list));
                 list.clear();
-                list << new QPieSlice(2, "slice 2");
+                list << new QPieSlice("slice 2", 2);
-                list << new QPieSlice(3, "slice 3");
+                list << new QPieSlice("slice 3", 3);
                 QVERIFY(s.append(list));
                 QVERIFY(!s.append(list));
                 QCOMPARE(s.count(), 3);
                 // append operator
-                s << new QPieSlice(4, "slice 4");
+                s << new QPieSlice("slice 4", 4);
                 s << slice1; // fails because already added
                 QCOMPARE(s.count(), 4);
                 // append with params
-                QPieSlice *slice5 = s.append(5, "slice 5");
+                QPieSlice *slice5 = s.append("slice 5", 5);
                 QVERIFY(slice5 != 0);
                 QCOMPARE(slice5->value(), 5.0);
                 QCOMPARE(slice5->label(), QString("slice 5"));
                 QCOMPARE(s.count(), 5);
                 // check slices
                 QVERIFY(!s.isEmpty());
                 for (int i=0; i<s.count(); i++) {
                     QCOMPARE(s.slices().at(i)->value(), (qreal) i+1);
                     QCOMPARE(s.slices().at(i)->label(), QString("slice ") + QString::number(i+1));
                 }
             }
             void tst_qpieseries::insert()
             {
                 QPieSeries s;
                 // insert one slice
                 QPieSlice *slice1 = 0;
                 QVERIFY(!s.insert(0, slice1));
-                slice1 = new QPieSlice(1, "slice 1");
+                slice1 = new QPieSlice("slice 1", 1);
                 QVERIFY(!s.insert(-1, slice1));
                 QVERIFY(!s.insert(5, slice1));
                 QVERIFY(s.insert(0, slice1));
                 QVERIFY(!s.insert(0, slice1));
                 QCOMPARE(s.count(), 1);
                 // add some more slices
-                s.append(2, "slice 2");
+                s.append("slice 2", 2);
-                s.append(4, "slice 4");
+                s.append("slice 4", 4);
                 QCOMPARE(s.count(), 3);
                 // insert between slices
-                s.insert(2, new QPieSlice(3, "slice 3"));
+                s.insert(2, new QPieSlice("slice 3", 3));
                 QCOMPARE(s.count(), 4);
                 // check slices
                 for (int i=0; i<s.count(); i++) {
                     QCOMPARE(s.slices().at(i)->value(), (qreal) i+1);
                     QCOMPARE(s.slices().at(i)->label(), QString("slice ") + QString::number(i+1));
                 }
             }
             void tst_qpieseries::remove()
             {
                 QPieSeries s;
                 // add some slices
-                QPieSlice *slice1 = s.append(1, "slice 1");
+                QPieSlice *slice1 = s.append("slice 1", 1);
-                QPieSlice *slice2 = s.append(2, "slice 2");
+                QPieSlice *slice2 = s.append("slice 2", 2);
-                QPieSlice *slice3 = s.append(3, "slice 3");
+                QPieSlice *slice3 = s.append("slice 3", 3);
                 QSignalSpy spy1(slice1, SIGNAL(destroyed()));
                 QSignalSpy spy2(slice2, SIGNAL(destroyed()));
                 QSignalSpy spy3(slice3, SIGNAL(destroyed()));
                 QCOMPARE(s.count(), 3);
                 // null pointer remove
                 QVERIFY(!s.remove(0));
                 // remove first
                 QVERIFY(s.remove(slice1));
                 QVERIFY(!s.remove(slice1));
                 QCOMPARE(s.count(), 2);
                 QCOMPARE(s.slices().at(0)->label(), slice2->label());
                 // remove all
                 s.clear();
                 QVERIFY(s.isEmpty());
                 QVERIFY(s.slices().isEmpty());
                 QCOMPARE(s.count(), 0);
                 // check that slices were actually destroyed
                 TRY_COMPARE(spy1.count(), 1);
                 TRY_COMPARE(spy2.count(), 1);
                 TRY_COMPARE(spy3.count(), 1);
             }
             void tst_qpieseries::calculatedValues()
             {
                 bool ok;
                 QPieSeries s;
                 // add a slice
-                QPieSlice *slice1 = s.append(1, "slice 1");
+                QPieSlice *slice1 = s.append("slice 1", 1);
                 verifyCalculatedData(s, &ok);
                 if (!ok)
                     return;
                 // add some more slices
                 QList<QPieSlice *> list;
-                list << new QPieSlice(2, "slice 2");
+                list << new QPieSlice("slice 2", 2);
-                list << new QPieSlice(3, "slice 3");
+                list << new QPieSlice("slice 3", 3);
                 s.append(list);
                 verifyCalculatedData(s, &ok);
                 if (!ok)
                     return;
                 // remove a slice
                 s.remove(slice1);
                 verifyCalculatedData(s, &ok);
                 if (!ok)
                     return;
                 // insert a slice
-                s.insert(0, new QPieSlice(1, "Slice 4"));
+                s.insert(0, new QPieSlice("Slice 4", 4));
                 verifyCalculatedData(s, &ok);
                 if (!ok)
                     return;
                 // clear all
                 s.clear();
                 verifyCalculatedData(s, &ok);
             }
             void tst_qpieseries::verifyCalculatedData(const QPieSeries &series, bool *ok)
             {
                 *ok = false;
                 qreal sum = 0;
                 foreach (const QPieSlice *slice, series.slices())
                     sum += slice->value();
                 QCOMPARE(series.sum(), sum);
                 qreal startAngle = series.pieStartAngle();
                 qreal pieAngleSpan = series.pieEndAngle() - series.pieStartAngle();
                 foreach (const QPieSlice *slice, series.slices()) {
                     qreal ratio = slice->value() / sum;
                     qreal sliceSpan = pieAngleSpan * ratio;
                     QCOMPARE(slice->startAngle(), startAngle);
                     QCOMPARE(slice->endAngle(), startAngle + sliceSpan);
                     QCOMPARE(slice->percentage(), ratio);
                     startAngle += sliceSpan;
                 }
                 if (!series.isEmpty())
                     QCOMPARE(series.slices().last()->endAngle(), series.pieEndAngle());
                 *ok = true;
             }
             void tst_qpieseries::clickedSignal()
             {
                 // create a pie series
                 QPieSeries *series = new QPieSeries();
                 series->setPieSize(1.0);
-                QPieSlice *s1 = series->append(1, "slice 1");
+                QPieSlice *s1 = series->append("slice 1", 1);
-                series->append(2, "slice 2");
+                series->append("slice 2", 2);
-                series->append(3, "slice 3");
+                series->append("slice 3", 3);
                 QSignalSpy clickSpy1(series, SIGNAL(clicked(QPieSlice*)));
                 // add series to the chart
                 QChartView view(new QChart());
                 view.chart()->legend()->setVisible(false);
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // simulate clicks
                 // pie rectangle: QRectF(60,60 121x121)
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(146, 90)); // inside slice 1
                 TRY_COMPARE(clickSpy1.count(), 1);
                 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy1.at(0).at(0)), s1);
             }
             void tst_qpieseries::hoverSignal()
             {
                 // create a pie series
                 QPieSeries *series = new QPieSeries();
                 series->setPieSize(1.0);
-                QPieSlice *s1 = series->append(1, "slice 1");
+                QPieSlice *s1 = series->append("slice 1", 1);
-                series->append(2, "slice 2");
+                series->append("slice 2", 2);
-                series->append(3, "slice 3");
+                series->append("slice 3", 3);
                 // add series to the chart
                 QChartView view(new QChart());
                 view.chart()->legend()->setVisible(false);
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // first move to right top corner
                 QTest::mouseMove(view.viewport(), QPoint(200, 0));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 // move inside the slice
                 // pie rectangle: QRectF(60,60 121x121)
                 QSignalSpy hoverSpy(series, SIGNAL(hovered(QPieSlice*,bool)));
                 QTest::mouseMove(view.viewport(), QPoint(139, 85));
                 TRY_COMPARE(hoverSpy.count(), 1);
                 QCOMPARE(qvariant_cast<QPieSlice*>(hoverSpy.at(0).at(0)), s1);
                 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(0).at(1)), true);
                 // move outside the slice
                 QTest::mouseMove(view.viewport(), QPoint(200, 0));
                 TRY_COMPARE(hoverSpy.count(), 2);
                 QCOMPARE(qvariant_cast<QPieSlice*>(hoverSpy.at(1).at(0)), s1);
                 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(1).at(1)), false);
             }
             void tst_qpieseries::model()
             {
                 QSKIP("Needs to be checked again. Model implementation changed", SkipAll);
                 QPieSeries *series = new QPieSeries;
                 QChart *chart = new QChart;
                 chart->addSeries(series);
                 QChartView *chartView = new QChartView(chart);
                 chartView->show();
                 QStandardItemModel *stdModel = new QStandardItemModel(0, 2);
                 series->setModel(stdModel);
                 int rowCount = 3;
                 for (int row = 0; row < rowCount; ++row) {
                     for (int column = 0; column < 2; 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->slices().count() == 0, "Mapper has not been set, so the number of slices should be 0");
                 // set the mapper
                 QPieModelMapper *mapper = series->modelMapper();//new QPieModelMapper;
                 mapper->setMapValues(0);
                 mapper->setMapLabels(0);
             //    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->slices().count(), rowCount);
                 // set the mappings to be outside of the model
                 mapper->setMapLabels(5);
                 mapper->setMapValues(4);
                 QCOMPARE(series->slices().count(), 0); // Mappings are invalid, so the number of slices should be 0
                 // set back to correct ones
                 mapper->setMapValues(0);
                 mapper->setMapLabels(0);
                 QCOMPARE(series->slices().count(), rowCount);
                 // reset the mappings
                 mapper->reset();
                 QCOMPARE(series->slices().count(), 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
             }
             void tst_qpieseries::modelCustomMap()
             {
                 QSKIP("Needs to be checked again. Model implementation changed", SkipAll);
                 int rowCount = 12;
                 int columnCount = 3;
                 QStandardItemModel *stdModel = new QStandardItemModel(0, 3);
                 for (int row = 0; row < rowCount; ++row) {
                     for (int column = 0; column < 2; column++) {
                         QStandardItem *item = new QStandardItem(row * column);
                         stdModel->setItem(row, column, item);
                     }
                 }
                 QPieSeries *series = new QPieSeries;
                 QChart *chart = new QChart;
                 chart->addSeries(series);
                 QChartView *chartView = new QChartView(chart);
                 chartView->show();
                 series->setModel(stdModel);
                 QPieModelMapper *mapper = series->modelMapper();//new QPieModelMapper;
                 mapper->setMapValues(0);
                 mapper->setMapLabels(0);
             //    series->setModelMapper(mapper);
                 QCOMPARE(series->slices().count(), rowCount);
                 // lets change the orientation to horizontal
                 mapper->setOrientation(Qt::Horizontal);
                 QCOMPARE(series->slices().count(), columnCount);
                 // change it back to vertical
                 mapper->setOrientation(Qt::Vertical);
                 QCOMPARE(series->slices().count(), rowCount);
                 // lets customize the mapping
                 int first = 3;
                 mapper->setFirst(first);
                 QCOMPARE(series->slices().count(), rowCount - first);
                 int count = 7;
                 mapper->setCount(count);
                 QCOMPARE(series->slices().count(), count);
                 first = 9;
                 mapper->setFirst(first);
                 QCOMPARE(series->slices().count(), qMin(count, rowCount - first));
             }
             void tst_qpieseries::modelUpdate()
             {
                 QSKIP("Needs to be checked again. Model implementation changed", SkipAll);
                 int rowCount = 12;
                 int columnCount = 7;
                 QStandardItemModel *stdModel = new QStandardItemModel(rowCount, columnCount);
                 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);
                     }
                 }
                 QPieSeries *series = new QPieSeries;
                 QChart *chart = new QChart;
                 chart->addSeries(series);
                 QChartView *chartView = new QChartView(chart);
                 chartView->show();
                 series->setModel(stdModel);
                 QPieModelMapper *mapper = series->modelMapper();//new QPieModelMapper;
                 mapper->setMapValues(0);
                 mapper->setMapLabels(0);
             //    series->setModelMapper(mapper);
                 stdModel->insertRows(3, 5);
                 QCOMPARE(series->slices().count(), rowCount + 5);
                 stdModel->removeRows(10, 5);
                 QCOMPARE(series->slices().count(), rowCount);
                 // limit the number of slices taken from the model to 12
                 mapper->setCount(rowCount);
                 stdModel->insertRows(3, 5);
                 QCOMPARE(series->slices().count(), rowCount);
                 stdModel->removeRows(0, 10);
                 QCOMPARE(series->slices().count(), rowCount - 5);
                 // change the orientation to horizontal
                 mapper->setOrientation(Qt::Horizontal);
                 QCOMPARE(series->slices().count(), columnCount);
                 stdModel->insertColumns(3, 10);
                 QCOMPARE(series->slices().count(), rowCount); // count is limited to rowCount (12)
                 stdModel->removeColumns(5, 10);
                 QCOMPARE(series->slices().count(), columnCount);
             }
             QTEST_MAIN(tst_qpieseries)
             #include "tst_qpieseries.moc"

tests/auto/qpieslice/tst_qpieslice.cpp +12 -12

             /****************************************************************************
             **
             ** 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 <tst_definitions.h>
             #include <qchartview.h>
             #include <qchart.h>
             #include <qpieslice.h>
             #include <qpieseries.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class tst_qpieslice : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void construction();
                 void changedSignals();
                 void customize();
                 void mouseClick();
                 void mouseHover();
             private:
             private:
             };
             void tst_qpieslice::initTestCase()
             {
             }
             void tst_qpieslice::cleanupTestCase()
             {
             }
             void tst_qpieslice::init()
             {
             }
             void tst_qpieslice::cleanup()
             {
             }
             void tst_qpieslice::construction()
             {
                 // no params
                 QPieSlice slice1;
                 QCOMPARE(slice1.value(), 0.0);
                 QVERIFY(slice1.label().isEmpty());
                 QVERIFY(!slice1.isLabelVisible());
                 QVERIFY(!slice1.isExploded());
                 QCOMPARE(slice1.pen(), QPen());
                 QCOMPARE(slice1.brush(), QBrush());
                 QCOMPARE(slice1.labelPen(), QPen());
                 QCOMPARE(slice1.labelFont(), QFont());
                 QCOMPARE(slice1.labelArmLengthFactor(), 0.15); // default value
                 QCOMPARE(slice1.explodeDistanceFactor(), 0.15); // default value
                 QCOMPARE(slice1.percentage(), 0.0);
                 QCOMPARE(slice1.startAngle(), 0.0);
                 QCOMPARE(slice1.endAngle(), 0.0);
                 // value and label params
-                QPieSlice slice2(1.0, "foobar");
+                QPieSlice slice2("foobar", 1.0);
                 QCOMPARE(slice2.value(), 1.0);
                 QCOMPARE(slice2.label(), QString("foobar"));
                 QVERIFY(!slice2.isLabelVisible());
                 QVERIFY(!slice2.isExploded());
                 QCOMPARE(slice2.pen(), QPen());
                 QCOMPARE(slice2.brush(), QBrush());
                 QCOMPARE(slice2.labelPen(), QPen());
                 QCOMPARE(slice2.labelFont(), QFont());
                 QCOMPARE(slice2.labelArmLengthFactor(), 0.15); // default value
                 QCOMPARE(slice2.explodeDistanceFactor(), 0.15); // default value
                 QCOMPARE(slice2.percentage(), 0.0);
                 QCOMPARE(slice2.startAngle(), 0.0);
                 QCOMPARE(slice2.endAngle(), 0.0);
             }
             void tst_qpieslice::changedSignals()
             {
                 // set everything twice to see we do not get unnecessary signals
                 QPieSlice slice;
                 QSignalSpy spy(&slice, SIGNAL(changed())); // TODO: this will be changed to something more refined
                 slice.setValue(1);
                 slice.setValue(1);
                 slice.setLabel("foobar");
                 slice.setLabel("foobar");
                 slice.setLabelVisible();
                 slice.setLabelVisible();
                 slice.setExploded();
                 slice.setExploded();
                 slice.setPen(QPen(Qt::red));
                 slice.setPen(QPen(Qt::red));
                 slice.setBrush(QBrush(Qt::red));
                 slice.setBrush(QBrush(Qt::red));
                 slice.setLabelPen(QPen(Qt::green));
                 slice.setLabelPen(QPen(Qt::green));
                 slice.setLabelFont(QFont("Tahoma"));
                 slice.setLabelFont(QFont("Tahoma"));
                 slice.setLabelArmLengthFactor(0.1);
                 slice.setLabelArmLengthFactor(0.1);
                 slice.setExplodeDistanceFactor(0.1);
                 slice.setExplodeDistanceFactor(0.1);
                 TRY_COMPARE(spy.count(), 10);
             }
             void tst_qpieslice::customize()
             {
                 // create a pie series
                 QPieSeries *series = new QPieSeries();
-                QPieSlice *s1 = series->append(1, "slice 1");
+                QPieSlice *s1 = series->append("slice 1", 1);
-                QPieSlice *s2 = series->append(2, "slice 2");
+                QPieSlice *s2 = series->append("slice 2", 2);
-                series->append(3, "slice 3");
+                series->append("slice 3", 3);
                 // customize a slice
                 QPen p1(Qt::red);
                 s1->setPen(p1);
                 QBrush b1(Qt::red);
                 s1->setBrush(b1);
                 s1->setLabelPen(p1);
                 QFont f1("Consolas");
                 s1->setLabelFont(f1);
                 // add series to the chart
                 QChartView view(new QChart());
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 //QTest::qWait(1000);
                 // check that customizations persist
                 QCOMPARE(s1->pen(), p1);
                 QCOMPARE(s1->brush(), b1);
                 QCOMPARE(s1->labelPen(), p1);
                 QCOMPARE(s1->labelFont(), f1);
                 // remove a slice
                 series->remove(s2);
                 QCOMPARE(s1->pen(), p1);
                 QCOMPARE(s1->brush(), b1);
                 QCOMPARE(s1->labelPen(), p1);
                 QCOMPARE(s1->labelFont(), f1);
                 // add a slice
-                series->append(4, "slice 4");
+                series->append("slice 4", 4);
                 QCOMPARE(s1->pen(), p1);
                 QCOMPARE(s1->brush(), b1);
                 QCOMPARE(s1->labelPen(), p1);
                 QCOMPARE(s1->labelFont(), f1);
                 // insert a slice
-                series->insert(0, new QPieSlice(5, "slice 5"));
+                series->insert(0, new QPieSlice("slice 5", 5));
                 QCOMPARE(s1->pen(), p1);
                 QCOMPARE(s1->brush(), b1);
                 QCOMPARE(s1->labelPen(), p1);
                 QCOMPARE(s1->labelFont(), f1);
                 // change theme
                 // theme will overwrite customizations
                 view.chart()->setTheme(QChart::ChartThemeHighContrast);
                 QVERIFY(s1->pen() != p1);
                 QVERIFY(s1->brush() != b1);
                 QVERIFY(s1->labelPen() != p1);
                 QVERIFY(s1->labelFont() != f1);
             }
             void tst_qpieslice::mouseClick()
             {
                 // create a pie series
                 QPieSeries *series = new QPieSeries();
                 series->setPieSize(1.0);
-                QPieSlice *s1 = series->append(1, "slice 1");
+                QPieSlice *s1 = series->append("slice 1", 1);
-                QPieSlice *s2 = series->append(2, "slice 2");
+                QPieSlice *s2 = series->append("slice 2", 2);
-                QPieSlice *s3 = series->append(3, "slice 3");
+                QPieSlice *s3 = series->append("slice 3", 3);
                 QSignalSpy clickSpy1(s1, SIGNAL(clicked()));
                 QSignalSpy clickSpy2(s2, SIGNAL(clicked()));
                 QSignalSpy clickSpy3(s3, SIGNAL(clicked()));
                 // add series to the chart
                 QChartView view(new QChart());
                 view.chart()->legend()->setVisible(false);
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // simulate clicks
                 // pie rectangle: QRectF(60,60 121x121)
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(139, 85)); // inside slice 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(146, 136)); // inside slice 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(91, 119)); // inside slice 3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(70, 70)); // inside pie rectangle but not inside a slice
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(170, 170)); // inside pie rectangle but not inside a slice
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(clickSpy1.count(), 1);
                 QCOMPARE(clickSpy2.count(), 1);
                 QCOMPARE(clickSpy3.count(), 1);
             }
             void tst_qpieslice::mouseHover()
             {
                 // create a pie series
                 QPieSeries *series = new QPieSeries();
                 series->setPieSize(1.0);
-                QPieSlice *s1 = series->append(1, "slice 1");
+                QPieSlice *s1 = series->append("slice 1", 1);
-                series->append(2, "slice 2");
+                series->append("slice 2", 2);
-                series->append(3, "slice 3");
+                series->append("slice 3", 3);
                 // add series to the chart
                 QChartView view(new QChart());
                 view.chart()->legend()->setVisible(false);
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // first move to right top corner
                 QTest::mouseMove(view.viewport(), QPoint(200, 0));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 // move inside slice rectangle but NOT the actual slice
                 // pie rectangle: QRectF(60,60 121x121)
                 QSignalSpy hoverSpy(s1, SIGNAL(hovered(bool)));
                 QTest::mouseMove(view.viewport(), QPoint(170, 70));
                 TRY_COMPARE(hoverSpy.count(), 0);
                 // move inside the slice
                 QTest::mouseMove(view.viewport(), QPoint(139, 85));
                 TRY_COMPARE(hoverSpy.count(), 1);
                 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(0).at(0)), true);
                 // move outside the slice
                 QTest::mouseMove(view.viewport(), QPoint(200, 0));
                 TRY_COMPARE(hoverSpy.count(), 2);
                 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(1).at(0)), false);
             }
             QTEST_MAIN(tst_qpieslice)
             #include "tst_qpieslice.moc"

tests/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));
+                            series->append(labels.at(i), column.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->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);
             }

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