HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r621:f4b980d7defa

Refactoring pie series and animations.

Jani Honkonen -

r621:f4b980d7defa

parent child

Context file:

r621:f4b980d7defa

Collapse all files

demos/piechartcustomization/main.cpp +13 0

             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <qpieseries.h>
             #include <qpieslice.h>
             #include <QGridLayout>
             #include <QFormLayout>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGroupBox>
             #include <QLabel>
             #include <QPushButton>
             #include <QColorDialog>
             #include <QFontDialog>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class PenTool : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit PenTool(QString title, QWidget *parent = 0)
                     :QWidget(parent)
                 {
                     setWindowTitle(title);
                     setWindowFlags(Qt::Tool);
                     m_colorButton = new QPushButton();
                     m_widthSpinBox = new QDoubleSpinBox();
                     m_styleCombo = new QComboBox();
                     m_styleCombo->addItem("NoPen");
                     m_styleCombo->addItem("SolidLine");
                     m_styleCombo->addItem("DashLine");
                     m_styleCombo->addItem("DotLine");
                     m_styleCombo->addItem("DashDotLine");
                     m_styleCombo->addItem("DashDotDotLine");
                     m_capStyleCombo = new QComboBox();
                     m_capStyleCombo->addItem("FlatCap", Qt::FlatCap);
                     m_capStyleCombo->addItem("SquareCap", Qt::SquareCap);
                     m_capStyleCombo->addItem("RoundCap", Qt::RoundCap);
                     m_joinStyleCombo = new QComboBox();
                     m_joinStyleCombo->addItem("MiterJoin", Qt::MiterJoin);
                     m_joinStyleCombo->addItem("BevelJoin", Qt::BevelJoin);
                     m_joinStyleCombo->addItem("RoundJoin", Qt::RoundJoin);
                     m_joinStyleCombo->addItem("SvgMiterJoin", Qt::SvgMiterJoin);
                     QFormLayout *layout = new QFormLayout();
                     layout->addRow("Color", m_colorButton);
                     layout->addRow("Width", m_widthSpinBox);
                     layout->addRow("Style", m_styleCombo);
                     layout->addRow("Cap style", m_capStyleCombo);
                     layout->addRow("Join style", m_joinStyleCombo);
                     setLayout(layout);
                     connect(m_colorButton, SIGNAL(clicked()), this, SLOT(showColorDialog()));
                     connect(m_widthSpinBox, SIGNAL(valueChanged(double)), this, SLOT(updateWidth(double)));
                     connect(m_styleCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(updateStyle(int)));
                     connect(m_capStyleCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(updateCapStyle(int)));
                     connect(m_joinStyleCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(updateJoinStyle(int)));
                 }
                 void setPen(QPen pen)
                 {
                     m_pen = pen;
                     m_colorButton->setText(m_pen.color().name());
                     m_widthSpinBox->setValue(m_pen.widthF());
                     m_styleCombo->setCurrentIndex(m_pen.style()); // index matches the enum
                     m_capStyleCombo->setCurrentIndex(m_capStyleCombo->findData(m_pen.capStyle()));
                     m_joinStyleCombo->setCurrentIndex(m_joinStyleCombo->findData(m_pen.joinStyle()));
                 }
                 QPen pen() const
                 {
                     return m_pen;
                 }
                 QString name()
                 {
                     return name(m_pen);
                 }
                 static QString name(const QPen &pen)
                 {
                     return pen.color().name() + ":" + QString::number(pen.widthF());
                 }
             Q_SIGNALS:
                 void changed();
             public Q_SLOTS:
                 void showColorDialog()
                 {
                     QColorDialog dialog(m_pen.color());
                     dialog.show();
                     dialog.exec();
                     m_pen.setColor(dialog.selectedColor());
                     m_colorButton->setText(m_pen.color().name());
                     emit changed();
                 }
                 void updateWidth(double width)
                 {
                     if (width != m_pen.widthF()) {
                         m_pen.setWidthF(width);
                         emit changed();
                     }
                 }
                 void updateStyle(int style)
                 {
                     if (m_pen.style() != style) {
                         m_pen.setStyle((Qt::PenStyle) style);
                         emit changed();
                     }
                 }
                 void updateCapStyle(int index)
                 {
                     Qt::PenCapStyle capStyle = (Qt::PenCapStyle) m_capStyleCombo->itemData(index).toInt();
                     if (m_pen.capStyle() != capStyle) {
                         m_pen.setCapStyle(capStyle);
                         emit changed();
                     }
                 }
                 void updateJoinStyle(int index)
                 {
                     Qt::PenJoinStyle joinStyle = (Qt::PenJoinStyle) m_joinStyleCombo->itemData(index).toInt();
                     if (m_pen.joinStyle() != joinStyle) {
                         m_pen.setJoinStyle(joinStyle);
                         emit changed();
                     }
                 }
             private:
                 QPen m_pen;
                 QPushButton *m_colorButton;
                 QDoubleSpinBox *m_widthSpinBox;
                 QComboBox *m_styleCombo;
                 QComboBox *m_capStyleCombo;
                 QComboBox *m_joinStyleCombo;
             };
             class BrushTool : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit BrushTool(QString title, QWidget *parent = 0)
                     :QWidget(parent)
                 {
                     setWindowTitle(title);
                     setWindowFlags(Qt::Tool);
                     m_colorButton = new QPushButton();
                     m_styleCombo = new QComboBox();
                     m_styleCombo->addItem("Nobrush", Qt::NoBrush);
                     m_styleCombo->addItem("Solidpattern", Qt::SolidPattern);
                     m_styleCombo->addItem("Dense1pattern", Qt::Dense1Pattern);
                     m_styleCombo->addItem("Dense2attern", Qt::Dense2Pattern);
                     m_styleCombo->addItem("Dense3Pattern", Qt::Dense3Pattern);
                     m_styleCombo->addItem("Dense4Pattern", Qt::Dense4Pattern);
                     m_styleCombo->addItem("Dense5Pattern", Qt::Dense5Pattern);
                     m_styleCombo->addItem("Dense6Pattern", Qt::Dense6Pattern);
                     m_styleCombo->addItem("Dense7Pattern", Qt::Dense7Pattern);
                     m_styleCombo->addItem("HorPattern", Qt::HorPattern);
                     m_styleCombo->addItem("VerPattern", Qt::VerPattern);
                     m_styleCombo->addItem("CrossPattern", Qt::CrossPattern);
                     m_styleCombo->addItem("BDiagPattern", Qt::BDiagPattern);
                     m_styleCombo->addItem("FDiagPattern", Qt::FDiagPattern);
                     m_styleCombo->addItem("DiagCrossPattern", Qt::DiagCrossPattern);
                     QFormLayout *layout = new QFormLayout();
                     layout->addRow("Color", m_colorButton);
                     layout->addRow("Style", m_styleCombo);
                     setLayout(layout);
                     connect(m_colorButton, SIGNAL(clicked()), this, SLOT(showColorDialog()));
                     connect(m_styleCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(updateStyle()));
                 }
                 void setBrush(QBrush brush)
                 {
                     m_brush = brush;
                     m_colorButton->setText(m_brush.color().name());
                     m_styleCombo->setCurrentIndex(m_brush.style()); // index matches the enum
                 }
                 QBrush brush() const
                 {
                     return m_brush;
                 }
                 QString name()
                 {
                     return name(m_brush);
                 }
                 static QString name(const QBrush &brush)
                 {
                     return brush.color().name();
                 }
             Q_SIGNALS:
                 void changed();
             public Q_SLOTS:
                 void showColorDialog()
                 {
                     QColorDialog dialog(m_brush.color());
                     dialog.show();
                     dialog.exec();
                     m_brush.setColor(dialog.selectedColor());
                     m_colorButton->setText(m_brush.color().name());
                     emit changed();
                 }
                 void updateStyle()
                 {
                     Qt::BrushStyle style = (Qt::BrushStyle) m_styleCombo->itemData(m_styleCombo->currentIndex()).toInt();
                     if (m_brush.style() != style) {
                         m_brush.setStyle(style);
                         emit changed();
                     }
                 }
             private:
                 QBrush m_brush;
                 QPushButton *m_colorButton;
                 QComboBox *m_styleCombo;
             };
             class CustomSlice : public QPieSlice
             {
                 Q_OBJECT
             public:
                 CustomSlice(qreal value, QString label)
                     :QPieSlice(value, label)
                 {
                     connect(this, SIGNAL(hoverEnter()), this, SLOT(handleHoverEnter()));
                     connect(this, SIGNAL(hoverLeave()), this, SLOT(handleHoverLeave()));
                 }
             public:
                 QBrush originalBrush()
                 {
                     return m_originalBrush;
                 }
             public Q_SLOTS:
                 void handleHoverEnter()
                 {
                     QBrush brush = this->sliceBrush();
                     m_originalBrush = brush;
                     brush.setColor(brush.color().lighter());
                     setSliceBrush(brush);
                 }
                 void handleHoverLeave()
                 {
                     setSliceBrush(m_originalBrush);
                 }
             private:
                 QBrush m_originalBrush;
             };
             class MainWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit MainWidget(QWidget* parent = 0)
                     :QWidget(parent),
                     m_slice(0)
                 {
                     // create chart
                     m_chartView =  new QChartView();
                     m_chartView->setChartTitle("Piechart customization");
                     m_chartView->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_chartView->addSeries(m_series);
                     connect(m_series, SIGNAL(clicked(QPieSlice*)), this, SLOT(handleSliceClicked(QPieSlice*)));
                     // chart settings
                     m_themeComboBox = new QComboBox();
                     m_themeComboBox->addItem("Default", QChart::ChartThemeDefault);
                     m_themeComboBox->addItem("Vanilla", QChart::ChartThemeVanilla);
                     m_themeComboBox->addItem("Icy", QChart::ChartThemeIcy);
                     m_themeComboBox->addItem("Grayscale", QChart::ChartThemeGrayscale);
                     m_themeComboBox->addItem("Scientific", QChart::ChartThemeScientific);
                     m_aaCheckBox = new QCheckBox();
                     QFormLayout* chartSettingsLayout = new QFormLayout();
                     chartSettingsLayout->addRow("Theme", m_themeComboBox);
                     chartSettingsLayout->addRow("Antialiasing", m_aaCheckBox);
                     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()));
                     // 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_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_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_labelArmPen = new QPushButton();
                     m_labelArmPenTool = new PenTool("Label arm 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 arm pen", m_labelArmPen);
                     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_labelArmPen, SIGNAL(clicked()), m_labelArmPenTool, SLOT(show()));
                     connect(m_labelArmPenTool, 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 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();
                 }
             public Q_SLOTS:
                 void updateChartSettings()
                 {
                     QChart::ChartTheme theme = (QChart::ChartTheme) m_themeComboBox->itemData(m_themeComboBox->currentIndex()).toInt();
                     m_chartView->setChartTheme(theme);
                     m_chartView->setRenderHint(QPainter::Antialiasing, m_aaCheckBox->isChecked());
                 }
                 void updateSerieSettings()
                 {
                     m_series->setPiePosition(m_vPosition->value(), m_hPosition->value());
                     m_series->setPieSize(m_sizeFactor->value());
                     m_series->setPieStartAngle(m_startAngle->value());
                     m_series->setPieEndAngle(m_endAngle->value());
                 }
                 void updateSliceSettings()
                 {
                     if (!m_slice)
                         return;
                     m_slice->setValue(m_sliceValue->value());
                     m_slice->setSlicePen(m_penTool->pen());
                     m_slice->setSliceBrush(m_brushTool->brush());
                     m_slice->setLabelArmPen(m_labelArmPenTool->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 handleSliceClicked(QPieSlice* slice)
                 {
                     m_slice = static_cast<CustomSlice*>(slice);
                     // name
                     m_sliceName->setText(slice->label());
                     // value
                     m_sliceValue->blockSignals(true);
                     m_sliceValue->setValue(slice->value());
                     m_sliceValue->blockSignals(false);
                     // pen
                     m_pen->setText(PenTool::name(m_slice->slicePen()));
                     m_penTool->setPen(m_slice->slicePen());
                     // brush
                     m_brush->setText(m_slice->originalBrush().color().name());
                     m_brushTool->setBrush(m_slice->originalBrush());
                     // label
                     m_labelArmPen->setText(PenTool::name(m_slice->labelArmPen()));
                     m_labelArmPenTool->setPen(m_slice->labelArmPen());
                     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 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 addSlice()
                 {
                     *m_series << new CustomSlice(10.0, "Slice " + QString::number(m_series->count()));
                 }
+                void 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())));
+                }
                 void removeSlice()
                 {
                     if (!m_slice)
                         return;
                     m_series->remove(m_slice);
                     m_slice = 0;
                 }
             private:
                 QComboBox *m_themeComboBox;
                 QCheckBox *m_aaCheckBox;
                 QChartView* m_chartView;
                 QPieSeries* m_series;
                 CustomSlice* m_slice;
                 QDoubleSpinBox* m_hPosition;
                 QDoubleSpinBox* m_vPosition;
                 QDoubleSpinBox* m_sizeFactor;
                 QDoubleSpinBox* m_startAngle;
                 QDoubleSpinBox* m_endAngle;
                 QLabel* m_sliceName;
                 QDoubleSpinBox* m_sliceValue;
                 QCheckBox* m_sliceLabelVisible;
                 QDoubleSpinBox* m_sliceLabelArmFactor;
                 QCheckBox* m_sliceExploded;
                 QDoubleSpinBox* m_sliceExplodedFactor;
                 QPushButton *m_brush;
                 BrushTool *m_brushTool;
                 QPushButton *m_pen;
                 PenTool *m_penTool;
                 QPushButton *m_font;
                 QPushButton *m_labelArmPen;
                 PenTool *m_labelArmPenTool;
             };
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
                 MainWidget* widget = new MainWidget();
                 window.setCentralWidget(widget);
                 window.resize(900, 600);
                 window.show();
                 return a.exec();
             }
             #include "main.moc"

