HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r884:bc9561bc4b37

QSeries name and QPieSeries properties to QML api

Tero Ahola -

r884:bc9561bc4b37

parent child

Context file:

r884:bc9561bc4b37

Collapse all files

demos/chartthemes/themewidget.cpp +2 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "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 = "Item " + QString::number(i) + ":" + QString::number(j);
                         dataList << Data(value, label);
                     }
                     dataTable << dataList;
                 }
                 return dataTable;
             }
             QComboBox* ThemeWidget::createThemeBox() const
             {
                 // settings layout
                 QComboBox* themeComboBox = new QComboBox();
                 themeComboBox->addItem("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
             {
                 // area chart
                 QChart *chart = new QChart();
                 chart->axisX()->setNiceNumbers(true);
                 chart->axisY()->setNiceNumbers(true);
                 chart->setTitle("Area chart");
                 QString name("Series ");
                 int nameIndex = 0;
                 // The lower series initialized to zero values
                 QLineSeries *lowerSeries = 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)
                             upperSeries->append(QPointF(j, lowerSeries->y(i) + 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
             {
                 // bar chart
                 QChart* chart = new QChart();
                 chart->axisX()->setNiceNumbers(true);
                 chart->axisY()->setNiceNumbers(true);
                 chart->setTitle("Bar chart");
                 QBarCategories categories;
                 // TODO: categories
                 for (int i(0); i < valueCount; i++)
                     categories << QString::number(i);
             //            QBarSeries* series = new QBarSeries(categories, chart);
             //            QPercentBarSeries* series = new QPercentBarSeries(categories, chart);
                 QStackedBarSeries* series = new QStackedBarSeries(categories, chart);
                 for (int i(0); i < m_dataTable.count(); i++) {
                     QBarSet *set = new QBarSet("Set" + QString::number(i));
                     foreach (Data data, m_dataTable[i])
                         *set << data.first.y();
                     series->appendBarSet(set);
                 }
                 chart->addSeries(series);
                 return chart;
             }
             QChart* ThemeWidget::createLineChart() const
             {
                 // line chart
                 QChart* chart = new QChart();
                 chart->axisX()->setNiceNumbers(true);
                 chart->axisY()->setNiceNumbers(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
             {
                 // pie chart
                 QChart* chart = new QChart();
                 chart->setTitle("Pie chart");
                 qreal pieSize = 1.0 / m_dataTable.count();
                 for (int i = 0; i < m_dataTable.count(); i++) {
                     QPieSeries *series = new QPieSeries(chart);
                     foreach (Data data, m_dataTable[i]) {
                         QPieSlice *slice = series->append(data.first.y(), data.second);
                         if (data == m_dataTable[i].first()) {
                             slice->setLabelVisible();
                             slice->setExploded();
                         }
                     }
                     qreal hPos = (pieSize / 2) + (i / (qreal) m_dataTable.count());
                     series->setPieSize(pieSize);
-                    series->setPiePosition(hPos, 0.5);
+                    series->setHorizontalPosition(hPos);
+                    series->setVerticalPosition(0.5);
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createSplineChart() const
             { // spine chart
                 QChart* chart = new QChart();
                 chart->axisX()->setNiceNumbers(true);
                 chart->axisY()->setNiceNumbers(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()->setNiceNumbers(true);
                 chart->axisY()->setNiceNumbers(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()->setAlignmnent(alignment);
                         chartView->chart()->legend()->show();
                     }
             }

demos/piechartcustomization/mainwidget.cpp +4 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "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(20.0, "Slice 2");
                 *m_series << new CustomSlice(30.0, "Slice 3");
                 *m_series << new CustomSlice(40.0, "Slice 4");
                 *m_series << new CustomSlice(50.0, "Slice 5");
                 m_series->setLabelsVisible();
                 chart->addSeries(m_series);
                 connect(m_series, SIGNAL(clicked(QPieSlice*, Qt::MouseButtons)), this, SLOT(handleSliceClicked(QPieSlice*, Qt::MouseButtons)));
                 // 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);
                 QFormLayout* chartSettingsLayout = new QFormLayout();
                 chartSettingsLayout->addRow("Theme", m_themeComboBox);
                 chartSettingsLayout->addRow("Antialiasing", m_aaCheckBox);
                 chartSettingsLayout->addRow("Animations", m_animationsCheckBox);
                 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()));
                 // 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->pieHorizontalPosition());
+                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->pieVerticalPosition());
+                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 *addSlice = new QPushButton("Add 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(addSlice);
                 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(addSlice, SIGNAL(clicked()), this, SLOT(addSlice()));
                 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);
             }
             void MainWidget::updateSerieSettings()
             {
-                m_series->setPiePosition(m_hPosition->value(), m_vPosition->value());
+                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, Qt::MouseButtons buttons)
             {
                 Q_UNUSED(buttons);
                 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::addSlice()
             {
                 *m_series << new CustomSlice(10.0, "Slice " + QString::number(m_series->count()+1));
             }
             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)));
             }
             void MainWidget::removeSlice()
             {
                 if (!m_slice)
                     return;
                 m_series->remove(m_slice);
                 m_slice = 0;
             }
             #include "moc_mainwidget.cpp"

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

src/piechart/piechartitem.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 "piechartitem_p.h"
             #include "piesliceitem_p.h"
             #include "qpieslice.h"
             #include "qpieseries.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "chartanimator_p.h"
             #include <QDebug>
             #include <QPainter>
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter* presenter)
                 :ChartItem(presenter),
                 m_series(series)
             {
                 Q_ASSERT(series);
                 connect(series, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleSlicesAdded(QList<QPieSlice*>)));
                 connect(series, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleSlicesRemoved(QList<QPieSlice*>)));
                 connect(series, SIGNAL(piePositionChanged()), this, SLOT(handlePieLayoutChanged()));
                 connect(series, SIGNAL(pieSizeChanged()), this, SLOT(handlePieLayoutChanged()));
                 QTimer::singleShot(0, this, SLOT(initialize()));
                 // Note: the following does not affect as long as the item does not have anything to paint
                 setZValue(ChartPresenter::PieSeriesZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
             }
             PieChartItem::~PieChartItem()
             {
                 // slices deleted automatically through QGraphicsItem
             }
             void PieChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
             {
                 Q_UNUSED(painter)
                 // TODO: paint shadows for all components
                 // - get paths from items & merge & offset and draw with shadow color?
                 //painter->setBrush(QBrush(Qt::red));
                 //painter->drawRect(m_debugRect);
             }
             void PieChartItem::initialize()
             {
                 handleSlicesAdded(m_series->slices());
             }
             void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices)
             {
                 bool isEmpty = m_slices.isEmpty();
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series), false);
                 foreach (QPieSlice *s, slices) {
                     PieSliceItem* item = new PieSliceItem(this);
                     m_slices.insert(s, item);
                     connect(s, SIGNAL(changed()), this, SLOT(handleSliceChanged()));
                     connect(item, SIGNAL(clicked(Qt::MouseButtons)), s, SIGNAL(clicked(Qt::MouseButtons)));
                     connect(item, SIGNAL(hoverEnter()), s, SIGNAL(hoverEnter()));
                     connect(item, SIGNAL(hoverLeave()), s, SIGNAL(hoverLeave()));
                     PieSliceData data = sliceData(s);
                     if (animator())
                         animator()->addAnimation(this, s, data, isEmpty);
                     else
                         setLayout(s, data);
                 }
             }
             void PieChartItem::handleSlicesRemoved(QList<QPieSlice*> slices)
             {
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series), false);
                 foreach (QPieSlice *s, slices) {
                     if (animator())
                         animator()->removeAnimation(this, s);
                     else
                         destroySlice(s);
                 }
             }
             void PieChartItem::handlePieLayoutChanged()
             {
                 PieLayout layout = calculateLayout();
                 applyLayout(layout);
                 update();
             }
             void PieChartItem::handleSliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 PieSliceData data = sliceData(slice);
                 updateLayout(slice, data);
                 update();
             }
             void PieChartItem::handleDomainChanged(qreal, qreal, qreal, qreal)
             {
                 // TODO
             }
             void PieChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 handlePieLayoutChanged();
             }
             void PieChartItem::calculatePieLayout()
             {
                 // find pie center coordinates
-                m_pieCenter.setX(m_rect.left() + (m_rect.width() * m_series->pieHorizontalPosition()));
+                m_pieCenter.setX(m_rect.left() + (m_rect.width() * m_series->horizontalPosition()));
-                m_pieCenter.setY(m_rect.top() + (m_rect.height() * m_series->pieVerticalPosition()));
+                m_pieCenter.setY(m_rect.top() + (m_rect.height() * m_series->verticalPosition()));
                 // find maximum radius for pie
                 m_pieRadius = m_rect.height() / 2;
                 if (m_rect.width() < m_rect.height())
                     m_pieRadius = m_rect.width() / 2;
                 // apply size factor
                 m_pieRadius *= m_series->pieSize();
             }
             PieSliceData PieChartItem::sliceData(QPieSlice *slice)
             {
             	// TODO: This function is kid of useless now. Refactor.
                 PieSliceData sliceData = PieSliceData::data(slice);
                 sliceData.m_center = PieSliceItem::sliceCenter(m_pieCenter, m_pieRadius, slice);
                 sliceData.m_radius = m_pieRadius;
                 return sliceData;
             }
             PieLayout PieChartItem::calculateLayout()
             {
                 calculatePieLayout();
                 PieLayout layout;
                 foreach (QPieSlice* s, m_series->slices()) {
                     if (m_slices.contains(s)) // calculate layout only for those slices that are already visible
                         layout.insert(s, sliceData(s));
                 }
                 return layout;
             }
             void PieChartItem::applyLayout(const PieLayout &layout)
             {
                 if (animator())
                     animator()->updateLayout(this, layout);
                 else
                     setLayout(layout);
             }
             void PieChartItem::updateLayout(QPieSlice *slice, const PieSliceData &sliceData)
             {
                 if (animator())
                     animator()->updateLayout(this, slice, sliceData);
                 else
                     setLayout(slice, sliceData);
             }
             void PieChartItem::setLayout(const PieLayout &layout)
             {
                 foreach (QPieSlice *slice, layout.keys()) {
                     PieSliceItem *item = m_slices.value(slice);
                     Q_ASSERT(item);
                     item->setSliceData(layout.value(slice));
                     item->updateGeometry();
                     item->update();
                 }
             }
             void PieChartItem::setLayout(QPieSlice *slice, const PieSliceData &sliceData)
             {
                 // find slice
                 PieSliceItem *item = m_slices.value(slice);
                 Q_ASSERT(item);
                 item->setSliceData(sliceData);
                 item->updateGeometry();
                 item->update();
             }
             void PieChartItem::destroySlice(QPieSlice *slice)
             {
                 delete m_slices.take(slice);
             }
             #include "moc_piechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.cpp +51 -42

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

