HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r618:249071e508d1

Add animations to pie. Works but has some visual issues when adding slices.

Jani Honkonen -

r618:249071e508d1

parent child

Context file:

r618:249071e508d1

Collapse all files

src/animations/pieanimation.cpp created 644 +94 0

@@ -0,0 +1,94
	1	#include "PieAnimation_p.h"
	2	#include "piesliceanimation_p.h"
	3	#include "piechartitem_p.h"
	4	#include <QParallelAnimationGroup>
	5	#include <QTimer>
	6
	7	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	8
	9	PieAnimation::PieAnimation(PieChartItem *item)
	10	:ChartAnimation(item),
	11	m_item(item)
	12	{
	13	}
	14
	15	PieAnimation::~PieAnimation()
	16	{
	17	}
	18
	19	void PieAnimation::setValues(QVector<PieSliceLayout>& newValues)
	20	{
	21	PieSliceAnimation *animation = 0;
	22
	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	}
	67
	68	void PieAnimation::updateValue(PieSliceLayout& endLayout)
	69	{
	70	PieSliceAnimation *animation = m_animations.value(endLayout.m_data);
	71	Q_ASSERT(animation);
	72	animation->stop();
	73	animation->updateValue(endLayout);
	74	animation->setDuration(1000);
	75	animation->setEasingCurve(QEasingCurve::OutQuart);
	76	QTimer::singleShot(0, animation, SLOT(start()));
	77	}
	78
	79	void PieAnimation::updateCurrentValue(const QVariant &)
	80	{
	81	// nothing to do...
	82	}
	83
	84	void PieAnimation::destroySliceAnimationComplete()
	85	{
	86	PieSliceAnimation animation = static_cast<PieSliceAnimation>(sender());
	87	QPieSlice *slice = m_animations.key(animation);
	88	m_item->destroySlice(slice);
	89	delete m_animations.take(slice);
	90	}
	91
	92	#include "moc_pieanimation_p.cpp"
	93
	94	QTCOMMERCIALCHART_END_NAMESPACE

src/animations/pieanimation_p.h created 644 +35 0

@@ -0,0 +1,35
	1	#ifndef PIEANIMATION_P_H_
	2	#define PIEANIMATION_P_H_
	3
	4	#include "chartanimation_p.h"
	5	#include "piechartitem_p.h"
	6	#include "piesliceanimation_p.h"
	7
	8	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	9
	10	class PieChartItem;
	11
	12	class PieAnimation : public ChartAnimation
	13	{
	14	Q_OBJECT
	15
	16	public:
	17	PieAnimation(PieChartItem *item);
	18	~PieAnimation();
	19	void setValues(QVector<PieSliceLayout>& newValues);
	20	void updateValue(PieSliceLayout& newValue);
	21
	22	public: // from QVariantAnimation
	23	void updateCurrentValue(const QVariant &value);
	24
	25	public Q_SLOTS:
	26	void destroySliceAnimationComplete();
	27
	28	private:
	29	PieChartItem *m_item;
	30	QHash<QPieSlice, PieSliceAnimation> m_animations;
	31	};
	32
	33	QTCOMMERCIALCHART_END_NAMESPACE
	34
	35	#endif

src/animations/piesliceanimation.cpp created 644 +77 0