examples/piechartdrilldown/main.cpp +1 0

             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <qpieseries.h>
             #include <qpieslice.h>
             #include <QTime>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class DrilldownSlice : public QPieSlice
             {
                 Q_OBJECT
             public:
                 DrilldownSlice(qreal value, QString prefix, QSeries* drilldownSeries)
                     :m_drilldownSeries(drilldownSeries),
                     m_prefix(prefix)
                 {
                     setValue(value);
                     setLabelVisible(true);
                     updateLabel();
                     connect(this, SIGNAL(changed()), this, SLOT(updateLabel()));
                 }
                 QSeries* drilldownSeries() const { return m_drilldownSeries; }
             public Q_SLOTS:
                 void updateLabel()
                 {
                     QString label = m_prefix;
                     label += " " + QString::number(this->value())+ "e (";
                     label += QString::number(this->percentage()*100, 'f', 1) + "%)";
                     setLabel(label);
                 }
             private:
                 QSeries* m_drilldownSeries;
                 QString m_prefix;
             };
             class DrilldownChart : public QChartView
             {
                 Q_OBJECT
             public:
                 explicit DrilldownChart(QWidget *parent = 0):QChartView(parent), m_currentSeries(0) {}
                 void changeSeries(QSeries* series)
                 {
                     // NOTE: if the series is owned by the chart it will be deleted
                     // here the "window" owns the series...
                     if (m_currentSeries)
                         removeSeries(m_currentSeries);
                     m_currentSeries = series;
                     addSeries(series);
                     setChartTitle(series->title());
                 }
             public Q_SLOTS:
                 void handleSliceClicked(QPieSlice* slice)
                 {
                     DrilldownSlice* drilldownSlice = static_cast<DrilldownSlice*>(slice);
                     changeSeries(drilldownSlice->drilldownSeries());
                 }
             private:
                 QSeries* m_currentSeries;
             };
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
                 QMainWindow window;
                 DrilldownChart* drilldownChart =  new DrilldownChart(&window);
                 drilldownChart->setRenderHint(QPainter::Antialiasing);
                 drilldownChart->setChartTheme(QChart::ChartThemeVanilla);