src/piechart/qpieseries.h +9 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef PIESERIES_H
             #define PIESERIES_H
             #include <qseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSeriesPrivate;
             class QPieSlice;
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QSeries
             {
                 Q_OBJECT
+                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)
             public:
                 QPieSeries(QObject *parent = 0);
                 virtual ~QPieSeries();
             public: // from QChartSeries
                 QSeriesType type() const;
             public:
                 // slice setters
                 void append(QPieSlice* slice);
                 void append(QList<QPieSlice*> slices);
                 void insert(int index, QPieSlice* slice);
                 void replace(QList<QPieSlice*> slices);
                 void remove(QPieSlice* slice);
                 void clear();
                 // slice getters
                 QList<QPieSlice*> slices() const;
                 // calculated data
                 int count() const;
                 bool isEmpty() const;
                 qreal total() const;
                 // pie customization
-                void setPiePosition(qreal relativeHorizontalPosition, qreal relativeVerticalPosition);
+                void setHorizontalPosition(qreal relativePosition);
-                qreal pieHorizontalPosition() const;
+                qreal horizontalPosition() const;
-                qreal pieVerticalPosition() 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;
                 // convenience function
                 QPieSeries& operator << (QPieSlice* slice);
                 QPieSlice* append(qreal value, QString name);
                 void setLabelsVisible(bool visible = true);
                 // data from model
                 bool setModel(QAbstractItemModel* model);
                 void setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation = Qt::Vertical);
             Q_SIGNALS:
                 void clicked(QPieSlice* slice, Qt::MouseButtons buttons);
                 void hoverEnter(QPieSlice* slice);
                 void hoverLeave(QPieSlice* slice);
                 void added(QList<QPieSlice*> slices);
                 void removed(QList<QPieSlice*> slices);
                 void piePositionChanged();
                 void pieSizeChanged();
             private:
                 QPieSeriesPrivate * const d_ptr;
                 Q_DECLARE_PRIVATE(QPieSeries)
                 Q_DISABLE_COPY(QPieSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

src/piechart/qpieseriesprivate_p.h +1 0

             /****************************************************************************
             **
             ** 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 QPIESERIESPRIVATE_P_H
             #define QPIESERIESPRIVATE_P_H
             #include "qpieseries.h"
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSeriesPrivate : public QObject
             {
                 Q_OBJECT
                 Q_DECLARE_PUBLIC(QPieSeries)
             public:
                 QPieSeriesPrivate(QPieSeries *parent);
                 ~QPieSeriesPrivate();
                 void updateDerivativeData();
             public Q_SLOTS:
                 void sliceChanged();
                 void sliceClicked(Qt::MouseButtons buttons);
                 void sliceHoverEnter();
                 void sliceHoverLeave();
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelDataAdded(QModelIndex parent, int start, int end);
                 void modelDataRemoved(QModelIndex parent, int start, int end);
+                bool setRealValue(qreal &value, qreal newValue, qreal max, qreal min = 0.0);
             public:
                 QPieSeries * const q_ptr;
                 QList<QPieSlice*> m_slices;
                 qreal m_pieRelativeHorPos;
                 qreal m_pieRelativeVerPos;
                 qreal m_pieRelativeSize;
                 qreal m_pieStartAngle;
                 qreal m_pieEndAngle;
                 qreal m_total;
                 // model map
                 int m_mapValues;
                 int m_mapLabels;
                 Qt::Orientation m_mapOrientation;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIESERIESPRIVATE_P_H

src/qseries.cpp +1 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qseries.h"
             /*!
                 \class QSeries
                 \brief Base class for all QtCommercial Chart series.
                 \mainclass
                 Usually you use the series type specific inherited classes instead of the base class.
                 \sa QScatterSeries
             */
             /*!
                 \enum QSeries::QSeriesType
                 The type of the series object.
                 \value SeriesTypeLine
                 \value SeriesTypeArea
                 \value SeriesTypeBar
                 \value SeriesTypeStackedBar
                 \value SeriesTypePercentBar
                 \value SeriesTypePie
                 \value SeriesTypeScatter
                 \value SeriesTypeSpline
             */
             /*!
                 \fn QSeries::QSeries(QObject *parent)
                 \brief Constructs ChartSeries object with \a parent.
             */
             /*!
                 \fn QSeries::~QSeries()
                 \brief Virtual destructor for the chart series.
             */
             /*!
                 \fn QSeriesType QSeries::type() const
                 \brief The type of the series.
             */
             /*!
                 \fn bool QSeries::setModel(QAbstractItemModel *model)
                 \brief Use the \a model to provide data for the series. The model overrides possible user data
                 set with QChartSeries type specific data setters. For example if you call both
                 QScatterSeries::addData() and QScatterSeries::setModel, only the data provided by the model is
                 used by the series. Returns true if the model is valid for the series.
             */
             /*!
                 \fn void QSeries::setName(QString name)
                 \brief Sets a \a name for the series.
                 The name of a series is shown in the legend for QXYSeries.
                 \sa QChart::setTitle()
                 \sa QPieSlice::setLabel()
                 \sa QBarSet::setName()
             */
             /*!
                 \fn QString QSeries::name()
                 \brief Returns the name of the series.
             */
-            QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            QTCOMMERCIALCHART_USE_NAMESPACE
             #include "moc_qseries.cpp"
-            QTCOMMERCIALCHART_END_NAMESPACE

src/qseries.h +2 0

             /****************************************************************************
             **
             ** 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 QSERIES_H
             #define QSERIES_H
             #include <qchartglobal.h>
             #include <QObject>
             //#include <QAbstractItemModel>
             #include <QPen>
             class QAbstractItemModel;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QSeries : public QObject
             {
                 Q_OBJECT
+                Q_PROPERTY(QString name READ name WRITE setName)
             public:
                 enum QSeriesType {
                     SeriesTypeLine,
                     SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypeStackedBar,
                     SeriesTypePercentBar,
                     SeriesTypePie,
                     SeriesTypeScatter,
                     SeriesTypeSpline
                 };
             protected:
                 QSeries(QObject *parent = 0) : QObject(parent) {m_model = 0;}
             public:
                 virtual ~QSeries() {}
                 virtual QSeriesType type() const = 0;
                 // TODO
                 virtual bool setModel(QAbstractItemModel* /*model*/) { return false; }
                 QAbstractItemModel* model() const { return m_model; }
                 void setName(QString name) { m_name = name; }
                 QString name() const { return m_name; }
             protected:
                 QAbstractItemModel* m_model;
             private:
                 QString m_name;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