@@ -0,0 +1,77
	1	#include "PieSliceAnimation_p.h"
	2	#include "piechartitem_p.h"
	3	#include "qpieslice.h"
	4
	5	Q_DECLARE_METATYPE(QtCommercialChart::PieSliceLayout)
	6
	7	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	8
	9	qreal linearPos(qreal start, qreal end, qreal pos)
	10	{
	11	return start + ((end - start) * pos);
	12	}
	13
	14	QPointF linearPos(QPointF start, QPointF end, qreal pos)
	15	{
	16	qreal x = linearPos(start.x(), end.x(), pos);
	17	qreal y = linearPos(start.y(), end.y(), pos);
	18	return QPointF(x, y);
	19	}
	20
	21	PieSliceAnimation::PieSliceAnimation(PieChartItem *item)
	22	:QVariantAnimation(item),
	23	m_item(item)
	24	{
	25	}
	26
	27	PieSliceAnimation::~PieSliceAnimation()
	28	{
	29	}
	30
	31	void PieSliceAnimation::setValue(PieSliceLayout& startValue, PieSliceLayout& endValue)
	32	{
	33	if (state() != QAbstractAnimation::Stopped)
	34	stop();
	35
	36	setKeyValueAt(0.0, qVariantFromValue(startValue));
	37	setKeyValueAt(1.0, qVariantFromValue(endValue));
	38	}
	39
	40	void PieSliceAnimation::updateValue(PieSliceLayout& endValue)
	41	{
	42	if (state() != QAbstractAnimation::Stopped)
	43	stop();
	44
	45	//qDebug() << "PieSliceAnimation::updateValue()" << endValue.m_data->label() << currentSliceValue().m_startAngle << endValue.m_startAngle;
	46
	47	setKeyValueAt(0.0, qVariantFromValue(currentSliceValue()));
	48	setKeyValueAt(1.0, qVariantFromValue(endValue));
	49	}
	50
	51	PieSliceLayout PieSliceAnimation::currentSliceValue()
	52	{
	53	return qVariantValue<PieSliceLayout>(currentValue());
	54	}
	55
	56	QVariant PieSliceAnimation::interpolated(const QVariant &start, const QVariant &end, qreal progress) const
	57	{
	58	PieSliceLayout startValue = qVariantValue<PieSliceLayout>(start);
	59	PieSliceLayout endValue = qVariantValue<PieSliceLayout>(end);
	60
	61	PieSliceLayout result;
	62	result = endValue;
	63	result.m_center = linearPos(startValue.m_center, endValue.m_center, progress);
	64	result.m_radius = linearPos(startValue.m_radius, endValue.m_radius, progress);
	65	result.m_startAngle = linearPos(startValue.m_startAngle, endValue.m_startAngle, progress);
	66	result.m_angleSpan = linearPos(startValue.m_angleSpan, endValue.m_angleSpan, progress);
	67
	68	return qVariantFromValue(result);
	69	}
	70
	71	void PieSliceAnimation::updateCurrentValue(const QVariant &value)
	72	{
	73	if (state() != QAbstractAnimation::Stopped) //workaround
	74	m_item->setLayout(qVariantValue<PieSliceLayout>(value));
	75	}
	76
	77	QTCOMMERCIALCHART_END_NAMESPACE

src/animations/piesliceanimation_p.h created 644 +30 0

@@ -0,0 +1,30
	1	#ifndef PIESLICEANIMATION_P_H_
	2	#define PIESLICEANIMATION_P_H_
	3
	4	#include "piechartitem_p.h"
	5	#include <QVariantAnimation>
	6
	7	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	8
	9	class PieChartItem;
	10
	11	class PieSliceAnimation : public QVariantAnimation
	12	{
	13	public:
	14	PieSliceAnimation(PieChartItem *item);
	15	~PieSliceAnimation();
	16	void setValue(PieSliceLayout& startValue, PieSliceLayout& endValue);
	17	void updateValue(PieSliceLayout& endValue);
	18	PieSliceLayout currentSliceValue();
	19
	20	protected:
	21	QVariant interpolated(const QVariant &start, const QVariant &end, qreal progress) const;
	22	void updateCurrentValue(const QVariant &value);
	23
	24	private:
	25	PieChartItem *m_item;
	26	};
	27
	28	QTCOMMERCIALCHART_END_NAMESPACE
	29
	30	#endif

demos/piechartcustomization/main.cpp +22 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");
                     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);
                     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()));
                     // 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 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"

src/animations/animations.pri +6 -2

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/axisanimation.cpp \
                 $$PWD/chartanimator.cpp \
-                $$PWD/xyanimation.cpp
+                $$PWD/xyanimation.cpp \
+                $$PWD/pieanimation.cpp \
+                $$PWD/piesliceanimation.cpp
             PRIVATE_HEADERS += \
                 $$PWD/axisanimation_p.h \
                 $$PWD/chartanimator_p.h \
                 $$PWD/chartanimation_p.h \