+                drilldownChart->setAnimationOptions(QChart::AllAnimations);
                 QPieSeries* yearSeries = new QPieSeries(&window);
                 yearSeries->setTitle("Sales by year - All");
                 QList<QString> months;
                 months << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
                 QList<QString> names;
                 names << "Jane" << "John" << "Axel" << "Mary" << "Samantha" << "Bob";
                 foreach (QString name, names) {
                     QPieSeries* series = new QPieSeries(&window);
                     series->setTitle("Sales by month - " + name);
                     foreach (QString month, months)
                         *series << new DrilldownSlice(qrand() % 1000, month, yearSeries);
                     QObject::connect(series, SIGNAL(clicked(QPieSlice*)), drilldownChart, SLOT(handleSliceClicked(QPieSlice*)));
                     *yearSeries << new DrilldownSlice(series->total(), name, series);
                 }
                 QObject::connect(yearSeries, SIGNAL(clicked(QPieSlice*)), drilldownChart, SLOT(handleSliceClicked(QPieSlice*)));
                 drilldownChart->changeSeries(yearSeries);
                 window.setCentralWidget(drilldownChart);
                 window.resize(800, 600);
                 window.show();
                 return a.exec();
             }
             #include "main.moc"

src/animations/chartanimator.cpp +16 -2

             #include "chartanimator_p.h"
             #include "axisanimation_p.h"
             #include "xyanimation_p.h"
             #include "xychartitem_p.h"
             #include "pieanimation_p.h"
             #include "areachartitem_p.h"
             #include <QTimer>
             Q_DECLARE_METATYPE(QVector<QPointF>)
             Q_DECLARE_METATYPE(QVector<qreal>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             const static int duration = 1000;
             ChartAnimator::ChartAnimator(QObject *parent):QObject(parent)
             {
             }
             ChartAnimator::~ChartAnimator()
             {
             }
             void ChartAnimator::addAnimation(AxisItem* item)
             {
                 ChartAnimation* animation = m_animations.value(item);
                 if(!animation) {
                     animation = new AxisAnimation(item);
                     m_animations.insert(item,animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::addAnimation(XYChartItem*  item)
             {
                 ChartAnimation* animation = m_animations.value(item);
                 if(!animation) {
                     animation = new XYAnimation(item);
                     m_animations.insert(item,animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::addAnimation(PieChartItem* item)
             {
                 ChartAnimation* animation = m_animations.value(item);
                 if(!animation) {
                     animation = new PieAnimation(item);
                     m_animations.insert(item,animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::removeAnimation(ChartItem* item)
             {
                 item->setAnimator(0);
                 m_animations.remove(item);
             }
             void ChartAnimator::applyLayout(AxisItem* item , QVector<qreal>& newLayout)
             {
                 AxisAnimation* animation = static_cast<AxisAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 QVector<qreal> oldLayout = item->layout();
                 if(newLayout.count()==0) return;
                 switch(m_state)
             	{
                 	case ZoomOutState: {
                 			QRectF rect = item->geometry();
                 			oldLayout.resize(newLayout.count());
                 			for(int i=0,j=oldLayout.count()-1;i<(oldLayout.count()+1)/2;i++,j--)
                 			{
                 				oldLayout[i]= item->axisType()==AxisItem::X_AXIS?rect.left():rect.bottom();
                 				oldLayout[j]= item->axisType()==AxisItem::X_AXIS?rect.right():rect.top();
                 			}
                 		}
                 	break;
             		case ZoomInState: {
             			int index = qMin(oldLayout.count()*(item->axisType()==AxisItem::X_AXIS?m_point.x():(1 -m_point.y())),newLayout.count()-1.0);
             			oldLayout.resize(newLayout.count());
             			for(int i=0;i<oldLayout.count();i++)
             			{
             				oldLayout[i]= oldLayout[index];
             			}
             		}
             		break;
             		case ScrollDownState:
             		case ScrollRightState: {
             			oldLayout.resize(newLayout.count());
             			for(int i=0, j=i+1;i<oldLayout.count()-1;i++,j++)
             			{
             				oldLayout[i]= oldLayout[j];
             			}
             		}
             		break;
             		case ScrollUpState:
             		case ScrollLeftState: {
             			oldLayout.resize(newLayout.count());
             			for(int i=oldLayout.count()-1, j=i-1;i>0;i--,j--)
             			{
             				oldLayout[i]= oldLayout[j];
             			}
             		}
             		break;
             		default: {
             			oldLayout.resize(newLayout.count());
             			QRectF rect = item->geometry();
             			for(int i=0, j=oldLayout.count()-1;i<oldLayout.count();i++,j--)
             			{
             				oldLayout[i]= item->axisType()==AxisItem::X_AXIS?rect.left():rect.top();
             			}
             		}
             		break;
             	}
                 if(animation->state()!=QAbstractAnimation::Stopped) {
                     animation->stop();
                 }
                 animation->setDuration(duration);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 QVariantAnimation::KeyValues value;
                 animation->setKeyValues(value); //workaround for wrong interpolation call
                 animation->setKeyValueAt(0.0, qVariantFromValue(oldLayout));
                 animation->setKeyValueAt(1.0, qVariantFromValue(newLayout));
                 QTimer::singleShot(0,animation,SLOT(start()));
             }
             void ChartAnimator::applyLayout(XYChartItem* item, QVector<QPointF>& newPoints)
             {
                 XYAnimation* animation = static_cast<XYAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 QVector<QPointF> oldPoints = item->points();
                 if(newPoints.count()==0) return;
                 bool empty = oldPoints.count()==0;
                 oldPoints.resize(newPoints.size());
                 if(animation->state()!=QAbstractAnimation::Stopped) {
                     animation->stop();
                 }
                 animation->setDuration(duration);
                 if(!empty)
                 animation->setAnimationType(XYAnimation::MoveDownAnimation);
                 else
                 animation->setAnimationType(XYAnimation::LineDrawAnimation);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 animation->setValues(oldPoints,newPoints);
                 QTimer::singleShot(0,animation,SLOT(start()));
             }
             void ChartAnimator::updateLayout(XYChartItem* item, QVector<QPointF>& newPoints)
             {
                 XYAnimation* animation = static_cast<XYAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->setDuration(duration);
                 animation->setAnimationType(XYAnimation::MoveDownAnimation);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 animation->updateValues(newPoints);
                 QTimer::singleShot(0,animation,SLOT(start()));
             }
-            void ChartAnimator::applyLayout(PieChartItem* item, QVector<PieSliceLayout> &layout)
+            void ChartAnimator::addAnimation(PieChartItem* item, QPieSlice *slice, PieSliceLayout &layout)
             {
                 PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
-                animation->setValues(layout);
+                animation->addSlice(slice, layout);
+            }
+            void ChartAnimator::removeAnimation(PieChartItem* item, QPieSlice *slice)
+            {
+                PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
+                Q_ASSERT(animation);
+                animation->removeSlice(slice);
+            }
+            void ChartAnimator::updateLayout(PieChartItem* item, QVector<PieSliceLayout> &layout)
+            {
+                PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
+                Q_ASSERT(animation);
+                animation->updateValues(layout);
             }
             void ChartAnimator::updateLayout(PieChartItem* item, PieSliceLayout &layout)
             {
                 PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->updateValue(layout);
             }
             void ChartAnimator::setState(State state,const QPointF& point)
             {
             	m_state=state;
             	m_point=point;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/chartanimator_p.h +3 -1

             #ifndef CHARTANIMATOR_P_H_
             #define CHARTANIMATOR_P_H_
             #include "qchartglobal.h"
             #include "chartanimation_p.h"
             #include "piechartitem_p.h"
             #include <QPointF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class XYChartItem;
             class AxisItem;
             class AreaChartItem;
             class ChartAnimator : public QObject {
             public:
             	//TODO: this should be flags in case of two state at the time
             	enum State{ShowState, ScrollUpState, ScrollDownState, ScrollLeftState,ScrollRightState,ZoomInState,ZoomOutState};
                 ChartAnimator(QObject *parent = 0);
                 virtual ~ChartAnimator();
                 void addAnimation(AxisItem* item);
                 void addAnimation(XYChartItem* item);
                 void addAnimation(PieChartItem* item);
                 void removeAnimation(ChartItem* item);
                 void animationStarted();
                 void applyLayout(XYChartItem* item, QVector<QPointF>& layout);
                 void updateLayout(XYChartItem* item, QVector<QPointF>& layout);
                 void applyLayout(AxisItem* item, QVector<qreal>& layout);
-                void applyLayout(PieChartItem* item, QVector<PieSliceLayout> &layout);
+                void addAnimation(PieChartItem* item, QPieSlice *slice, PieSliceLayout &layout);
+                void removeAnimation(PieChartItem* item, QPieSlice *slice);
+                void updateLayout(PieChartItem* item, QVector<PieSliceLayout> &layout);
                 void updateLayout(PieChartItem* item, PieSliceLayout &layout);
                 void setState(State state,const QPointF& point = QPointF());
             private:
                  QMap<ChartItem*,ChartAnimation*> m_animations;
                  State m_state;
                  QPointF m_point;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/animations/pieanimation.cpp +41 -46

@@ -1,94 +1,89
1	#include "PieAnimation_p.h"	1	#include "PieAnimation_p.h"
2	#include "piesliceanimation_p.h"	2	#include "piesliceanimation_p.h"
3	#include "piechartitem_p.h"	3	#include "piechartitem_p.h"
4	#include <QParallelAnimationGroup>	4	#include <QParallelAnimationGroup>
5	#include <QTimer>	5	#include <QTimer>
6		6
7	QTCOMMERCIALCHART_BEGIN_NAMESPACE	7	QTCOMMERCIALCHART_BEGIN_NAMESPACE
8		8
9	PieAnimation::PieAnimation(PieChartItem *item)	9	PieAnimation::PieAnimation(PieChartItem *item)
10	:ChartAnimation(item),	10	:ChartAnimation(item),
11	m_item(item)	11	m_item(item)
12	{	12	{
13	}	13	}
14		14
15	PieAnimation::~PieAnimation()	15	PieAnimation::~PieAnimation()
16	{	16	{
17	}	17	}
18		18
19	void PieAnimation::~~set~~Values(QVector<PieSliceLayout>& newValues)	19	void PieAnimation::updateValues(QVector<PieSliceLayout>& newValues)
20	{	20	{
21	PieSliceAnimation *animation = 0;	21	foreach (PieSliceLayout endLayout, newValues)
22		22	updateValue(endLayout);
23	foreach (PieSliceLayout endLayout, newValues) {
24	animation = m_animations.value(endLayout.m_data);
25	if (animation) {
26	// existing slice
27	animation->stop();
28	animation->updateValue(endLayout);
29	} else {
30	// new slice
31	animation = new PieSliceAnimation(m_item);
32	m_animations.insert(endLayout.m_data, animation);
33	PieSliceLayout startLayout = endLayout;
34	startLayout.m_radius = 0;
35	//startLayout.m_startAngle = 0;
36	//startLayout.m_angleSpan = 0;
37	animation->setValue(startLayout, endLayout);
38	}
39	animation->setDuration(1000);
40	animation->setEasingCurve(QEasingCurve::OutQuart);
41	QTimer::singleShot(0, animation, SLOT(start())); // TODO: use sequential animation?
42	}
43
44	foreach (QPieSlice *s, m_animations.keys()) {
45	bool isFound = false;
46	foreach (PieSliceLayout layout, newValues) {
47	if (s == layout.m_data)
48	isFound = true;
49	}
50	if (!isFound) {
51	// slice has been deleted
52	animation = m_animations.value(s);
53	animation->stop();
54	PieSliceLayout endLayout = m_animations.value(s)->currentSliceValue();
55	endLayout.m_radius = 0;
56	// TODO: find the actual angle where this slice disappears
57	endLayout.m_startAngle = endLayout.m_startAngle + endLayout.m_angleSpan;
58	endLayout.m_angleSpan = 0;
59	animation->updateValue(endLayout);
60	animation->setDuration(1000);
61	animation->setEasingCurve(QEasingCurve::OutQuart);
62	connect(animation, SIGNAL(finished()), this, SLOT(destroySliceAnimationComplete()));
63	QTimer::singleShot(0, animation, SLOT(start()));
64	}
65	}
66	}	23	}
67		24
68	void PieAnimation::updateValue(PieSliceLayout& endLayout)	25	void PieAnimation::updateValue(PieSliceLayout& endLayout)
69	{	26	{
70	PieSliceAnimation *animation = m_animations.value(endLayout.m_data);	27	PieSliceAnimation *animation = m_animations.value(endLayout.m_data);
71	Q_ASSERT(animation);	28	Q_ASSERT(animation);
72	animation->stop();	29	animation->stop();
		30
		31	animation->updateValue(endLayout);
		32	animation->setDuration(1000);
		33	animation->setEasingCurve(QEasingCurve::OutQuart);
		34
		35	QTimer::singleShot(0, animation, SLOT(start()));
		36	}
		37
		38	void PieAnimation::addSlice(QPieSlice *slice, PieSliceLayout endLayout)
		39	{
		40	PieSliceAnimation *animation = new PieSliceAnimation(m_item);
		41	m_animations.insert(slice, animation);
		42
		43	PieSliceLayout startLayout = endLayout;
		44	startLayout.m_radius = 0;
		45	startLayout.m_startAngle = endLayout.m_startAngle + (endLayout.m_angleSpan/2);
		46	startLayout.m_angleSpan = 0;
		47	animation->setValue(startLayout, endLayout);
		48
		49	animation->setDuration(1000);
		50	animation->setEasingCurve(QEasingCurve::OutQuart);
		51	QTimer::singleShot(0, animation, SLOT(start()));
		52	}
		53
		54	void PieAnimation::removeSlice(QPieSlice *slice)
		55	{
		56	PieSliceAnimation *animation = m_animations.value(slice);
		57	Q_ASSERT(animation);
		58	animation->stop();
		59
		60	PieSliceLayout endLayout = animation->currentSliceValue();
		61	endLayout.m_radius = 0;
		62	// TODO: find the actual angle where this slice disappears
		63	endLayout.m_startAngle = endLayout.m_startAngle + endLayout.m_angleSpan;
		64	endLayout.m_angleSpan = 0;
		65
73	animation->updateValue(endLayout);	66	animation->updateValue(endLayout);
74	animation->setDuration(1000);	67	animation->setDuration(1000);
75	animation->setEasingCurve(QEasingCurve::OutQuart);	68	animation->setEasingCurve(QEasingCurve::OutQuart);
		69
		70	connect(animation, SIGNAL(finished()), this, SLOT(destroySliceAnimationComplete()));
76	QTimer::singleShot(0, animation, SLOT(start()));	71	QTimer::singleShot(0, animation, SLOT(start()));
77	}	72	}
78		73
79	void PieAnimation::updateCurrentValue(const QVariant &)	74	void PieAnimation::updateCurrentValue(const QVariant &)
80	{	75	{
81	// nothing to do...	76	// nothing to do...
82	}	77	}
83		78
84	void PieAnimation::destroySliceAnimationComplete()	79	void PieAnimation::destroySliceAnimationComplete()
85	{	80	{
86	PieSliceAnimation animation = static_cast<PieSliceAnimation>(sender());	81	PieSliceAnimation animation = static_cast<PieSliceAnimation>(sender());
87	QPieSlice *slice = m_animations.key(animation);	82	QPieSlice *slice = m_animations.key(animation);
88	m_item->destroySlice(slice);	83	m_item->destroySlice(slice);
89	delete m_animations.take(slice);	84	delete m_animations.take(slice);
90	}	85	}
91		86
92	#include "moc_pieanimation_p.cpp"	87	#include "moc_pieanimation_p.cpp"
93		88
94	QTCOMMERCIALCHART_END_NAMESPACE	89	QTCOMMERCIALCHART_END_NAMESPACE

src/animations/pieanimation_p.h +3 -1

             #ifndef PIEANIMATION_P_H_
             #define PIEANIMATION_P_H_
             #include "chartanimation_p.h"
             #include "piechartitem_p.h"
             #include "piesliceanimation_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieChartItem;
             class PieAnimation : public ChartAnimation
             {
                 Q_OBJECT
             public:
                 PieAnimation(PieChartItem *item);
                 ~PieAnimation();
-                void setValues(QVector<PieSliceLayout>& newValues);
+                void updateValues(QVector<PieSliceLayout>& newValues);
                 void updateValue(PieSliceLayout& newValue);
+                void addSlice(QPieSlice *slice, PieSliceLayout endLayout);
+                void removeSlice(QPieSlice *slice);
             public: // from QVariantAnimation
                 void updateCurrentValue(const QVariant &value);
             public Q_SLOTS:
                 void destroySliceAnimationComplete();
             private:
                 PieChartItem *m_item;
                 QHash<QPieSlice*, PieSliceAnimation*> m_animations;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/piechart/piechartitem.cpp +72 -68

             #include "piechartitem_p.h"
             #include "pieslice_p.h"
             #include "qpieslice.h"
             #include "qpieseries.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QDebug>
             #include <QPainter>
+            #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieChartItem::PieChartItem(QGraphicsItem *parent, QPieSeries *series)
                 :ChartItem(parent),
                 m_series(series)
             {
                 Q_ASSERT(series);
-                connect(series, SIGNAL(changed()), this, SLOT(handleSeriesChanged()));
+                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);
             }
             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::handleSeriesChanged()
+            void PieChartItem::initialize()
+            {
+                handleSlicesAdded(m_series->m_slices);
+            }
+            void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices)
+            {
+                foreach (QPieSlice *s, slices) {
+                    PieSlice* slice = new PieSlice(this);
+                    m_slices.insert(s, slice);
+                    connect(s, SIGNAL(changed()), this, SLOT(handleSliceChanged()));
+                    connect(slice, SIGNAL(clicked()), s, SIGNAL(clicked()));
+                    connect(slice, SIGNAL(hoverEnter()), s, SIGNAL(hoverEnter()));
+                    connect(slice, SIGNAL(hoverLeave()), s, SIGNAL(hoverLeave()));
+                    PieSliceLayout layout = calculateSliceLayout(s);
+                    if (m_animator)
+                        m_animator->addAnimation(this, s, layout);
+                    else
+                        setLayout(layout);
+                }
+            }
+            void PieChartItem::handleSlicesRemoved(QList<QPieSlice*> slices)
+            {
+                foreach (QPieSlice *s, slices) {
+                    if (m_animator)
+                        m_animator->removeAnimation(this, s);
+                    else
+                        destroySlice(s);
+                }
+            }
+            void PieChartItem::handlePieLayoutChanged()
             {
                 QVector<PieSliceLayout> layout = calculateLayout();
                 applyLayout(layout);
                 update();
             }
             void PieChartItem::handleSliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
+                PieSliceLayout layout = calculateSliceLayout(slice);
-                //qDebug() << "PieChartItem::handleSliceChanged" << slice->label();
+                updateLayout(layout);
-                // TODO: Optimize. No need to calculate everything.
-                QVector<PieSliceLayout> layout = calculateLayout();
-                foreach (PieSliceLayout sl, layout) {
-                    if (sl.m_data == slice)
-                        updateLayout(sl);
                 update();
             }
             void PieChartItem::handleDomainChanged(qreal, qreal, qreal, qreal)
             {
                 // TODO
             }
             void PieChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
-                QVector<PieSliceLayout> sliceLayout = calculateLayout();
+                handlePieLayoutChanged();
-                applyLayout(sliceLayout);
-                update();
             }
+            void PieChartItem::calculatePieLayout()
-            QVector<PieSliceLayout> PieChartItem::calculateLayout()
             {
                 // find pie center coordinates
-                QPointF center;
+                m_pieCenter.setX(m_rect.left() + (m_rect.width() * m_series->pieHorizontalPosition()));
-                center.setX(m_rect.left() + (m_rect.width() * m_series->pieHorizontalPosition()));
+                m_pieCenter.setY(m_rect.top() + (m_rect.height() * m_series->pieVerticalPosition()));
-                center.setY(m_rect.top() + (m_rect.height() * m_series->pieVerticalPosition()));
                 // find maximum radius for pie
-                qreal radius = m_rect.height() / 2;
+                m_pieRadius = m_rect.height() / 2;
                 if (m_rect.width() < m_rect.height())
-                    radius = m_rect.width() / 2;
+                    m_pieRadius = m_rect.width() / 2;
                 // apply size factor
-                radius *= m_series->pieSize();
+                m_pieRadius *= m_series->pieSize();
+            }
+            PieSliceLayout PieChartItem::calculateSliceLayout(QPieSlice *slice)
+            {
+                PieSliceLayout sliceLayout;
+                sliceLayout.m_data = slice;
+                sliceLayout.m_center = PieSlice::sliceCenter(m_pieCenter, m_pieRadius, slice);
+                sliceLayout.m_radius = m_pieRadius;
+                sliceLayout.m_startAngle = slice->startAngle();
+                sliceLayout.m_angleSpan = slice->m_angleSpan;
+                return sliceLayout;
+            }
+            QVector<PieSliceLayout> PieChartItem::calculateLayout()
+            {
+                calculatePieLayout();
                 QVector<PieSliceLayout> layout;
                 foreach (QPieSlice* s, m_series->slices()) {
-                    PieSliceLayout sliceLayout;
+                    if (m_slices.contains(s)) // calculate layout only for those slices that are already visible
-                    sliceLayout.m_data = s;
+                        layout << calculateSliceLayout(s);
-                    sliceLayout.m_center = PieSlice::sliceCenter(center, radius, s);
-                    sliceLayout.m_radius = radius;
-                    sliceLayout.m_startAngle = s->startAngle();
-                    sliceLayout.m_angleSpan = s->m_angleSpan;
-                    layout << sliceLayout;
                 }
                 return layout;
             }
             void PieChartItem::applyLayout(QVector<PieSliceLayout> &layout)
             {
                 if (m_animator)
-                    m_animator->applyLayout(this, layout);
+                    m_animator->updateLayout(this, layout);
                 else
                     setLayout(layout);
             }
             void PieChartItem::updateLayout(PieSliceLayout &layout)
             {
                 if (m_animator)
                     m_animator->updateLayout(this, layout);
                 else
                     setLayout(layout);
             }
             void PieChartItem::setLayout(QVector<PieSliceLayout> &layout)
             {
                 foreach (PieSliceLayout l, layout) {
-                    // find slice
                     PieSlice *slice = m_slices.value(l.m_data);
-                    if (!slice) {
+                    Q_ASSERT(slice);
-                        // add a new slice
-                        slice = new PieSlice(this);
-                        m_slices.insert(l.m_data, slice);
-                        // connect signals
-                        connect(l.m_data, SIGNAL(changed()), this, SLOT(handleSliceChanged()));
-                        connect(slice, SIGNAL(clicked()), l.m_data, SIGNAL(clicked()));
-                        connect(slice, SIGNAL(hoverEnter()), l.m_data, SIGNAL(hoverEnter()));
-                        connect(slice, SIGNAL(hoverLeave()), l.m_data, SIGNAL(hoverLeave()));
-                    // update
                     slice->setLayout(l);
+                    slice->updateData(l.m_data);
                     slice->updateGeometry();
                     slice->update();
                 }
-                // delete slices
-                foreach (QPieSlice *s, m_slices.keys()) {
-                    bool found = false;
-                    foreach (PieSliceLayout l, layout) {
-                        if (l.m_data == s)
-                            found = true;
-                    if (!found)
-                        destroySlice(s);
             }
             void PieChartItem::setLayout(PieSliceLayout &layout)
             {
                 // find slice
                 PieSlice *slice = m_slices.value(layout.m_data);
-                if (!slice) {
+                Q_ASSERT(slice);
-                    slice = new PieSlice(this);
-                    m_slices.insert(layout.m_data, slice);
-                    connect(layout.m_data, SIGNAL(changed()), this, SLOT(handleSliceChanged()));
-                    connect(slice, SIGNAL(clicked()), layout.m_data, SIGNAL(clicked()));
-                    connect(slice, SIGNAL(hoverEnter()), layout.m_data, SIGNAL(hoverEnter()));
-                    connect(slice, SIGNAL(hoverLeave()), layout.m_data, SIGNAL(hoverLeave()));
                 slice->setLayout(layout);
                 if (m_series->m_slices.contains(layout.m_data)) // Slice has been deleted if not found. Animations ongoing...
                     slice->updateData(layout.m_data);
                 slice->updateGeometry();
                 slice->update();
             }
             void PieChartItem::destroySlice(QPieSlice *slice)
             {
                 delete m_slices.take(slice);
             }
             #include "moc_piechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piechartitem_p.h +6 -1

             #ifndef PIECHARTITEM_H
             #define PIECHARTITEM_H
             #include "qpieseries.h"
             #include "chartitem_p.h"
             #include "pieslice_p.h"
             class QGraphicsItem;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSlice;
             class PieChartItem : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
                 // TODO: use a generic data class instead of x and y
                 PieChartItem(QGraphicsItem *parent, QPieSeries *series);
                 ~PieChartItem();
             public: // from QGraphicsItem
                 QRectF boundingRect() const { return m_rect; }
                 void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *);
             public Q_SLOTS:
-                void handleSeriesChanged();
+                void initialize();
+                void handleSlicesAdded(QList<QPieSlice*> slices);
+                void handleSlicesRemoved(QList<QPieSlice*> slices);
+                void handlePieLayoutChanged();
                 void handleSliceChanged();
                 void handleDomainChanged(qreal, qreal, qreal, qreal);
                 void handleGeometryChanged(const QRectF& rect);
             public:
+                void calculatePieLayout();
+                PieSliceLayout calculateSliceLayout(QPieSlice *slice);
                 QVector<PieSliceLayout> calculateLayout();
                 void applyLayout(QVector<PieSliceLayout> &layout);
                 void updateLayout(PieSliceLayout &layout);
                 void setLayout(QVector<PieSliceLayout> &layout);
                 void setLayout(PieSliceLayout &layout);
                 void destroySlice(QPieSlice *slice);
             private:
                 friend class PieSlice;
                 QHash<QPieSlice*, PieSlice*> m_slices;
                 QPieSeries *m_series;
                 QRectF m_rect;
                 QPointF m_pieCenter;
                 qreal m_pieRadius;
                 QRectF m_debugRect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIECHARTITEM_H

src/piechart/pieslice.cpp +3 -2

             #include "pieslice_p.h"
             #include "piechartitem_p.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QDebug>
             #include <qmath.h>
             #include <QGraphicsSceneEvent>
             #include <QTime>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             #define PI 3.14159265 // TODO: is this defined in some header?
             QPointF offset(qreal angle, qreal length)
             {
                 qreal dx = qSin(angle*(PI/180)) * length;
                 qreal dy = qCos(angle*(PI/180)) * length;
                 return QPointF(dx, -dy);
             }
             PieSlice::PieSlice(QGraphicsItem* parent)
                 :QGraphicsObject(parent),
                 m_isExploded(false),
                 m_explodeDistanceFactor(0),
                 m_labelVisible(false),
                 m_labelArmLengthFactor(0)
             {
                 setAcceptHoverEvents(true);
                 setAcceptedMouseButtons(Qt::LeftButton);
                 setZValue(ChartPresenter::PieSeriesZValue);
             }
             PieSlice::~PieSlice()
             {
             }
             QRectF PieSlice::boundingRect() const
             {
-                return m_slicePath.boundingRect().united(m_labelTextRect);
+                return m_boundingRect;
             }
             QPainterPath PieSlice::shape() const
             {
                 // Don't include the label and label arm.
                 // This is used to detect a mouse clicks. We do not want clicks from label.
                 return m_slicePath;
             }
             void PieSlice::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
             {
                 painter->setClipRect(parentItem()->boundingRect());
                 painter->save();
                 painter->setPen(m_slicePen);
                 painter->setBrush(m_sliceBrush);
                 painter->drawPath(m_slicePath);
                 painter->restore();
                 if (m_labelVisible) {
                     painter->save();
                     painter->setPen(m_labelArmPen);
                     painter->drawPath(m_labelArmPath);
                     painter->restore();
                     painter->setFont(m_labelFont);
                     painter->drawText(m_labelTextRect.bottomLeft(), m_labelText);
                 }
             }
             void PieSlice::hoverEnterEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverEnter();
             }
             void PieSlice::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverLeave();
             }
             void PieSlice::mousePressEvent(QGraphicsSceneMouseEvent* /*event*/)
             {
                 emit clicked();
             }
             void PieSlice::setLayout(PieSliceLayout layout)
             {
                 m_layout = layout;
             }
             void PieSlice::updateGeometry()
             {
                 if (m_layout.m_radius <= 0)
                     return;
                 prepareGeometryChange();
                 // update slice path
                 qreal centerAngle;
                 QPointF armStart;
                 m_slicePath = slicePath(m_layout.m_center, m_layout.m_radius, m_layout.m_startAngle, m_layout.m_angleSpan, &centerAngle, &armStart);
                 // update text rect
                 m_labelTextRect = labelTextRect(m_labelFont, m_labelText);
                 // update label arm path
                 QPointF labelTextStart;
                 m_labelArmPath = labelArmPath(armStart, centerAngle, m_layout.m_radius * m_labelArmLengthFactor, m_labelTextRect.width(), &labelTextStart);
                 // update text position
                 m_labelTextRect.moveBottomLeft(labelTextStart);
-                //qDebug() << "PieSlice::updateGeometry" << m_labelText << boundingRect() << m_startAngle << m_startAngle + m_angleSpan;
+                // update bounding rect
+                m_boundingRect = m_slicePath.boundingRect().united(m_labelArmPath.boundingRect()).united(m_labelTextRect);
             }
             void PieSlice::updateData(const QPieSlice* sliceData)
             {
                 // TODO: compare what has changes to avoid unneccesary geometry updates
                 m_isExploded = sliceData->isExploded();
                 m_explodeDistanceFactor = sliceData->explodeDistanceFactor();
                 m_slicePen = sliceData->slicePen();
                 m_sliceBrush = sliceData->sliceBrush();
                 m_labelVisible = sliceData->isLabelVisible();
                 m_labelText = sliceData->label();
                 m_labelFont = sliceData->labelFont();
                 m_labelArmLengthFactor = sliceData->labelArmLengthFactor();
                 m_labelArmPen = sliceData->labelArmPen();
             }
             QPointF PieSlice::sliceCenter(QPointF point, qreal radius, QPieSlice *slice)
             {
                 if (slice->isExploded()) {
                     qreal centerAngle = slice->startAngle() + (slice->m_angleSpan/2);
                     qreal len = radius * slice->explodeDistanceFactor();
                     qreal dx = qSin(centerAngle*(PI/180)) * len;
                     qreal dy = -qCos(centerAngle*(PI/180)) * len;
                     point += QPointF(dx, dy);
                 }
                 return point;
             }
             QPainterPath PieSlice::slicePath(QPointF center, qreal radius, qreal startAngle, qreal angleSpan, qreal* centerAngle, QPointF* armStart)
             {
                 // calculate center angle
                 *centerAngle = startAngle + (angleSpan/2);
                 // calculate slice rectangle
                 QRectF rect(center.x()-radius, center.y()-radius, radius*2, radius*2);
                 // slice path
                 // TODO: draw the shape so that it might have a hole in the center
                 QPainterPath path;
                 path.moveTo(rect.center());
                 path.arcTo(rect, -startAngle + 90, -angleSpan);
                 path.closeSubpath();
                 // calculate label arm start point
                 *armStart = center;
                 *armStart += offset(*centerAngle, radius + PIESLICE_LABEL_GAP);
                 return path;
             }
             QPainterPath PieSlice::labelArmPath(QPointF start, qreal angle, qreal length, qreal textWidth, QPointF* textStart)
             {
                 qreal dx = qSin(angle*(PI/180)) * length;
                 qreal dy = -qCos(angle*(PI/180)) * length;
                 QPointF parm1 = start + QPointF(dx, dy);
                 QPointF parm2 = parm1;
                 if (angle < 180) { // arm swings the other way on the left side
                      parm2 += QPointF(textWidth, 0);
                      *textStart = parm1;
                 }
                 else {
                      parm2 += QPointF(-textWidth,0);
                      *textStart = parm2;
                 }
                 // elevate the text position a bit so that it does not hit the line
                 *textStart += QPointF(0, -5);
                 QPainterPath path;
                 path.moveTo(start);
                 path.lineTo(parm1);
                 path.lineTo(parm2);
                 return path;
             }
             QRectF PieSlice::labelTextRect(QFont font, QString text)
             {
                 QFontMetricsF fm(font);
                 return fm.boundingRect(text);
             }
             #include "moc_pieslice_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslice_p.h +1 0

             #ifndef PIESLICE_H
             #define PIESLICE_H
             #include "qchartglobal.h"
             #include "charttheme_p.h"
             #include "qpieseries.h"
             #include <QGraphicsItem>
             #include <QRectF>
             #include <QColor>
             #include <QPen>
             #define PIESLICE_LABEL_GAP 5
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieChartItem;
             class PieSliceLabel;
             class QPieSlice;
             class PieSliceLayout
             {
             public:
                 QPieSlice* m_data; // TODO: get rid of this
                 QPointF m_center;
                 qreal m_radius;
                 qreal m_startAngle;
                 qreal m_angleSpan;
             };
             class PieSlice : public QGraphicsObject
             {
                 Q_OBJECT
             public:
                 PieSlice(QGraphicsItem* parent = 0);
                 ~PieSlice();
             public: // from QGraphicsItem
                 QRectF boundingRect() const;
                 QPainterPath shape() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
                 void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
             Q_SIGNALS:
                 void clicked();
                 void hoverEnter();
                 void hoverLeave();
             public:
                 void setLayout(PieSliceLayout layout);
                 void updateGeometry();
                 void updateData(const QPieSlice *sliceData);
                 static QPointF sliceCenter(QPointF point, qreal radius, QPieSlice *slice);
                 static QPainterPath slicePath(QPointF center, qreal radius, qreal startAngle, qreal angleSpan, qreal* centerAngle, QPointF* armStart);
                 static QPainterPath labelArmPath(QPointF start, qreal angle, qreal length, qreal textWidth, QPointF* textStart);
                 static QRectF labelTextRect(QFont font, QString text);
             private:
                 PieSliceLayout m_layout;
+                QRectF m_boundingRect;
                 QPainterPath m_slicePath;
                 bool m_isExploded;
                 qreal m_explodeDistanceFactor;
                 bool m_labelVisible;
                 QPen m_slicePen;
                 QBrush m_sliceBrush;
                 QPainterPath m_labelArmPath;
                 qreal m_labelArmLengthFactor;
                 QPen m_labelArmPen;
                 QRectF m_labelTextRect;
                 QFont m_labelFont;
                 QString m_labelText;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESLICE_H

src/piechart/qpieseries.cpp +21 -14

             #include "qpieseries.h"
             #include "qpieslice.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries
                 \brief Pie series API for QtCommercial Charts
                 The pie series defines a pie chart which consists of pie slices which are 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),
                 m_pieRelativeHorPos(0.5),
                 m_pieRelativeVerPos(0.5),
                 m_pieRelativeSize(0.7),
                 m_pieStartAngle(0),
                 m_pieEndAngle(360),
                 m_total(0)
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QPieSeries::~QPieSeries()
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
             QSeries::QSeriesType QPieSeries::type() const
             {
                 return QSeries::SeriesTypePie;
             }
             /*!
                 Sets an array of \a slices to the series replacing the existing slices.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::replace(QList<QPieSlice*> slices)
             {
                 clear();
                 add(slices);
             }
             /*!
                 Adds an array of \a slices to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::add(QList<QPieSlice*> slices)
             {
                 foreach (QPieSlice* s, slices) {
                     s->setParent(this);
                     m_slices << s;
                 }
                 updateDerivativeData();
                 foreach (QPieSlice* s, slices) {
                     connect(s, SIGNAL(changed()), this, SLOT(sliceChanged()));
                     connect(s, SIGNAL(clicked()), this, SLOT(sliceClicked()));
                     connect(s, SIGNAL(hoverEnter()), this, SLOT(sliceHoverEnter()));
                     connect(s, SIGNAL(hoverLeave()), this, SLOT(sliceHoverLeave()));
                 }
-                emit changed();
+                emit added(slices);
             }
             /*!
                 Adds a single \a slice to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::add(QPieSlice* slice)
             {
                 add(QList<QPieSlice*>() << slice);
             }
             /*!
                 Adds a single \a slice to the series and returns a reference to the series.
                 Slice ownership is passed to the series.
             */
             QPieSeries& QPieSeries::operator << (QPieSlice* slice)
             {
                 add(slice);
                 return *this;
             }
             /*!
                 Adds a single slice to the series with give \a value and \a name.
                 Slice ownership is passed to the series.
             */
             QPieSlice* QPieSeries::add(qreal value, QString name)
             {
                 QPieSlice* slice = new QPieSlice(value, name);
                 add(slice);
                 return slice;
             }
             void QPieSeries::insert(int i, QPieSlice* slice)
             {
                 Q_ASSERT(i <= m_slices.count());
                 slice->setParent(this);
                 m_slices.insert(i, slice);
                 updateDerivativeData();
                 connect(slice, SIGNAL(changed()), this, SLOT(sliceChanged()));
                 connect(slice, SIGNAL(clicked()), this, SLOT(sliceClicked()));
                 connect(slice, SIGNAL(hoverEnter()), this, SLOT(sliceHoverEnter()));
                 connect(slice, SIGNAL(hoverLeave()), this, SLOT(sliceHoverLeave()));
-                emit changed();
+                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)
             {
                 if (!m_slices.removeOne(slice)) {
                     Q_ASSERT(0); // TODO: how should this be reported?
                     return;
                 }
-                emit changed();
                 updateDerivativeData();
+                emit removed(QList<QPieSlice*>() << slice);
                 delete slice;
                 slice = NULL;
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 if (m_slices.count() == 0)
                     return;
+                QList<QPieSlice*> slices = m_slices;
                 foreach (QPieSlice* s, m_slices) {
                     m_slices.removeOne(s);
                     delete s;
                 }
-                emit changed();
                 updateDerivativeData();
+                emit removed(slices);
             }
             /*!
                 Counts the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 return m_slices.count();
             }
             /*!
+                Returns true is the series is empty.
+            */
+            bool QPieSeries::isEmpty() const
+            {
+                return m_slices.isEmpty();
+            }
+            /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice*> QPieSeries::slices() const
             {
                 return m_slices;
             }
             /*!
                 Sets the center position of the pie by \a relativeHorizontalPosition and \a relativeVerticalPosition.
                 The factors are relative to the chart rectangle where:
                 \a relativeHorizontalPosition 0.0 means the absolute left.
                 \a relativeHorizontalPosition 1.0 means the absolute right.
                 \a relativeVerticalPosition 0.0 means the absolute top.
                 \a relativeVerticalPosition 1.0 means the absolute bottom.
                 By default both values are 0.5 which puts the pie in the middle of the chart rectangle.
                 \sa pieHorizontalPosition(), pieVerticalPosition(), setPieSize()
             */
             void QPieSeries::setPiePosition(qreal relativeHorizontalPosition, qreal relativeVerticalPosition)
             {
                 if (relativeHorizontalPosition < 0.0 || relativeHorizontalPosition > 1.0 ||
                         relativeVerticalPosition < 0.0 || relativeVerticalPosition > 1.0)
                     return;
                 if (m_pieRelativeHorPos != relativeHorizontalPosition || m_pieRelativeVerPos != relativeVerticalPosition) {
                     m_pieRelativeHorPos = relativeHorizontalPosition;
                     m_pieRelativeVerPos = relativeVerticalPosition;
-                    emit changed();
+                    emit piePositionChanged();
                 }
             }
             /*!
                 Gets the horizontal position of the pie.
                 The returned value is relative to the chart rectangle where:
 .0 means the absolute left.
 .0 means the absolute right.
                 By default it is 0.5 which puts the pie in the horizontal middle of the chart rectangle.
                 \sa setPiePosition(), pieVerticalPosition(), setPieSize()
             */
             qreal QPieSeries::pieHorizontalPosition() const
             {
                 return m_pieRelativeHorPos;
             }
             /*!
                 Gets the vertical position position of the pie.
                 The returned value is relative to the chart rectangle where:
 .0 means the absolute top.
 .0 means the absolute bottom.
                 By default it is 0.5 which puts the pie in the vertical middle of the chart rectangle.
                 \sa setPiePosition(), pieHorizontalPosition(), setPieSize()
             */
             qreal QPieSeries::pieVerticalPosition() const
             {
                 return 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)
             {
                 if (relativeSize < 0.0 || relativeSize > 1.0)
                     return;
                 if (m_pieRelativeSize != relativeSize) {
                     m_pieRelativeSize = relativeSize;
-                    emit changed();
+                    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
             {
                 return 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)
             {
                 if (angle >= 0 && angle <= 360 && angle != m_pieStartAngle && angle <= m_pieEndAngle) {
                     m_pieStartAngle = angle;
                     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
             {
                 return 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)
             {
                 if (angle >= 0 && angle <= 360 && angle != m_pieEndAngle && angle >= m_pieStartAngle) {
                     m_pieEndAngle = angle;
                     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
             {
                 return m_pieEndAngle;
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 foreach (QPieSlice* s, m_slices)
                     s->setLabelVisible(visible);
             }
             /*!
                 Returns the sum of all slice values in this series.
                 \sa QPieSlice::value(), QPieSlice::setValue()
             */
             qreal QPieSeries::total() const
             {
                 return m_total;
             }
             /*!
                 \fn void QPieSeries::changed()
                 This signal emitted when something has changed in the series.
                 \sa QPieSeries::ChangeSet, QPieSlice::changed()
             */
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice)
                 This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
             /*!
                 \fn void QPieSeries::hoverEnter(QPieSlice* slice)
                 This signal is emitted when user has hovered over a \a slice.
                 \sa QPieSlice::hoverEnter()
             */
             /*!
                 \fn void QPieSeries::hoverLeave(QPieSlice* slice)
                 This signal is emitted when user has hovered away from a \a slice.
                 \sa QPieSlice::hoverLeave()
             */
             void QPieSeries::sliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 updateDerivativeData();
             }
             void QPieSeries::sliceClicked()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit clicked(slice);
             }
             void QPieSeries::sliceHoverEnter()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit hoverEnter(slice);
             }
             void QPieSeries::sliceHoverLeave()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit hoverLeave(slice);
             }
             void QPieSeries::updateDerivativeData()
             {
                 m_total = 0;
                 // nothing to do?
                 if (m_slices.count() == 0)
                     return;
                 // calculate total
                 foreach (QPieSlice* s, m_slices)
                     m_total += s->value();
-                // TODO: emit totalChanged?
+                // nothing to show..
+                if (m_total == 0)
-                // we must have some values
+                    return;
-                if (m_total == 0) {
-                    qDebug() << "QPieSeries::updateDerivativeData() total == 0";
-                    Q_ASSERT(m_total > 0); // TODO: is this the correct way to handle this?
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
                 QVector<QPieSlice*> changed;
                 foreach (QPieSlice* s, m_slices) {
                     bool isChanged = false;
                     qreal percentage = s->value() / m_total;
                     if (s->m_percentage != percentage) {
                         s->m_percentage = percentage;
                         isChanged = true;
                     }
                     qreal sliceSpan = pieSpan * percentage;
                     if (s->m_angleSpan != sliceSpan) {
                         s->m_angleSpan = sliceSpan;
                         isChanged = true;
                     }
                     if (s->m_startAngle != sliceAngle) {
                         s->m_startAngle = sliceAngle;
                         isChanged = true;
                     }
                     sliceAngle += sliceSpan;
                     if (isChanged)
                         changed << s;
                 }
+                // emit signals
                 foreach (QPieSlice* s, changed)
                     emit s->changed();
             }
             bool QPieSeries::setModel(QAbstractItemModel* model)
             {
                 // disconnect signals from old model
                 if(m_model)
                 {
                     disconnect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), 0, 0);
                     disconnect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)), 0, 0);
                     disconnect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), 0, 0);
                 }
                 // set new model if not NULL and connect necessary signals from it
                 if(model)
                 {
                     m_model = model;
                     connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                     connect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 }
                 return true;
             }
             void QPieSeries::setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation)
             {
                 m_mapValues = modelValuesLine;
                 m_mapLabels = modelLabelsLine;
                 m_mapOrientation = orientation;
                 if (m_model == NULL)
                     return;
                 if (m_mapOrientation == Qt::Vertical)
                     for (int i = 0; i < m_model->rowCount(); i++)
                         add(m_model->data(m_model->index(i, m_mapValues), Qt::DisplayRole).toDouble(), m_model->data(m_model->index(i, m_mapLabels), Qt::DisplayRole).toString());
                 else
                     for (int i = 0; i < m_model->columnCount(); i++)
                         add(m_model->data(m_model->index(m_mapValues, i), Qt::DisplayRole).toDouble(), m_model->data(m_model->index(m_mapLabels, i), Qt::DisplayRole).toString());
             }
             void QPieSeries::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(bottomRight)
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     //        slices().at(topLeft.row())->setValue(m_model->data(m_model->index(topLeft.row(), topLeft.column()), Qt::DisplayRole).toDouble());
                     if (topLeft.column() == m_mapValues)
                         slices().at(topLeft.row())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                     else if (topLeft.column() == m_mapLabels)
                         slices().at(topLeft.row())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                 }
                 else
                 {
                     //        slices().at(topLeft.column())->setValue(m_model->data(m_model->index(topLeft.row(), topLeft.column()), Qt::DisplayRole).toDouble());
                     if (topLeft.column() == m_mapValues)
                         slices().at(topLeft.column())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                     else if (topLeft.column() == m_mapLabels)
                         slices().at(topLeft.column())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                 }
             }
             void QPieSeries::modelDataAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 QPieSlice* newSlice = new QPieSlice;
                 newSlice->setLabelVisible(true);
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     newSlice->setValue(m_model->data(m_model->index(start, m_mapValues), Qt::DisplayRole).toDouble());
                     newSlice->setLabel(m_model->data(m_model->index(start, m_mapLabels), Qt::DisplayRole).toString());
                 }
                 else
                 {
                     newSlice->setValue(m_model->data(m_model->index(m_mapValues, start), Qt::DisplayRole).toDouble());
                     newSlice->setLabel(m_model->data(m_model->index(m_mapLabels, start), Qt::DisplayRole).toString());
                 }
                 insert(start, newSlice);
             }
             void QPieSeries::modelDataRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 remove(slices().at(start));
             }
             #include "moc_qpieseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.h +7 -1

             #ifndef PIESERIES_H
             #define PIESERIES_H
             #include "qseries.h"
             #include <QObject>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSlice;
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 QPieSeries(QObject *parent = 0);
                 virtual ~QPieSeries();
             public: // from QChartSeries
                 QSeriesType type() const;
             public:
                 // slice setters
                 void add(QPieSlice* slice);
                 void add(QList<QPieSlice*> slices);
                 void insert(int i, QPieSlice* slice);
                 void replace(QList<QPieSlice*> slices);
                 void remove(QPieSlice* slice);
                 void clear();
                 // sluce getters
                 QList<QPieSlice*> slices() const;
                 // calculated data
                 int count() const;