test/qmlchart/qml/qmlchart/main.qml +12 -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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             Rectangle {
                 width: parent.width
                 height: parent.height
                 // Another option for QML data api:
             //    ListModel {
             //        id: listModelForPie
             //        // PieDataElement
             //        ListElement {
             //            label: "Apple"
             //            value: 4.3
             //        }
             //        ListElement {
             //            label: "Blackberry"
             //            value: 15.1
             //        }
             //    }
                 Component.onCompleted: {
             //        console.log("model:" + myModel.item(0));
             //        myModel.insert(1, {"time":1.4; "speed":41.1 });
             //        scatter.appendData();
             //        chart1.theme = Chart.ThemeHighContrast;
             //        chart2.theme = Chart.ThemeHighContrast;
                 }
                 Chart {
                     id: chart1
                     anchors.top: parent.top
                     anchors.left: parent.left
                     anchors.right: parent.right
                     height: parent.height / 2
                     theme: Chart.ChartThemeDark
                     BarSeries {
                         barCategories: [ "2008", "2009", "2010", "2011", "2012" ]
+                        // TBD: data
                     }
                     PieSeries {
+                        horizontalPosition: 0.2
+                        verticalPosition: 0.3
+                        size: 0.4
+                        endAngle: 0.52 * 360 // The share of "others" is 52%
                         slices: [
                             PieSlice { label: "Volkswagen"; value: 13.5 },
                             PieSlice { label: "Toyota"; value: 10.9 },
                             PieSlice { label: "Ford"; value: 8.6 },
                             PieSlice { label: "Skoda"; value: 8.2 },
-                            PieSlice { label: "Volvo"; value: 6.8 },
+                            PieSlice { label: "Volvo"; value: 6.8 }
-                            PieSlice { label: "Others"; value: 52.0 }
                         ]
                     }
                 }
                 Chart {
                     id: chart2
                     anchors.top: chart1.bottom
                     anchors.bottom: parent.bottom
                     anchors.left: parent.left
                     anchors.right: parent.right
                     theme: Chart.ChartThemeBrownSand
                     LineSeries {
+                        name: "Line"
                         points: [
                             XyPoint { x: 0.0; y: 0.0 },
                             XyPoint { x: 1.1; y: 2.1 },
                             XyPoint { x: 2.9; y: 4.9 },
                             XyPoint { x: 3.2; y: 3.0 }
                         ]
                     }
                     SplineSeries {
+                        name: "Spline"
                         points: [
                             XyPoint { x: 0.0; y: 0.3 },
                             XyPoint { x: 1.1; y: 3.2 },
                             XyPoint { x: 4.17; y: 3.15 }
                         ]
                     }
                     AreaSeries {
+                        name: "Area"
                         points: [
                             XyPoint { x: 0.0; y: 1.1 },
                             XyPoint { x: 2.5; y: 3.6 },
                             XyPoint { x: 3.57; y: 2.55 }
                         ]
                         lowerPoints: [
                             XyPoint { x: 0.0; y: 0.0 },
                             XyPoint { x: 2.5; y: 0.0 },
                             XyPoint { x: 3.57; y: 0.0 }
                         ]
                     }
                     ScatterSeries {
+                        name: "Scatter1"
                         points: [
                             XyPoint { x: 1.5; y: 1.5 },
                             XyPoint { x: 1.5; y: 1.6 },
                             XyPoint { x: 1.57; y: 1.55 }
                         ]
                     }
                     ScatterSeries {
+                        name: "Scatter2"
                         points: [
                             XyPoint { x: 2.0; y: 2.0 },
                             XyPoint { x: 2.0; y: 2.1 },
                             XyPoint { x: 2.07; y: 2.05 }
                         ]
                     }
                     ScatterSeries {
+                        name: "Scatter3"
                         points: [
                             XyPoint { x: 2.6; y: 2.6 },
                             XyPoint { x: 2.6; y: 2.7 },
                             XyPoint { x: 2.67; y: 2.65 }
                         ]
                     }
                 }
             }

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