-                $$PWD/xyanimation_p.h
  No newline at end of file
+                $$PWD/xyanimation_p.h \
+                $$PWD/pieanimation_p.h \
+                $$PWD/piesliceanimation_p.h

src/animations/chartanimator.cpp +27 0

             #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)
+            {
+                PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
+                Q_ASSERT(animation);
+                animation->setValues(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 +5 0

             #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 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/chartpresenter.cpp +1 -1

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             //series
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "areachartitem_p.h"
             #include "barpresenter_p.h"
             #include "stackedbarpresenter_p.h"
             #include "percentbarpresenter_p.h"
             #include "linechartitem_p.h"
             #include "piechartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "splinechartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
                 m_chart(chart),
                 m_animator(0),
                 m_dataset(dataset),
                 m_chartTheme(0),
                 m_zoomIndex(0),
                 m_marginSize(0),
                 m_rect(QRectF(QPoint(0,0),m_chart->size())),
                 m_options(QChart::NoAnimation)
             {
                 createConnections();
                 setChartTheme(QChart::ChartThemeDefault);
             }
             ChartPresenter::~ChartPresenter()
             {
             	delete m_chartTheme;
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),this,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),this,SLOT(handleSeriesRemoved(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*,Domain*)),this,SLOT(handleAxisAdded(QChartAxis*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 QRectF rect(QPoint(0,0),m_chart->size());
                 rect.adjust(m_marginSize,m_marginSize, -m_marginSize, -m_marginSize);
                 //rewrite zoom stack
                 for(int i=0;i<m_zoomStack.count();i++){
                     QRectF r = m_zoomStack[i];
                     qreal w = rect.width()/m_rect.width();
                     qreal h = rect.height()/m_rect.height();
                     QPointF tl = r.topLeft();
                     tl.setX(tl.x()*w);
                     tl.setY(tl.y()*h);
                     QPointF br = r.bottomRight();
                     br.setX(br.x()*w);
                     br.setY(br.y()*h);
                     r.setTopLeft(tl);
                     r.setBottomRight(br);
                     m_zoomStack[i]=r;
                 }
                 m_rect = rect;
                 Q_ASSERT(m_rect.isValid());
                 emit geometryChanged(m_rect);
             }
             int ChartPresenter::margin() const
             {
                 return m_marginSize;
             }
             void ChartPresenter::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
             void ChartPresenter::handleAxisAdded(QChartAxis* axis,Domain* domain)
             {
                 AxisItem* item = new AxisItem(axis,this,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
                     m_animator->addAnimation(item);
                 }
                 if(axis==m_dataset->axisX()){
                     m_chartTheme->decorate(axis,true);
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minX(),domain->maxX(),domain->tickXCount());
                 }
                 else{
                     m_chartTheme->decorate(axis,false);
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY(),domain->tickYCount());
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                 //initialize
                 item->handleGeometryChanged(m_rect);
                 m_axisItems.insert(axis, item);
             }
             void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
             {
                 AxisItem* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 if(m_animator) m_animator->removeAnimation(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain)
             {
             	ChartItem *item = 0 ;
                 switch(series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                     LineChartItem* line = new LineChartItem(lineSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                     	m_animator->addAnimation(line);
                     }
                     m_chartTheme->decorate(lineSeries, m_dataset->seriesIndex(series));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),line,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),line,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item = line;
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
                     QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                     AreaChartItem* area = new AreaChartItem(areaSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                        m_animator->addAnimation(area->upperLineItem());
                        if(areaSeries->lowerSeries())  m_animator->addAnimation(area->lowerLineItem());
                     }
                     m_chartTheme->decorate(areaSeries, m_dataset->seriesIndex(series));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),area,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),area,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=area;
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     BarPresenter* bar = new BarPresenter(barSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                      //  m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(barSeries, m_dataset->seriesIndex(barSeries));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
                     QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                     StackedBarPresenter* bar = new StackedBarPresenter(stackedBarSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                      //  m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(stackedBarSeries, m_dataset->seriesIndex(stackedBarSeries));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
                     QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                     PercentBarPresenter* bar = new PercentBarPresenter(percentBarSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                      //  m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(percentBarSeries, m_dataset->seriesIndex(percentBarSeries));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
                 	QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
                         ScatterChartItem *scatter = new ScatterChartItem(scatterSeries, m_chart);
                         if(m_options.testFlag(QChart::SeriesAnimations)) {
                             m_animator->addAnimation(scatter);
                         }
                         m_chartTheme->decorate(scatterSeries, m_dataset->seriesIndex(series));
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),scatter,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),scatter,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                         item = scatter;
                         break;
             	}
                 case QSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     PieChartItem* pie = new PieChartItem(m_chart, pieSeries);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