+                bool isEmpty() const;
                 qreal total() const;
                 // pie customization
                 void setPiePosition(qreal relativeHorizontalPosition, qreal relativeVerticalPosition);
                 qreal pieHorizontalPosition() const;
                 qreal pieVerticalPosition() const;
                 void setPieSize(qreal relativeSize);
                 qreal pieSize() const;
                 void setPieStartAngle(qreal startAngle);
                 qreal pieStartAngle() const;
                 void setPieEndAngle(qreal endAngle);
                 qreal pieEndAngle() const;
                 // convenience function
                 QPieSeries& operator << (QPieSlice* slice);
                 QPieSlice* add(qreal value, QString name);
                 void setLabelsVisible(bool visible = true);
                 // data from model
                 bool setModel(QAbstractItemModel* model);
                 void setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation = Qt::Vertical);
                 // TODO: find slices?
                 // QList<QPieSlice*> findByValue(qreal value);
                 // ...
                 // TODO: sorting slices?
                 // void sort(QPieSeries::SortByValue|label|??)
                 // TODO: general graphics customization
                 // setDrawStyle(2d|3d)
                 // setDropShadows
             Q_SIGNALS:
                 void clicked(QPieSlice* slice);
                 void hoverEnter(QPieSlice* slice);
                 void hoverLeave(QPieSlice* slice);
-                void changed(); // TODO: hide this in PIMPL
+                // TODO: hide these in PIMPL
+                void added(QList<QPieSlice*> slices);
+                void removed(QList<QPieSlice*> slices);
+                void piePositionChanged();
+                void pieSizeChanged();
             private Q_SLOTS: // TODO: should be private and not visible in the interface at all
                 void sliceChanged();
                 void sliceClicked();
                 void sliceHoverEnter();
                 void sliceHoverLeave();
                 // slots for updating pie when data in model changes
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelDataAdded(QModelIndex parent, int start, int end);
                 void modelDataRemoved(QModelIndex parent, int start, int end);
             private:
                 void updateDerivativeData();
             private:
                 Q_DISABLE_COPY(QPieSeries)
                 // TODO: use PIML
                 friend class PieChartItem;
                 friend class PieSlice;
                 friend class QPieSlice;
                 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 // PIESERIES_H

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