-                       // m_animator->addAnimation(pie);
+                        m_animator->addAnimation(pie);
                     }
                     m_chartTheme->decorate(pieSeries, m_dataset->seriesIndex(series));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),pie,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),pie,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     // Hide all from background when there is only piechart
                     // TODO: refactor this ugly code... should be one setting for this
                     if (m_chartItems.count() == 0) {
                         m_chart->axisX()->hide();
                         m_chart->axisY()->hide();
                         m_chart->setChartBackgroundBrush(Qt::transparent);
                     }
                     item=pie;
                     break;
                 }
                 case QSeries::SeriesTypeSpline: {
                     QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
                     SplineChartItem* spline  = new SplineChartItem(splineSeries, m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(spline);
                     }
                     m_chartTheme->decorate(splineSeries, m_dataset->seriesIndex(series));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),spline,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),spline,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=spline;
                     break;
                 }
                 default: {
                     qDebug()<< "Series type" << series->type() << "not implemented.";
                     break;
                 }
                 }
                 //initialize
                 item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                 m_chartItems.insert(series,item);
                 zoomReset();
             }
             void ChartPresenter::handleSeriesRemoved(QSeries* series)
             {
                 ChartItem* item = m_chartItems.take(series);
                 Q_ASSERT(item);
                 if(m_animator) {
                     //small hack to handle area animations
                     if(series->type()==QSeries::SeriesTypeArea){
                          QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                          AreaChartItem* area = static_cast<AreaChartItem*>(item);
                          m_animator->removeAnimation(area->upperLineItem());
                          if(areaSeries->lowerSeries())  m_animator->addAnimation(area->lowerLineItem());
                     }else
                     m_animator->removeAnimation(item);
                 }
                 delete item;
             }
             void ChartPresenter::setChartTheme(QChart::ChartTheme theme)
             {
             	if(m_chartTheme && m_chartTheme->id() == theme) return;
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart);
                 m_chartTheme->decorate(m_chart->legend());
                 resetAllElements();
             }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     if(m_options!=QChart::NoAnimation && !m_animator) {
                         m_animator= new ChartAnimator(this);
                     }
                     resetAllElements();
                 }
             }
             void ChartPresenter::resetAllElements()
             {
                  QList<QChartAxis*> axisList = m_axisItems.uniqueKeys();
                  QList<QSeries*> seriesList = m_chartItems.uniqueKeys();
                  foreach(QChartAxis* axis, axisList) {
                      handleAxisRemoved(axis);
                      handleAxisAdded(axis,m_dataset->domain(axis));
                  }
                  foreach(QSeries* series, seriesList) {
                      handleSeriesRemoved(series);
                      handleSeriesAdded(series,m_dataset->domain(series));
                  }
             }
             void ChartPresenter::zoomIn()
             {
             	QRectF rect = geometry();
             	rect.setWidth(rect.width()/2);
             	rect.setHeight(rect.height()/2);
             	rect.moveCenter(geometry().center());
             	zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
             	QRectF r = rect.normalized();
             	r.translate(-m_marginSize, -m_marginSize);
             	if(m_animator) {
             		QPointF point(r.center().x()/geometry().width(),r.center().y()/geometry().height());
             		m_animator->setState(ChartAnimator::ZoomInState,point);
             	}
             	m_dataset->zoomInDomain(r,geometry().size());
             	m_zoomStack<<r;
             	m_zoomIndex++;
             	if(m_animator) {
             		m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             void ChartPresenter::zoomOut()
             {
             	if(m_zoomIndex==0) return;
             	if(m_animator)
             	{
             		m_animator->setState(ChartAnimator::ZoomOutState);
             	}
             	m_dataset->zoomOutDomain(m_zoomStack[m_zoomIndex-1],geometry().size());
             	m_zoomIndex--;
             	m_zoomStack.resize(m_zoomIndex);
             	if(m_animator){
             			m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             void ChartPresenter::zoomReset()
             {
                 m_zoomIndex=0;
                 m_zoomStack.resize(m_zoomIndex);
             }
             void ChartPresenter::scroll(int dx,int dy)
             {
             	if(m_animator){
             		if(dx<0) m_animator->setState(ChartAnimator::ScrollLeftState,QPointF());
             		if(dx>0) m_animator->setState(ChartAnimator::ScrollRightState,QPointF());
             		if(dy<0) m_animator->setState(ChartAnimator::ScrollUpState,QPointF());
             		if(dy>0) m_animator->setState(ChartAnimator::ScrollDownState,QPointF());
             	}
             	m_dataset->scrollDomain(dx,dy,geometry().size());
                 if(m_animator){
             		m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piechartitem.cpp +53 -12

             #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>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieChartItem::PieChartItem(QGraphicsItem *parent, QPieSeries *series)
                 :ChartItem(parent),
                 m_series(series)
             {
                 Q_ASSERT(series);
                 connect(series, SIGNAL(changed()), this, SLOT(handleSeriesChanged()));
                 // 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()
             {
-                QVector<PieSliceLayout> sliceLayout = calculateLayout();
+                QVector<PieSliceLayout> layout = calculateLayout();
-                applyLayout(sliceLayout);
+                applyLayout(layout);
                 update();
             }
             void PieChartItem::handleSliceChanged()
             {
-                // TODO: optimize don't need to handle all slices
+                QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
-                QVector<PieSliceLayout> sliceLayout = calculateLayout();
+                Q_ASSERT(m_slices.contains(slice));
-                applyLayout(sliceLayout);
+                //qDebug() << "PieChartItem::handleSliceChanged" << slice->label();
+                // 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();
                 applyLayout(sliceLayout);
                 update();
             }
             QVector<PieSliceLayout> PieChartItem::calculateLayout()
             {
                 // find pie center coordinates
                 QPointF center;
                 center.setX(m_rect.left() + (m_rect.width() * m_series->pieHorizontalPosition()));
                 center.setY(m_rect.top() + (m_rect.height() * m_series->pieVerticalPosition()));
                 // find maximum radius for pie
                 qreal radius = m_rect.height() / 2;
                 if (m_rect.width() < m_rect.height())
                     radius = m_rect.width() / 2;
                 // apply size factor
                 radius *= m_series->pieSize();
                 QVector<PieSliceLayout> layout;
                 foreach (QPieSlice* s, m_series->slices()) {
                     PieSliceLayout sliceLayout;
                     sliceLayout.m_data = 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(const QVector<PieSliceLayout> &layout)
+            void PieChartItem::applyLayout(QVector<PieSliceLayout> &layout)
             {
-                //if(m_animator)
+                if (m_animator)
-                //        m_animator->applyLayout(this,points);
+                    m_animator->applyLayout(this, layout);
-                //else
+                else
-                setLayout(layout);
+                    setLayout(layout);
             }
-            void PieChartItem::setLayout(const QVector<PieSliceLayout> &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) {
                         // 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->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)
-                        delete m_slices.take(s);
+                        destroySlice(s);
+                }
+            }
+            void PieChartItem::setLayout(PieSliceLayout &layout)
+            {
+                // find slice
+                PieSlice *slice = m_slices.value(layout.m_data);
+                if (!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 -3

             #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 handleSliceChanged();
                 void handleDomainChanged(qreal, qreal, qreal, qreal);
                 void handleGeometryChanged(const QRectF& rect);
-            private:
+            public:
                 QVector<PieSliceLayout> calculateLayout();
-                void applyLayout(const QVector<PieSliceLayout> &layout);
+                void applyLayout(QVector<PieSliceLayout> &layout);
-                void setLayout(const 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 +2 -7

             #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_startAngle(0),
-                m_angleSpan(0),
                 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();
+                return m_slicePath.boundingRect().united(m_labelTextRect);
             }
             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;
-                updateData(layout.m_data);
             }
             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_startAngle, m_angleSpan, &centerAngle, &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;
             }
             void PieSlice::updateData(const QPieSlice* sliceData)
             {
                 // TODO: compare what has changes to avoid unneccesary geometry updates
-                m_startAngle = sliceData->startAngle();
-                m_angleSpan = sliceData->m_angleSpan;
                 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 -3

             #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;
+                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;
                 QPainterPath m_slicePath;
-                qreal m_startAngle;
-                qreal m_angleSpan;
                 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 +12 -6

             #include "qpieseries.h"
             #include "qpieslice.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries::ChangeSet
                 \brief Defines the changes in the series.
                 Contains the changes that have occurred in the series. Lists of added, changed and removed slices.
                 \sa QPieSeries::changed()
             */
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendAdded(QPieSlice* slice)
             {
                 if (!m_added.contains(slice))
                     m_added << slice;
             }
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendAdded(QList<QPieSlice*> slices)
             {
                 foreach (QPieSlice* s, slices)
                     appendAdded(s);
             }
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendChanged(QPieSlice* slice)
             {
                 if (!m_changed.contains(slice))
                     m_changed << slice;
             }
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendRemoved(QPieSlice* slice)
             {
                 if (!m_removed.contains(slice))
                     m_removed << slice;
             }
             /*!
                 Returns a list of slices that have been added to the series.
                 \sa QPieSeries::changed()
             */
             QList<QPieSlice*> QPieSeries::ChangeSet::added() const
             {
                 return m_added;
             }
             /*!
                 Returns a list of slices that have been changed in the series.
                 \sa QPieSeries::changed()
             */
             QList<QPieSlice*> QPieSeries::ChangeSet::changed() const
             {
                 return m_changed;
             }
             /*!
                 Returns a list of slices that have been removed from the series.
                 \sa QPieSeries::changed()
             */
             QList<QPieSlice*> QPieSeries::ChangeSet::removed() const
             {
                 return m_removed;
             }
             /*!
                 Returns true if there are no added/changed or removed slices in the change set.
             */
             bool QPieSeries::ChangeSet::isEmpty() const
             {
                 if (m_added.count() || m_changed.count() || m_removed.count())
                     return false;
                 return true;
             }
             /*!
                 \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();
             }
             /*!
                 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();
             }
             /*!
                 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();
                 delete slice;
                 slice = NULL;
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 if (m_slices.count() == 0)
                     return;
                 foreach (QPieSlice* s, m_slices) {
                     m_slices.removeOne(s);
                     delete s;
                 }
                 emit changed();
                 updateDerivativeData();
             }
             /*!
                 Counts the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 return m_slices.count();
             }
             /*!
                 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();
                 }
             }
             /*!
                 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();
                 }
             }
             /*!
                 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?
                 // we must have some values
                 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 changed = false;
+                    bool isChanged = false;
                     qreal percentage = s->value() / m_total;
                     if (s->m_percentage != percentage) {
                         s->m_percentage = percentage;
-                        changed = true;
+                        isChanged = true;
                     }
                     qreal sliceSpan = pieSpan * percentage;
                     if (s->m_angleSpan != sliceSpan) {
                         s->m_angleSpan = sliceSpan;
-                        changed = true;
+                        isChanged = true;
                     }
                     if (s->m_startAngle != sliceAngle) {
                         s->m_startAngle = sliceAngle;
-                        changed = true;
+                        isChanged = true;
                     }
                     sliceAngle += sliceSpan;
-                    if (changed)
+                    if (isChanged)
-                        emit s->changed();
+                        changed << s;
                 }
+                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 +1 0

             #ifndef PIESERIES_H
             #define PIESERIES_H
             #include "qseries.h"
             #include <QObject>
             #include <QRectF>
             #include <QColor>
             #include <QPen>
             #include <QBrush>
             #include <QSignalMapper>
             class QGraphicsObject;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieChartItem;
             class PieSlice;
             class QPieSlice;
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 class ChangeSet
                 {
                 public:
                     // TODO: these should not really be exposed to the public API
                     void appendAdded(QPieSlice* slice);
                     void appendAdded(QList<QPieSlice*> slices);
                     void appendChanged(QPieSlice* slice);
                     void appendRemoved(QPieSlice* slice);
                     QList<QPieSlice*> added() const;
                     QList<QPieSlice*> changed() const;
                     QList<QPieSlice*> removed() const;
                     bool isEmpty() const;
                 private:
                     QList<QPieSlice*> m_added;
                     QList<QPieSlice*> m_changed;
                     QList<QPieSlice*> m_removed;
                 };
             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;
                 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
             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

src/piechart/qpieslice.cpp +7 -1

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

src/piechart/qpieslice.h +3 -6

             #ifndef QPIESLICE_H
             #define QPIESLICE_H
             #include <qchartglobal.h>
             #include <QObject>
             #include <QPen>
             #include <QBrush>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            class QPieSeries;
             class QTCOMMERCIALCHART_EXPORT QPieSlice : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QString label READ label WRITE setLabel NOTIFY changed)
                 Q_PROPERTY(qreal value READ value WRITE setValue NOTIFY changed)
             public:
                 QPieSlice(QObject *parent = 0);
                 QPieSlice(qreal value, QString label, QObject *parent = 0);
                 virtual ~QPieSlice();
                 // data
                 void setValue(qreal value);
                 qreal value() const;
                 void setLabel(QString label);
                 QString label() const;
                 void setLabelVisible(bool visible);
                 bool isLabelVisible() const;
                 void setExploded(bool exploded);
                 bool isExploded() const;
-                void setExplodeDistanceFactor(qreal factor);
-                qreal explodeDistanceFactor() const;
                 // generated data
                 qreal percentage() const;
                 qreal startAngle() const;
                 qreal endAngle() const;
                 // customization
                 void setSlicePen(const QPen &pen);
                 QPen slicePen() const;
                 void setSliceBrush(const QBrush &brush);
                 QBrush sliceBrush() const;
                 void setLabelArmPen(const QPen &pen);
                 QPen labelArmPen() const;
                 void setLabelFont(const QFont &font);
                 QFont labelFont() const;
                 void setLabelArmLengthFactor(qreal factor);
                 qreal labelArmLengthFactor() const;
+                void setExplodeDistanceFactor(qreal factor);
-                // TODO: label position in general
+                qreal explodeDistanceFactor() const;
-                // setLabelFlags(inside|outside|labelArmOn|labelArmOff|???)
-                // setLabelOrientation(horizontal|vertical|same as slice center angle|???)
             Q_SIGNALS:
                 void clicked();
                 void hoverEnter();
                 void hoverLeave();
                 void changed();
             private:
                 // TODO: use private class
                 friend class QPieSeries;
                 friend class PieChartItem;
                 friend class PieSlice;
                 // data
                 qreal m_value;
                 QString m_label;
                 bool m_isLabelVisible;
                 bool m_isExploded;
                 qreal m_explodeDistanceFactor;
                 // generated data
                 qreal m_percentage;
                 qreal m_startAngle;
                 qreal m_angleSpan;
                 // customization
                 QPen m_slicePen;
                 QBrush m_sliceBrush;
                 QFont m_labelFont;
                 QPen m_labelArmPen;
                 qreal m_labelArmLengthFactor;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIESLICE_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