HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1274:9c11726517fa

pie: added everything as a property in QPieSlice...

Jani Honkonen -

r1274:9c11726517fa

parent child

Context file:

r1274:9c11726517fa

Collapse all files

src/piechart/qpieslice_p.h created 644 +43 0

@@ -0,0 +1,43
	1	#ifndef QPIESLICE_P_H
	2	#define QPIESLICE_P_H
	3
	4	#include <QObject>
	5	#include "qpieslice.h"
	6	#include "pieslicedata_p.h"
	7
	8	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	9
	10	class QPieSlicePrivate : public QObject
	11	{
	12	Q_OBJECT
	13
	14	public:
	15	QPieSlicePrivate(QPieSlice *parent);
	16	~QPieSlicePrivate();
	17
	18	static QPieSlicePrivate* fromSlice(QPieSlice *slice);
	19
	20	void setPen(const QPen &pen, bool themed);
	21	void setBrush(const QBrush &brush, bool themed);
	22	void setLabelPen(const QPen &pen, bool themed);
	23	void setLabelFont(const QFont &font, bool themed);
	24
	25	void setPercentage(qreal percentage);
	26	void setStartAngle(qreal angle);
	27	void setAngleSpan(qreal span);
	28
	29	private:
	30	PieSliceData m_data;
	31
	32	private:
	33	friend class QPieSeriesPrivate;
	34	friend class ChartTheme;
	35	friend class PieChartItem;
	36
	37	QPieSlice * const q_ptr;
	38	Q_DECLARE_PUBLIC(QPieSlice)
	39	};
	40
	41	QTCOMMERCIALCHART_END_NAMESPACE
	42
	43	#endif // QPIESLICE_P_H

examples/piechartdrilldown/drilldownslice.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "drilldownslice.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             DrilldownSlice::DrilldownSlice(qreal value, QString prefix, QAbstractSeries* drilldownSeries)
                 :m_drilldownSeries(drilldownSeries),
                 m_prefix(prefix)
             {
                 setValue(value);
                 updateLabel();
                 setLabelFont(QFont("Arial", 8));
-                connect(this, SIGNAL(calculatedDataChanged()), this, SLOT(updateLabel()));
+                connect(this, SIGNAL(percentageChanged()), this, SLOT(updateLabel()));
                 connect(this, SIGNAL(hovered(bool)), this, SLOT(showHighlight(bool)));
             }
             DrilldownSlice::~DrilldownSlice()
             {
             }
             QAbstractSeries* DrilldownSlice::drilldownSeries() const
             {
                 return m_drilldownSeries;
             }
             void DrilldownSlice::updateLabel()
             {
                 QString label = m_prefix;
                 label += " $";
                 label += QString::number(this->value());
                 label += ", ";
                 label += QString::number(this->percentage()*100, 'f', 1);
                 label += "%";
                 setLabel(label);
             }
             void DrilldownSlice::showHighlight(bool show)
             {
                 setLabelVisible(show);
                 setExploded(show);
             }
             #include "moc_drilldownslice.cpp"

src/charttheme.cpp +10 -22

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "qchartview.h"
             #include "qlegend.h"
             #include "qaxis.h"
             #include <QTime>
             //series
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
+            #include "qpieslice_p.h"
             #include "qsplineseries.h"
             //items
             #include "chartaxis_p.h"
             #include "barchartitem_p.h"
             #include "stackedbarchartitem_p.h"
             #include "percentbarchartitem_p.h"
             #include "linechartitem_p.h"
             #include "areachartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "piechartitem_p.h"
             #include "splinechartitem_p.h"
             //themes
             #include "chartthemesystem_p.h"
             #include "chartthemelight_p.h"
             #include "chartthemebluecerulean_p.h"
             #include "chartthemedark_p.h"
             #include "chartthemebrownsand_p.h"
             #include "chartthemebluencs_p.h"
             #include "chartthemehighcontrast_p.h"
             #include "chartthemeblueicy_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartTheme::ChartTheme(QChart::ChartTheme id) :
                 m_masterFont(QFont("arial", 14)),
                 m_labelFont(QFont("arial", 10)),
                 m_titleBrush(QColor(QRgb(0x000000))),
                 m_axisLinePen(QPen(QRgb(0x000000))),
                 m_axisLabelBrush(QColor(QRgb(0x000000))),
                 m_backgroundShadesPen(Qt::NoPen),
                 m_backgroundShadesBrush(Qt::NoBrush),
                 m_backgroundShades(BackgroundShadesNone),
                 m_backgroundDropShadowEnabled(false),
                 m_gridLinePen(QPen(QRgb(0x000000))),
                 m_force(false)
             {
                 m_id = id;
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeLight:
                         return new ChartThemeLight();
                     case QChart::ChartThemeBlueCerulean:
                         return new ChartThemeBlueCerulean();
                     case QChart::ChartThemeDark:
                         return new ChartThemeDark();
                     case QChart::ChartThemeBrownSand:
                         return new ChartThemeBrownSand();
                     case QChart::ChartThemeBlueNcs:
                         return new ChartThemeBlueNcs();
                     case QChart::ChartThemeHighContrast:
                         return new ChartThemeHighContrast();
                     case QChart::ChartThemeBlueIcy:
                         return new ChartThemeBlueIcy();
                     default:
                         return new ChartThemeSystem();
                 }
             }
             void ChartTheme::decorate(QChart *chart)
             {
                 QBrush brush;
                 if(brush == chart->backgroundBrush() ||  m_force)
                     chart->setBackgroundBrush(m_chartBackgroundGradient);
                 chart->setTitleFont(m_masterFont);
                 chart->setTitleBrush(m_titleBrush);
                 chart->setBackgroundDropShadowEnabled(m_backgroundDropShadowEnabled);
             }
             void ChartTheme::decorate(QLegend *legend)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == legend->pen() ||  m_force){
                     legend->setPen(Qt::NoPen);
                 }
                 if (brush == legend->brush() ||  m_force) {
                     legend->setBrush(m_chartBackgroundGradient);
                 }
             }
             void ChartTheme::decorate(QAreaSeries *series, int index)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() ||  m_force){
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() ||  m_force) {
                    QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                    series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QLineSeries *series,int index)
             {
                 QPen pen;
                 if(pen == series->pen() ||  m_force ){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(QBarSeries *series, int index)
             {
                 QBrush brush;
                 QPen pen;
                 QList<QBarSet *> sets = series->barSets();
                 qreal takeAtPos = 0.5;
                 qreal step = 0.2;
                 if (sets.count() > 1 ) {
                     step = 1.0 / (qreal) sets.count();
                     if (sets.count() % m_seriesGradients.count())
                         step *= m_seriesGradients.count();
                     else
                         step *= (m_seriesGradients.count() - 1);
                 }
                 for (int i(0); i < sets.count(); i++) {
                     int colorIndex = (index + i) % m_seriesGradients.count();
                     if (i > 0 && i % m_seriesGradients.count() == 0) {
                         // There is no dedicated base color for each sets, generate more colors
                         takeAtPos += step;
                         if (takeAtPos == 1.0)
                             takeAtPos += step;
                         takeAtPos -= (int) takeAtPos;
                     }
                     if (brush == sets.at(i)->brush() ||  m_force )
                         sets.at(i)->setBrush(colorAt(m_seriesGradients.at(colorIndex), takeAtPos));
                     // Pick label color from the opposite end of the gradient.
                     // 0.3 as a boundary seems to work well.
                     if (takeAtPos < 0.3)
                         sets.at(i)->setLabelBrush(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1));
                     else
                         sets.at(i)->setLabelBrush(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0));
                     if (pen == sets.at(i)->pen() ||  m_force) {
                         QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                         sets.at(i)->setPen(c);
                     }
                 }
             }
             void ChartTheme::decorate(QScatterSeries *series, int index)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() ||  m_force) {
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() ||  m_force) {
                     QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                     series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QPieSeries *series, int index)
             {
                 for (int i(0); i < series->slices().count(); i++) {
                     QColor penColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                     // Get color for a slice from a gradient linearly, beginning from the start of the gradient
                     qreal pos = (qreal) (i + 1) / (qreal) series->count();
                     QColor brushColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     QPieSlice *s = series->slices().at(i);
-                    PieSliceData data = PieSliceData::fromSlice(s);
+                    QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s);
-                    if (data.m_slicePen.isThemed() || m_force) {
+                    if (d->m_data.m_slicePen.isThemed() || m_force)
-                        data.m_slicePen = penColor;
+                        d->setPen(penColor, true);
-                        data.m_slicePen.setThemed(true);
-                    if (data.m_sliceBrush.isThemed() || m_force) {
-                        data.m_sliceBrush = brushColor;
-                        data.m_sliceBrush.setThemed(true);
-                    if (data.m_labelPen.isThemed() || m_force) {
+                    if (d->m_data.m_sliceBrush.isThemed() || m_force)
-                        data.m_labelPen = QPen(m_titleBrush.color());
+                        d->setBrush(brushColor, true);
-                        data.m_labelPen.setThemed(true);
-                    if (data.m_labelFont.isThemed() || m_force) {
+                    if (d->m_data.m_labelPen.isThemed() || m_force)
-                        data.m_labelFont = m_labelFont;
+                        d->setLabelPen(QPen(m_titleBrush.color()), true);
-                        data.m_labelFont.setThemed(true);
-                    if (PieSliceData::fromSlice(s) != data) {
+                    if (d->m_data.m_labelFont.isThemed() || m_force)
-                        PieSliceData::fromSlice(s) = data;
+                        d->setLabelFont(m_labelFont, true);
-                        emit PieSliceData::emitAppearanceChanged(s);
                 }
             }
             void ChartTheme::decorate(QSplineSeries *series, int index)
             {
                 QPen pen;
                 if(pen == series->pen() ||  m_force){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(QAxis *axis,bool axisX)
             {
                 QPen pen;
                 QBrush brush;
                 QFont font;
                 if (axis->isAxisVisible()) {
                     if(brush == axis->labelsBrush() ||  m_force){
                         axis->setLabelsBrush(m_axisLabelBrush);
                     }
                     if(pen == axis->labelsPen() ||  m_force){
                         axis->setLabelsPen(Qt::NoPen); // NoPen for performance reasons
                     }
                    if (axis->shadesVisible() ||  m_force) {
                      if(brush == axis->shadesBrush() ||  m_force){
                          axis->setShadesBrush(m_backgroundShadesBrush);
                      }
                      if(pen == axis->shadesPen() ||  m_force){
                          axis->setShadesPen(m_backgroundShadesPen);
                      }
                      if( m_force && (m_backgroundShades == BackgroundShadesBoth
                                      || (m_backgroundShades == BackgroundShadesVertical && axisX)
                                      || (m_backgroundShades == BackgroundShadesHorizontal && !axisX))){
                          axis->setShadesVisible(true);
                      }
                    }
                     if(pen == axis->axisPen() ||  m_force){
                         axis->setAxisPen(m_axisLinePen);
                     }
                     if(pen == axis->gridLinePen() ||  m_force){
                         axis->setGridLinePen(m_gridLinePen);
                     }
                     if(font == axis->labelsFont() || m_force){
                         axis->setLabelsFont(m_labelFont);
                     }
                 }
             }
             void ChartTheme::generateSeriesGradients()
             {
                 // Generate gradients in HSV color space
                 foreach (const QColor& color, m_seriesColors) {
                     QLinearGradient g;
                     qreal h = color.hsvHueF();
                     qreal s = color.hsvSaturationF();
                     // TODO: tune the algorithm to give nice results with most base colors defined in
                     // most themes. The rest of the gradients we can define manually in theme specific
                     // implementation.
                     QColor start = color;
                     start.setHsvF(h, 0.0, 1.0);
                     g.setColorAt(0.0, start);
                     g.setColorAt(0.5, color);
                     QColor end = color;
                     end.setHsvF(h, s, 0.25);
                     g.setColorAt(1.0, end);
                     m_seriesGradients << g;
                 }
             }
             QColor ChartTheme::colorAt(const QColor &start, const QColor &end, qreal pos)
             {
                 Q_ASSERT(pos >= 0.0 && pos <= 1.0);
                 qreal r = start.redF() + ((end.redF() - start.redF()) * pos);
                 qreal g = start.greenF() + ((end.greenF() - start.greenF()) * pos);
                 qreal b = start.blueF() + ((end.blueF() - start.blueF()) * pos);
                 QColor c;
                 c.setRgbF(r, g, b);
                 return c;
             }
             QColor ChartTheme::colorAt(const QGradient &gradient, qreal pos)
             {
                 Q_ASSERT(pos >= 0 && pos <= 1.0);
                 QGradientStops stops = gradient.stops();
                 int count = stops.count();
                 // find previous stop relative to position
                 QGradientStop prev = stops.first();
                 for (int i = 0; i < count; i++) {
                     QGradientStop stop = stops.at(i);
                     if (pos > stop.first)
                         prev = stop;
                     // given position is actually a stop position?
                     if (pos == stop.first) {
                         //qDebug() << "stop color" << pos;
                         return stop.second;
                     }
                 }
                 // find next stop relative to position
                 QGradientStop next = stops.last();
                 for (int i = count - 1; i >= 0; i--) {
                     QGradientStop stop = stops.at(i);
                     if (pos < stop.first)
                         next = stop;
                 }
                 //qDebug() << "prev" << prev.first << "pos" << pos << "next" << next.first;
                 qreal range = next.first - prev.first;
                 qreal posDelta = pos - prev.first;
                 qreal relativePos = posDelta / range;
                 //qDebug() << "range" << range << "posDelta" << posDelta << "relativePos" << relativePos;
                 return colorAt(prev.second, next.second, relativePos);
             }
             void ChartTheme::setForced(bool enabled)
             {
                 m_force=enabled;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/legendmarker.cpp +1 -1

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "legendmarker_p.h"
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "qlegend.h"
             #include "qbarseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "qareaseries.h"
             #include "qareaseries_p.h"
             #include <QPainter>
             #include <QGraphicsSceneEvent>
             #include <QGraphicsSimpleTextItem>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LegendMarker::LegendMarker(QAbstractSeries *series, QLegend *legend) : QGraphicsObject(legend),
             m_series(series),
             m_markerRect(0,0,10.0,10.0),
             m_boundingRect(0,0,0,0),
             m_legend(legend),
             m_textItem(new QGraphicsSimpleTextItem(this)),
             m_rectItem(new QGraphicsRectItem(this))
             {
                 //setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
                 m_rectItem->setRect(m_markerRect);
                 updateLayout();
             }
             void LegendMarker::setPen(const QPen &pen)
             {
                 m_textItem->setPen(pen);
                 updateLayout();
             }
             QPen LegendMarker::pen() const
             {
                 return m_textItem->pen();
             }
             void LegendMarker::setBrush(const QBrush &brush)
             {
                 m_rectItem->setBrush(brush);
             }
             QBrush LegendMarker::brush() const
             {
                 return m_rectItem->brush();
             }
             void LegendMarker::setLabel(const QString name)
             {
                 m_textItem->setText(name);
                 updateLayout();
             }
             void LegendMarker::setSize(const QSize& size)
             {
                 m_markerRect = QRectF(0,0,size.width(),size.height());
             }
             QString LegendMarker::label() const
             {
                 return m_textItem->text();
             }
             void LegendMarker::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 Q_UNUSED(painter)
             }
             QRectF LegendMarker::boundingRect() const
             {
                 return m_boundingRect;
             }
             void LegendMarker::updateLayout()
             {
                 static const qreal margin = 2;
                 static const qreal space = 4;
                 const QRectF& textRect = m_textItem->boundingRect();
                 prepareGeometryChange();
                 m_boundingRect = QRectF(0,0,m_markerRect.width() + 2*margin + space + textRect.width(),qMax(m_markerRect.height()+2*margin,textRect.height()+2*margin));
                 m_textItem->setPos(m_markerRect.width() + space + margin,m_boundingRect.height()/2 - textRect.height()/2);
                 m_rectItem->setPos(margin,m_boundingRect.height()/2 - m_markerRect.height()/2);
             }
             void LegendMarker::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 QGraphicsObject::mousePressEvent(event);
                 qDebug()<<"Not implemented"; //TODO: selected signal removed for now
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             AreaLegendMarker::AreaLegendMarker(QAreaSeries *series,QLegend *legend) : LegendMarker(series,legend),
             m_series(series)
             {
                 //QObject::connect(this, SIGNAL(selected()), series, SIGNAL(selected()));
                 QObject::connect(series->d_func(),SIGNAL(updated()), this, SLOT(updated()));
                 updated();
             }
             void AreaLegendMarker::updated()
             {
                 setBrush(m_series->brush());
                 setLabel(m_series->name());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             BarLegendMarker::BarLegendMarker(QBarSeries *barseries,QBarSet *barset, QLegend *legend) : LegendMarker(barseries,legend),
             m_barset(barset)
             {
                 //QObject::connect(this, SIGNAL(selected()),barset->d_ptr.data(), SIGNAL(selected()));
                 QObject::connect(barset->d_ptr.data(), SIGNAL(updatedBars()), this, SLOT(updated()));
                 updated();
             }
             void BarLegendMarker::updated()
             {
                 setBrush(m_barset->brush());
                 setLabel(m_barset->name());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             PieLegendMarker::PieLegendMarker(QPieSeries* series,QPieSlice *pieslice, QLegend *legend) : LegendMarker(series,legend),
             m_pieslice(pieslice)
             {
                 QObject::connect(pieslice, SIGNAL(labelChanged()), this, SLOT(updated()));
-                QObject::connect(pieslice, SIGNAL(appearanceChanged()), this, SLOT(updated()));
+                QObject::connect(pieslice, SIGNAL(brushChanged()), this, SLOT(updated()));
                 updated();
             }
             void PieLegendMarker::updated()
             {
                 setBrush(m_pieslice->brush());
                 setLabel(m_pieslice->label());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             XYLegendMarker::XYLegendMarker(QXYSeries *series, QLegend *legend) : LegendMarker(series,legend),
             m_series(series)
             {
                 //QObject::connect(this, SIGNAL(selected()), series, SIGNAL(selected()));
                 QObject::connect(series->d_func(),SIGNAL(updated()), this, SLOT(updated()));
                 updated();
             }
             void XYLegendMarker::updated()
             {
                 setLabel(m_series->name());
                 if(m_series->type()== QAbstractSeries::SeriesTypeScatter)
                 {
                     setBrush(m_series->brush());
                 }
                 else {
                     setBrush(QBrush(m_series->pen().color()));
                 }
             }
             #include "moc_legendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piechart.pri +2 0

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/qpieseries.cpp \
                 $$PWD/piesliceitem.cpp \
                 $$PWD/piechartitem.cpp \
                 $$PWD/qpieslice.cpp \
                 $$PWD/qpiemodelmapper.cpp \
                 $$PWD/qvpiemodelmapper.cpp \
                 $$PWD/qhpiemodelmapper.cpp
             PRIVATE_HEADERS += \
                 $$PWD/pieslicedata_p.h \
                 $$PWD/piechartitem_p.h \
                 $$PWD/piesliceitem_p.h \
+                $$PWD/qpieslice_p.h \
                 $$PWD/qpieseries_p.h \
                 $$PWD/qpiemodelmapper_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qpieseries.h \
                 $$PWD/qpieslice.h \
                 $$PWD/qpiemodelmapper.h \
                 $$PWD/qvpiemodelmapper.h \
                 $$PWD/qhpiemodelmapper.h

src/piechart/piechartitem.cpp +14 -5

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "piechartitem_p.h"
             #include "piesliceitem_p.h"
             #include "qpieslice.h"
+            #include "qpieslice_p.h"
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter* presenter)
                 :ChartItem(presenter),
                 m_series(series)
             {
                 Q_ASSERT(series);
                 connect(series, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleSlicesAdded(QList<QPieSlice*>)));
                 connect(series, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleSlicesRemoved(QList<QPieSlice*>)));
                 connect(series, SIGNAL(horizontalPositionChanged()), this, SLOT(updateLayout()));
                 connect(series, SIGNAL(verticalPositionChanged()), this, SLOT(updateLayout()));
                 connect(series, SIGNAL(pieSizeChanged()), this, SLOT(updateLayout()));
+                connect(QPieSeriesPrivate::fromSeries(series), SIGNAL(calculatedDataChanged()), this, SLOT(updateLayout()));
                 // Note: the following does not affect as long as the item does not have anything to paint
                 setZValue(ChartPresenter::PieSeriesZValue);
                 // Note: will not create slice items until we have a proper rectangle to draw on.
             }
             PieChartItem::~PieChartItem()
             {
                 // slices deleted automatically through QGraphicsItem
             }
             void PieChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 updateLayout();
                 // This is for delayed initialization of the slice items during startup.
                 // It ensures that startup animation originates from the correct position.
                 if (m_sliceItems.isEmpty())
                     handleSlicesAdded(m_series->slices());
             }
             void PieChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 Q_UNUSED(minX);
                 Q_UNUSED(maxX);
                 Q_UNUSED(minY);
                 Q_UNUSED(maxY);
                 // does not apply to pie
             }
             void PieChartItem::rangeXChanged(qreal min, qreal max, int tickXCount)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 Q_UNUSED(tickXCount);
                 // does not apply to pie
             }
             void PieChartItem::rangeYChanged(qreal min, qreal max, int tickYCount)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 Q_UNUSED(tickYCount);
                 // does not apply to pie
             }
             void PieChartItem::updateLayout()
             {
                 // find pie center coordinates
                 m_pieCenter.setX(m_rect.left() + (m_rect.width() * m_series->horizontalPosition()));
                 m_pieCenter.setY(m_rect.top() + (m_rect.height() * m_series->verticalPosition()));
                 // find maximum radius for pie
                 m_pieRadius = m_rect.height() / 2;
                 if (m_rect.width() < m_rect.height())
                     m_pieRadius = m_rect.width() / 2;
                 // apply size factor
                 m_pieRadius *= m_series->pieSize();
                 // set layouts for existing slice items
                 foreach (QPieSlice* slice, m_series->slices()) {
                     PieSliceItem *sliceItem = m_sliceItems.value(slice);
                     if (sliceItem) {
                         PieSliceData sliceData = updateSliceGeometry(slice);
                         if (animator())
                             animator()->updateAnimation(this, sliceItem, sliceData);
                         else
                             sliceItem->setLayout(sliceData);
                     }
                 }
                 update();
             }
             void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices)
             {
                 // delay creating slice items until there is a proper rectangle
                 if (!m_rect.isValid() && m_sliceItems.isEmpty())
                     return;
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 bool startupAnimation = m_sliceItems.isEmpty();
                 foreach (QPieSlice *slice, slices) {
                     PieSliceItem* sliceItem = new PieSliceItem(this);
                     m_sliceItems.insert(slice, sliceItem);
-                    // note: do need to connect to slice valueChanged(). calculatedDataChanged() is enough.
+                    // Note: do need to connect to slice valueChanged() etc.
-                    // to update the slice.
+                    // This is handled through calculatedDataChanged signal.
-                    connect(slice, SIGNAL(calculatedDataChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(labelChanged()), this, SLOT(handleSliceChanged()));
-                    connect(slice, SIGNAL(appearanceChanged()), this, SLOT(handleSliceChanged()));
+                    connect(slice, SIGNAL(labelVisibleChanged()), this, SLOT(handleSliceChanged()));
+                    connect(slice, SIGNAL(explodedChanged()), this, SLOT(handleSliceChanged()));
+                    connect(slice, SIGNAL(penChanged()), this, SLOT(handleSliceChanged()));
+                    connect(slice, SIGNAL(brushChanged()), this, SLOT(handleSliceChanged()));
+                    connect(slice, SIGNAL(labelPenChanged()), this, SLOT(handleSliceChanged()));
+                    connect(slice, SIGNAL(labelFontChanged()), this, SLOT(handleSliceChanged()));
+                    connect(slice, SIGNAL(labelArmLengthFactorChanged()), this, SLOT(handleSliceChanged()));
+                    connect(slice, SIGNAL(explodeDistanceFactorChanged()), this, SLOT(handleSliceChanged()));
                     connect(sliceItem, SIGNAL(clicked(Qt::MouseButtons)), slice, SIGNAL(clicked()));
                     connect(sliceItem, SIGNAL(hovered(bool)), slice, SIGNAL(hovered(bool)));
                     PieSliceData sliceData = updateSliceGeometry(slice);
                     if (animator())
                         animator()->addAnimation(this, sliceItem, sliceData, startupAnimation);
                     else
                         sliceItem->setLayout(sliceData);
                 }
             }
             void PieChartItem::handleSlicesRemoved(QList<QPieSlice*> slices)
             {
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 foreach (QPieSlice *slice, slices) {
                     PieSliceItem *sliceItem = m_sliceItems.value(slice);
                     Q_ASSERT(sliceItem);
                     m_sliceItems.remove(slice);
                     if (animator())
                         animator()->removeAnimation(this, sliceItem); // animator deletes the PieSliceItem
                     else
                         delete sliceItem;
                 }
             }
             void PieChartItem::handleSliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_sliceItems.contains(slice));
                 PieSliceItem *sliceItem = m_sliceItems.value(slice);
                 PieSliceData sliceData = updateSliceGeometry(slice);
                 if (animator())
                     animator()->updateAnimation(this, sliceItem, sliceData);
                 else
                     sliceItem->setLayout(sliceData);
                 update();
             }
             PieSliceData PieChartItem::updateSliceGeometry(QPieSlice *slice)
             {
-                PieSliceData &sliceData = PieSliceData::fromSlice(slice);
+                PieSliceData &sliceData = QPieSlicePrivate::fromSlice(slice)->m_data;
                 sliceData.m_center = PieSliceItem::sliceCenter(m_pieCenter, m_pieRadius, slice);
                 sliceData.m_radius = m_pieRadius;
                 return sliceData;
             }
             #include "moc_piechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslicedata_p.h 0 -18

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef PIESLICEDATA_P_H
             #define PIESLICEDATA_P_H
             #include "qchartglobal.h"
             #include "qpieslice.h"
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             template <class T>
             class Themed : public T
             {
             public:
                 Themed():m_isThemed(true) {}
                 inline T &operator=(const T &other) { return T::operator =(other); }
                 inline bool operator!=(const T &other) const { return T::operator !=(other); }
                 inline bool operator!=(const Themed &other) const
                 {
                     if (T::operator !=(other))
                         return true;
                     if (m_isThemed != other.m_isThemed)
                         return true;
                     return false;
                 }
                 inline void setThemed(bool state) { m_isThemed = state; }
                 inline bool isThemed() const { return m_isThemed; }
             private:
                 bool m_isThemed;
             };
             class PieSliceData
             {
             public:
                 PieSliceData()
                 {
                     m_value = 0;
                     m_isExploded = false;
                     m_explodeDistanceFactor = 0.15;
                     m_isLabelVisible = false;
                     m_labelArmLengthFactor = 0.15;
                     m_percentage = 0;
                     m_radius = 0;
                     m_startAngle = 0;
                     m_angleSpan = 0;
                 }
                 bool operator!=(const PieSliceData &other) const
                 {
                     if (!qFuzzyIsNull(m_value - other.m_value))
                         return true;
                     if (m_slicePen != other.m_slicePen ||
                         m_sliceBrush != other.m_sliceBrush)
                         return true;
                     if (m_isExploded != other.m_isExploded ||
                         !qFuzzyIsNull(m_explodeDistanceFactor - other.m_explodeDistanceFactor))
                         return true;
                     if (m_isLabelVisible != other.m_isLabelVisible ||
                         m_labelText != other.m_labelText ||
                         m_labelFont != other.m_labelFont ||
                         !qFuzzyIsNull(m_labelArmLengthFactor - other.m_labelArmLengthFactor) ||
                         m_labelPen != other.m_labelPen)
                         return true;
                     if (!qFuzzyIsNull(m_percentage - other.m_percentage) ||
                         m_center != other.m_center ||
                         !qFuzzyIsNull(m_radius - other.m_radius) ||
                         !qFuzzyIsNull(m_startAngle - other.m_startAngle) ||
                         !qFuzzyIsNull(m_angleSpan - other.m_angleSpan))
                         return true;
                     return false;
                 }
-                static void emitAppearanceChanged(QPieSlice *slice)
-                    Q_ASSERT(slice);
-                    emit slice->appearanceChanged();
-                static void emitCalculatedDataChanged(QPieSlice *slice)
-                    Q_ASSERT(slice);
-                    emit slice->calculatedDataChanged();
-                static PieSliceData &fromSlice(QPieSlice *slice)
-                    Q_ASSERT(slice);
-                    return *slice->d;
                 qreal m_value;
                 Themed<QPen> m_slicePen;
                 Themed<QBrush> m_sliceBrush;
                 bool m_isExploded;
                 qreal m_explodeDistanceFactor;
                 bool m_isLabelVisible;
                 QString m_labelText;
                 Themed<QFont> m_labelFont;
                 qreal m_labelArmLengthFactor;
                 Themed<QPen> m_labelPen;
                 qreal m_percentage;
                 QPointF m_center;
                 qreal m_radius;
                 qreal m_startAngle;
                 qreal m_angleSpan;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESLICEDATA_P_H

src/piechart/piesliceitem.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "piesliceitem_p.h"
             #include "piechartitem_p.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #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);
             }
             PieSliceItem::PieSliceItem(QGraphicsItem* parent)
                 :QGraphicsObject(parent),
                 m_hovered(false)
             {
                 setAcceptHoverEvents(true);
                 setAcceptedMouseButtons(Qt::MouseButtonMask);
                 setZValue(ChartPresenter::PieSeriesZValue);
             }
             PieSliceItem::~PieSliceItem()
             {
                 // If user is hovering over the slice and it gets destroyed we do
                 // not get a hover leave event. So we must emit the signal here.
                 if (m_hovered)
                     emit hovered(false);
             }
             QRectF PieSliceItem::boundingRect() const
             {
                 return m_boundingRect;
             }
             QPainterPath PieSliceItem::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 PieSliceItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
             {
                 painter->save();
                 painter->setClipRect(parentItem()->boundingRect());
                 painter->setPen(m_data.m_slicePen);
                 painter->setBrush(m_data.m_sliceBrush);
                 painter->drawPath(m_slicePath);
                 painter->restore();
                 if (m_data.m_isLabelVisible) {
                     painter->setClipRect(parentItem()->boundingRect());
                     painter->setPen(m_data.m_labelPen);
                     painter->drawPath(m_labelArmPath);
             		// the pen color will affect the font color as well
                     painter->setFont(m_data.m_labelFont);
                     painter->drawText(m_labelTextRect.bottomLeft(), m_data.m_labelText);
                 }
             }
             void PieSliceItem::hoverEnterEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 m_hovered = true;
                 emit hovered(true);
             }
             void PieSliceItem::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 m_hovered = false;
                 emit hovered(false);
             }
             void PieSliceItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit clicked(event->buttons());
             }
             void PieSliceItem::setLayout(const PieSliceData &sliceData)
             {
                 m_data = sliceData;
                 updateGeometry();
                 update();
             }
             void PieSliceItem::updateGeometry()
             {
                 if (m_data.m_radius <= 0)
                     return;
                 prepareGeometryChange();
                 // update slice path
                 qreal centerAngle;
                 QPointF armStart;
                 m_slicePath = slicePath(m_data.m_center, m_data.m_radius, m_data.m_startAngle, m_data.m_angleSpan, &centerAngle, &armStart);
                 // update text rect
                 m_labelTextRect = labelTextRect(m_data.m_labelFont, m_data.m_labelText);
                 // update label arm path
                 QPointF labelTextStart;
                 m_labelArmPath = labelArmPath(armStart, centerAngle, m_data.m_radius * m_data.m_labelArmLengthFactor, m_labelTextRect.width(), &labelTextStart);
                 // update text position
                 m_labelTextRect.moveBottomLeft(labelTextStart);
                 // update bounding rect
                 if (m_data.m_isLabelVisible)
                     m_boundingRect = m_slicePath.boundingRect().united(m_labelArmPath.boundingRect()).united(m_labelTextRect);
                 else
                     m_boundingRect = m_slicePath.boundingRect();
             }
             QPointF PieSliceItem::sliceCenter(QPointF point, qreal radius, QPieSlice *slice)
             {
                 if (slice->isExploded()) {
-                    qreal centerAngle = slice->startAngle() + ((slice->endAngle() - slice->startAngle())/2);
+                    qreal centerAngle = slice->startAngle() + (slice->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 PieSliceItem::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 PieSliceItem::labelArmPath(QPointF start, qreal angle, qreal length, qreal textWidth, QPointF *textStart)
             {
                 // prevent label arm pointing straight down because it will look bad
                 if (angle < 180 && angle > 170)
                     angle = 170;
                 if (angle > 180 && angle < 190)
                     angle = 190;
                 // line from slice to label
                 qreal dx = qSin(angle*(PI/180)) * length;
                 qreal dy = -qCos(angle*(PI/180)) * length;
                 QPointF parm1 = start + QPointF(dx, dy);
                 // line to underline the label
                 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, -3);
                 QPainterPath path;
                 path.moveTo(start);
                 path.lineTo(parm1);
                 path.lineTo(parm2);
                 return path;
             }
             QRectF PieSliceItem::labelTextRect(QFont font, QString text)
             {
                 QFontMetricsF fm(font);
                 return fm.boundingRect(text);
             }
             #include "moc_piesliceitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.cpp +13 -19

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qpieslice.h"
+            #include "qpieslice_p.h"
             #include "pieslicedata_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "legendmarker_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries
                 \brief Pie series API for QtCommercial Charts
                 The pie series defines a pie chart which consists of pie slices which are defined as QPieSlice objects.
                 The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
                 The actual slice size is determined by that relative value.
                 Pie size and position on the chart is controlled by using relative values which range from 0.0 to 1.0
                 These relate to the actual chart rectangle.
                 By default the pie is defined as a full pie but it can also be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
                 Full pie is 360 degrees where 0 is at 12 a'clock.
                 See the \l {PieChart Example} {pie chart example} to learn how to create a simple pie chart.
                 \image examples_piechart.png
             */
             /*!
                 \property QPieSeries::horizontalPosition
                 \brief Defines the horizontal position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute left.
                 \o 1.0 is the absolute right.
                 \endlist
                 Default value is 0.5 (center).
             */
             /*!
                 \property QPieSeries::verticalPosition
                 \brief Defines the vertical position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute top.
                 \o 1.0 is the absolute bottom.
                 \endlist
                 Default value is 0.5 (center).
             */
             /*!
                 \property QPieSeries::size
                 \brief Defines the pie size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (pie not drawn).
                 \o 1.0 is the maximum size that can fit the chart.
                 \endlist
                 Default value is 0.7.
             */
             /*!
                 \property QPieSeries::startAngle
                 \brief Defines the starting angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 0.
             */
             /*!
                 \property QPieSeries::endAngle
                 \brief Defines the ending angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 360.
             */
             /*!
                 \property QPieSeries::count
                 \brief Number of slices in the series.
             */
             /*!
                 \property QPieSeries::sum
                 \brief Sum of all slices.
                 The series keeps track of the sum of all slices it holds.
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent) :
                 QAbstractSeries(*new QPieSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destroys the series and its slices.
             */
             QPieSeries::~QPieSeries()
             {
                 // NOTE: d_prt destroyed by QObject
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
             QAbstractSeries::SeriesType QPieSeries::type() const
             {
                 return QAbstractSeries::SeriesTypePie;
             }
             /*!
                 Appends an array of \a slices to the series.
                 Slice ownership is passed to the series.
                 Returns true if append was successfull.
             */
             bool QPieSeries::append(QList<QPieSlice*> slices)
             {
                 Q_D(QPieSeries);
                 if (slices.count() == 0)
                     return false;
                 foreach (QPieSlice* s, slices) {
                     if (!s || d->m_slices.contains(s))
                         return false;
                 }
                 foreach (QPieSlice* s, slices) {
                     s->setParent(this);
                     d->m_slices << s;
                 }
                 d->updateDerivativeData();
                 foreach (QPieSlice* s, slices) {
-                    connect(s, SIGNAL(valueChanged()), d, SLOT(sliceChanged()));
+                    connect(s, SIGNAL(valueChanged()), d, SLOT(sliceValueChanged()));
                     connect(s, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                     connect(s, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                 }
                 emit added(slices);
                 emit countChanged();
                 return true;
             }
             /*!
                 Appends a single \a slice to the series.
                 Slice ownership is passed to the series.
                 Returns true if append was succesfull.
             */
             bool QPieSeries::append(QPieSlice* slice)
             {
                 return append(QList<QPieSlice*>() << slice);
             }
             /*!
                 Appends a single \a slice to the series and returns a reference to the series.
                 Slice ownership is passed to the series.
             */
             QPieSeries& QPieSeries::operator << (QPieSlice* slice)
             {
                 append(slice);
                 return *this;
             }
             /*!
                 Appends a single slice to the series with give \a value and \a label.
                 Slice ownership is passed to the series.
             */
             QPieSlice* QPieSeries::append(QString label, qreal value)
             {
                 QPieSlice* slice = new QPieSlice(label, value);
                 append(slice);
                 return slice;
             }
             /*!
                 Inserts a single \a slice to the series before the slice at \a index position.
                 Slice ownership is passed to the series.
                 Returns true if insert was successfull.
             */
             bool QPieSeries::insert(int index, QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 if (index < 0 || index > d->m_slices.count())
                     return false;
                 if (!slice || d->m_slices.contains(slice))
                     return false;
                 slice->setParent(this);
                 d->m_slices.insert(index, slice);
                 d->updateDerivativeData();
-                connect(slice, SIGNAL(valueChanged()), d, SLOT(sliceChanged()));
+                connect(slice, SIGNAL(valueChanged()), d, SLOT(sliceValueChanged()));
                 connect(slice, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                 connect(slice, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                 emit added(QList<QPieSlice*>() << slice);
                 emit countChanged();
                 return true;
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference the pointer after this call.
                 Returns true if remove was successfull.
             */
             bool QPieSeries::remove(QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 if (!d->m_slices.removeOne(slice))
                     return false;
                 d->updateDerivativeData();
                 emit removed(QList<QPieSlice*>() << slice);
                 emit countChanged();
                 delete slice;
                 slice = 0;
                 return true;
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 Q_D(QPieSeries);
                 if (d->m_slices.count() == 0)
                     return;
                 QList<QPieSlice*> slices = d->m_slices;
                 foreach (QPieSlice* s, d->m_slices) {
                     d->m_slices.removeOne(s);
                     delete s;
                 }
                 d->updateDerivativeData();
                 emit removed(slices);
                 emit countChanged();
             }
             /*!
                 returns the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.count();
             }
             /*!
                 Returns true is the series is empty.
             */
             bool QPieSeries::isEmpty() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.isEmpty();
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice*> QPieSeries::slices() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices;
             }
             void QPieSeries::setHorizontalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (relativePosition < 0.0)
                     relativePosition = 0.0;
                 if (relativePosition > 1.0)
                     relativePosition = 1.0;
                 if (!qFuzzyIsNull(d->m_pieRelativeHorPos - relativePosition)) {
                     d->m_pieRelativeHorPos = relativePosition;
                     emit horizontalPositionChanged();
                 }
             }
             void QPieSeries::setVerticalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (relativePosition < 0.0)
                     relativePosition = 0.0;
                 if (relativePosition > 1.0)
                     relativePosition = 1.0;
                 if (!qFuzzyIsNull(d->m_pieRelativeVerPos - relativePosition)) {
                     d->m_pieRelativeVerPos = relativePosition;
                     emit verticalPositionChanged();
                 }
             }
             qreal QPieSeries::horizontalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeHorPos;
             }
             qreal QPieSeries::verticalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeVerPos;
             }
             void QPieSeries::setPieSize(qreal relativeSize)
             {
                 Q_D(QPieSeries);
                 if (relativeSize < 0.0)
                     relativeSize = 0.0;
                 if (relativeSize > 1.0)
                     relativeSize = 1.0;
                 if (!qFuzzyIsNull(d->m_pieRelativeSize - relativeSize)) {
                     d->m_pieRelativeSize = relativeSize;
                     emit pieSizeChanged();
                 }
             }
             qreal QPieSeries::pieSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeSize;
             }
             void QPieSeries::setPieStartAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (qFuzzyIsNull(d->m_pieStartAngle - angle))
                     return;
                 d->m_pieStartAngle = angle;
                 d->updateDerivativeData();
                 emit pieStartAngleChanged();
             }
             qreal QPieSeries::pieStartAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieStartAngle;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be greater than start angle.
                 \sa pieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             void QPieSeries::setPieEndAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (qFuzzyIsNull(d->m_pieEndAngle - angle))
                     return;
                 d->m_pieEndAngle = angle;
                 d->updateDerivativeData();
                 emit pieEndAngleChanged();
             }
             /*!
                 Returns the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \sa setPieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             qreal QPieSeries::pieEndAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieEndAngle;
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice* s, d->m_slices)
                     s->setLabelVisible(visible);
             }
             /*!
                 Returns the sum of all slice values in this series.
                 \sa QPieSlice::value(), QPieSlice::setValue(), QPieSlice::percentage()
             */
             qreal QPieSeries::sum() const
             {
                 Q_D(const QPieSeries);
                 return d->m_sum;
             }
             /*!
                 \fn void QPieSeries::added(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices have been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \fn void QPieSeries::removed(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices have been removed from the series.
                 \sa remove()
             */
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice)
                 This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
             /*!
                 \fn void QPieSeries::hovered(QPieSlice* slice, bool state)
                 This signal is emitted when user has hovered over or away from the \a slice.
                 \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
                 \sa QPieSlice::hovered()
             */
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPieSeriesPrivate::QPieSeriesPrivate(QPieSeries *parent) :
                 QAbstractSeriesPrivate(parent),
                 m_pieRelativeHorPos(0.5),
                 m_pieRelativeVerPos(0.5),
                 m_pieRelativeSize(0.7),
                 m_pieStartAngle(0),
                 m_pieEndAngle(360),
                 m_sum(0)
             {
             }
             QPieSeriesPrivate::~QPieSeriesPrivate()
             {
             }
             void QPieSeriesPrivate::updateDerivativeData()
             {
                 // calculate sum of all slices
                 qreal sum = 0;
                 foreach (QPieSlice* s, m_slices)
                     sum += s->value();
                 if (!qFuzzyIsNull(m_sum - sum)) {
                     m_sum = sum;
                     emit q_func()->sumChanged();
                 }
                 // nothing to show..
                 if (qFuzzyIsNull(m_sum))
                     return;
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
                 QVector<QPieSlice*> changed;
                 foreach (QPieSlice* s, m_slices) {
+                    QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s);
-                    PieSliceData data = PieSliceData::fromSlice(s);
+                    d->setPercentage(s->value() / m_sum);
-                    data.m_percentage = s->value() / m_sum;
+                    d->setStartAngle(sliceAngle);
-                    data.m_angleSpan = pieSpan * data.m_percentage;
+                    d->setAngleSpan(pieSpan * s->percentage());
-                    data.m_startAngle = sliceAngle;
+                    sliceAngle += s->angleSpan();
-                    sliceAngle += data.m_angleSpan;
-                    if (PieSliceData::fromSlice(s) != data) {
-                        PieSliceData::fromSlice(s) = data;
-                        changed << s;
                 }
-                // emit signals
-                foreach (QPieSlice* s, changed)
+                emit calculatedDataChanged();
-                    PieSliceData::emitCalculatedDataChanged(s);
             }
-            QPieSeriesPrivate* QPieSeriesPrivate::seriesData(QPieSeries &series)
+            QPieSeriesPrivate* QPieSeriesPrivate::fromSeries(QPieSeries *series)
             {
-                return series.d_func();
+                return series->d_func();
             }
-            void QPieSeriesPrivate::sliceChanged()
+            void QPieSeriesPrivate::sliceValueChanged()
             {
                 Q_ASSERT(m_slices.contains(qobject_cast<QPieSlice *>(sender())));
                 updateDerivativeData();
             }
             void QPieSeriesPrivate::sliceClicked()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->clicked(slice);
             }
             void QPieSeriesPrivate::sliceHovered(bool state)
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->hovered(slice, state);
             }
             void QPieSeriesPrivate::scaleDomain(Domain& domain)
             {
                 Q_UNUSED(domain);
                 // does not apply to pie
             }
             Chart* QPieSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QPieSeries);
                 PieChartItem* pie = new PieChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(pie);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return pie;
             }
             QList<LegendMarker*> QPieSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QPieSeries);
                 QList<LegendMarker*> markers;
                 foreach(QPieSlice* slice, q->slices()) {
                     PieLegendMarker* marker = new PieLegendMarker(q,slice,legend);
                     markers << marker;
                 }
                 return markers;
             }
             #include "moc_qpieseries.cpp"
             #include "moc_qpieseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries_p.h +6 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QPIESERIES_P_H
             #define QPIESERIES_P_H
             #include "qpieseries.h"
             #include "qabstractseries_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLegendPrivate;
             class QPieSeriesPrivate : public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QPieSeriesPrivate(QPieSeries *parent);
                 ~QPieSeriesPrivate();
                 void scaleDomain(Domain& domain);
                 Chart* createGraphics(ChartPresenter *presenter);
                 QList<LegendMarker*> createLegendMarker(QLegend *legend);
                 void updateDerivativeData();
-                static QPieSeriesPrivate* seriesData(QPieSeries &series);
+                static QPieSeriesPrivate* fromSeries(QPieSeries *series);
+            signals:
+                void calculatedDataChanged();
             public Q_SLOTS:
-                void sliceChanged();
+                void sliceValueChanged();
                 void sliceClicked();
                 void sliceHovered(bool state);
-            public:
+            private:
                 QList<QPieSlice*> m_slices;
                 qreal m_pieRelativeHorPos;
                 qreal m_pieRelativeVerPos;
                 qreal m_pieRelativeSize;
                 qreal m_pieStartAngle;
                 qreal m_pieEndAngle;
                 qreal m_sum;
             private:
                 friend class QLegendPrivate;
                 Q_DECLARE_PUBLIC(QPieSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIESERIES_P_H

src/piechart/qpieslice.cpp +118 -56

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qpieslice.h"
-            #include "pieslicedata_p.h"
+            #include "qpieslice_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSlice
                 \brief Defines a slice in pie series.
                 This object defines the properties of a single slice in a QPieSeries.
                 In addition to the obvious value and label properties the user can also control
                 the visual appearance of a slice. By modifying the visual appearance also means that
                 the user is overriding the default appearance set by the theme. Even if the theme is
                 changed users settings will persist.
                 To enable user interaction customization with the slices some basic signals
                 are provided about clicking and hovering.
             */
             /*!
                 \property QPieSlice::label
                 Label of the slice.
             */
             /*!
                 \property QPieSlice::value
                 Value of the slice.
                 \sa percentage(), QPieSeries::sum()
             */
             /*!
                 Constructs an empty slice with a \a parent.
                 \sa QPieSeries::append(), QPieSeries::insert()
             */
             QPieSlice::QPieSlice(QObject *parent)
                 :QObject(parent),
-                d(new PieSliceData())
+                d_ptr(new QPieSlicePrivate(this))
             {
             }
             /*!
                 Constructs an empty slice with given \a value, \a label and a \a parent.
                 \sa QPieSeries::append(), QPieSeries::insert()
             */
             QPieSlice::QPieSlice(QString label, qreal value, QObject *parent)
                 :QObject(parent),
-                d(new PieSliceData())
+                d_ptr(new QPieSlicePrivate(this))
             {
-                d->m_value = value;
+                d_ptr->m_data.m_value = value;
-                d->m_labelText = label;
+                d_ptr->m_data.m_labelText = label;
             }
             /*!
                 Destroys the slice.
                 User should not delete the slice if it has been added to the series.
             */
             QPieSlice::~QPieSlice()
             {
-                delete d;
             }
             /*!
                 Gets the value of the slice.
                 Note that all values in the series
                 \sa setValue()
             */
             qreal QPieSlice::value() const
             {
-                return d->m_value;
+                return d_ptr->m_data.m_value;
             }
             /*!
                 Gets the label of the slice.
                 \sa setLabel()
             */
             QString QPieSlice::label() const
             {
-                return d->m_labelText;
+                return d_ptr->m_data.m_labelText;
             }
             /*!
                 Returns true if label is set as visible.
                 \sa setLabelVisible()
             */
             bool QPieSlice::isLabelVisible() const
             {
-                return d->m_isLabelVisible;
+                return d_ptr->m_data.m_isLabelVisible;
             }
             /*!
                 Returns true if slice is exloded from the pie.
                 \sa setExploded(), explodeDistanceFactor(), setExplodeDistanceFactor()
             */
             bool QPieSlice::isExploded() const
             {
-                return d->m_isExploded;
+                return d_ptr->m_data.m_isExploded;
             }
             /*!
                 Returns the explode distance factor.
                 The factor is relative to pie radius. For example:
 .0 means the distance is the same as the radius.
 .5 means the distance is half of the radius.
                 Default value is 0.15.
                 \sa setExplodeDistanceFactor(), isExploded(), setExploded()
             */
             qreal QPieSlice::explodeDistanceFactor() const
             {
-                return d->m_explodeDistanceFactor;
+                return d_ptr->m_data.m_explodeDistanceFactor;
             }
             /*!
                 Returns the percentage of this slice compared to the sum of all slices in the same series.
                 The returned value ranges from 0 to 1.0.
                 Updated internally after the slice is added to the series.
                 \sa QPieSeries::sum()
             */
             qreal QPieSlice::percentage() const
             {
-                return d->m_percentage;
+                return d_ptr->m_data.m_percentage;
             }
             /*!
                 Returns the starting angle of this slice in the series it belongs to.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated internally after the slice is added to the series.
             */
             qreal QPieSlice::startAngle() const
             {
-                return d->m_startAngle;
+                return d_ptr->m_data.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
+            qreal QPieSlice::angleSpan() const
             {
-                return d->m_startAngle + d->m_angleSpan;
+                return d_ptr->m_data.m_angleSpan;
             }
             /*!
                 Returns the pen used to draw this slice.
                 \sa setPen()
             */
             QPen QPieSlice::pen() const
             {
-                return d->m_slicePen;
+                return d_ptr->m_data.m_slicePen;
             }
             /*!
                 Returns the brush used to draw this slice.
                 \sa setBrush()
             */
             QBrush QPieSlice::brush() const
             {
-                return d->m_sliceBrush;
+                return d_ptr->m_data.m_sliceBrush;
             }
             /*!
                 Returns the pen used to draw the label in this slice.
                 \sa setLabelPen()
             */
             QPen QPieSlice::labelPen() const
             {
-                return d->m_labelPen;
+                return d_ptr->m_data.m_labelPen;
             }
             /*!
                 Returns the font used to draw label in this slice.
                 \sa setLabelFont()
             */
             QFont QPieSlice::labelFont() const
             {
-                return d->m_labelFont;
+                return d_ptr->m_data.m_labelFont;
             }
             /*!
                 Gets the label arm length factor.
                 The factor is relative to pie radius. For example:
 .0 means the length is the same as the radius.
 .5 means the length is half of the radius.
                 Default value is 0.15
                 \sa setLabelArmLengthFactor()
             */
             qreal QPieSlice::labelArmLengthFactor() const
             {
-                return d->m_labelArmLengthFactor;
+                return d_ptr->m_data.m_labelArmLengthFactor;
             }
             /*!
                 \fn void QPieSlice::labelChanged()
                 This signal is emitted when the slice label changes.
                 \sa setLabel()
             */
             /*!
                 \fn void QPieSlice::valueChanged()
                 This signal is emitted when the slice value changes.
                 \sa setValue()
             */
             /*!
                 \fn void QPieSlice::appearanceChanged()
                 This signal is emitted when visual appearance of the slice changes.
                 \sa setPen(), setBrush(), setLabelVisible(), setExploded()
             */
             /*!
                 \fn void QPieSlice::calculatedDataChanged()
                 This signal is emitted when calculated data for this slice changes.
                 \sa percentage(), startAngle(), endAngle()
             */
             /*!
                 \fn void QPieSlice::clicked()
                 This signal is emitted when user has clicked the slice.
                 \sa QPieSeries::clicked()
             */
             /*!
                 \fn void QPieSlice::hovered(bool state)
                 This signal is emitted when user has hovered over or away from the slice.
                 \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
                 \sa QPieSeries::hovered()
             */
             /*!
                 Sets the \a value of this slice.
                 \sa value()
             */
             void QPieSlice::setValue(qreal value)
             {
-                if (!qFuzzyIsNull(d->m_value - value)) {
+                if (!qFuzzyIsNull(d_ptr->m_data.m_value - value)) {
-                    d->m_value = value;
+                    d_ptr->m_data.m_value = value;
                     emit valueChanged();
                 }
             }
             /*!
                 Sets the \a label of the slice.
                 \sa label()
             */
             void QPieSlice::setLabel(QString label)
             {
-                if (d->m_labelText != label) {
+                if (d_ptr->m_data.m_labelText != label) {
-                    d->m_labelText = label;
+                    d_ptr->m_data.m_labelText = label;
                     emit labelChanged();
                 }
             }
             /*!
                 Sets the label \a visible in this slice.
                 \sa isLabelVisible(), QPieSeries::setLabelsVisible()
             */
             void QPieSlice::setLabelVisible(bool visible)
             {
-                if (d->m_isLabelVisible != visible) {
+                if (d_ptr->m_data.m_isLabelVisible != visible) {
-                    d->m_isLabelVisible = visible;
+                    d_ptr->m_data.m_isLabelVisible = visible;
-                    emit appearanceChanged();
+                    emit labelVisibleChanged();
                 }
             }
             /*!
                 Sets this slices \a exploded state.
                 If the slice is exploded it is moved away from the pie center. The distance is defined by the explode distance factor.
                 \sa isExploded(), explodeDistanceFactor(), setExplodeDistanceFactor()
             */
             void QPieSlice::setExploded(bool exploded)
             {
-                if (d->m_isExploded != exploded) {
+                if (d_ptr->m_data.m_isExploded != exploded) {
-                    d->m_isExploded = exploded;
+                    d_ptr->m_data.m_isExploded = exploded;
-                    emit appearanceChanged();
+                    emit explodedChanged();
                 }
             }
             /*!
                 Sets the explode distance \a factor.
                 The factor is relative to pie radius. For example:
 .0 means the distance is the same as the radius.
 .5 means the distance is half of the radius.
                 Default value is 0.15
                 \sa explodeDistanceFactor(), isExploded(), setExploded()
             */
             void QPieSlice::setExplodeDistanceFactor(qreal factor)
             {
-                if (!qFuzzyIsNull(d->m_explodeDistanceFactor - factor)) {
+                if (!qFuzzyIsNull(d_ptr->m_data.m_explodeDistanceFactor - factor)) {
-                    d->m_explodeDistanceFactor = factor;
+                    d_ptr->m_data.m_explodeDistanceFactor = factor;
-                    emit appearanceChanged();
+                    emit explodeDistanceFactorChanged();
                 }
             }
             /*!
                 Sets the \a pen used to draw this slice.
                 Overrides the pen set by the theme.
                 \sa pen()
             */
             void QPieSlice::setPen(const QPen &pen)
             {
-                if (d->m_slicePen != pen) {
+                d_ptr->setPen(pen, false);
-                    d->m_slicePen = pen;
-                    d->m_slicePen.setThemed(false);
-                    emit appearanceChanged();
             }
             /*!
                 Sets the \a brush used to draw this slice.
                 Overrides the brush set by the theme.
                 \sa brush()
             */
             void QPieSlice::setBrush(const QBrush &brush)
             {
-                if (d->m_sliceBrush != brush) {
+                d_ptr->setBrush(brush, false);
-                    d->m_sliceBrush = brush;
-                    d->m_sliceBrush.setThemed(false);
-                    emit appearanceChanged();
             }
             /*!
                 Sets the \a pen used to draw the label in this slice.
                 Overrides the pen set by the theme.
                 \sa labelPen()
             */
             void QPieSlice::setLabelPen(const QPen &pen)
             {
-                if (d->m_labelPen != pen) {
+                d_ptr->setLabelPen(pen, false);
-                    d->m_labelPen = pen;
-                    d->m_labelPen.setThemed(false);
-                    emit appearanceChanged();
             }
             /*!
                 Sets the \a font used to draw the label in this slice.
                 Overrides the font set by the theme.
                 \sa labelFont()
             */
             void QPieSlice::setLabelFont(const QFont &font)
             {
-                if (d->m_labelFont != font) {
+                d_ptr->setLabelFont(font, false);
-                    d->m_labelFont = font;
-                    d->m_labelFont.setThemed(false);
-                    emit appearanceChanged();
             }
             /*!
                 Sets the label arm length \a factor.
                 The factor is relative to pie radius. For example:
 .0 means the length is the same as the radius.
 .5 means the length is half of the radius.
                 Default value is 0.15
                 \sa labelArmLengthFactor()
             */
             void QPieSlice::setLabelArmLengthFactor(qreal factor)
             {
-                if (!qFuzzyIsNull(d->m_labelArmLengthFactor - factor)) {
+                if (!qFuzzyIsNull(d_ptr->m_data.m_labelArmLengthFactor - factor)) {
-                    d->m_labelArmLengthFactor = factor;
+                    d_ptr->m_data.m_labelArmLengthFactor = factor;
-                    emit appearanceChanged();
+                    emit labelArmLengthFactorChanged();
+                }
+            }
+            QPieSlicePrivate::QPieSlicePrivate(QPieSlice *parent)
+                :QObject(parent),
+                q_ptr(parent)
+            {
+            }
+            QPieSlicePrivate::~QPieSlicePrivate()
+            {
+            }
+            QPieSlicePrivate *QPieSlicePrivate::fromSlice(QPieSlice *slice)
+            {
+                return slice->d_func();
+            }
+            void QPieSlicePrivate::setPen(const QPen &pen, bool themed)
+            {
+                if (m_data.m_slicePen != pen) {
+                    m_data.m_slicePen = pen;
+                    m_data.m_slicePen.setThemed(themed);
+                    emit q_ptr->penChanged();
+                }
+            }
+            void QPieSlicePrivate::setBrush(const QBrush &brush, bool themed)
+            {
+                if (m_data.m_sliceBrush != brush) {
+                    m_data.m_sliceBrush = brush;
+                    m_data.m_sliceBrush.setThemed(themed);
+                    emit q_ptr->brushChanged();
+                }
+            }
+            void QPieSlicePrivate::setLabelPen(const QPen &pen, bool themed)
+            {
+                if (m_data.m_labelPen != pen) {
+                    m_data.m_labelPen = pen;
+                    m_data.m_labelPen.setThemed(themed);
+                    emit q_ptr->labelPenChanged();
+                }
+            }
+            void QPieSlicePrivate::setLabelFont(const QFont &font, bool themed)
+            {
+                if (m_data.m_labelFont != font) {
+                    m_data.m_labelFont = font;
+                    m_data.m_labelFont.setThemed(themed);
+                    emit q_ptr->labelFontChanged();
+                }
+            }
+            void QPieSlicePrivate::setPercentage(qreal percentage)
+            {
+                if (!qFuzzyIsNull(m_data.m_percentage - percentage)) {
+                    m_data.m_percentage = percentage;
+                    emit q_ptr->percentageChanged();
+                }
+            }
+            void QPieSlicePrivate::setStartAngle(qreal angle)
+            {
+                if (!qFuzzyIsNull(m_data.m_startAngle - angle)) {
+                    m_data.m_startAngle = angle;
+                    emit q_ptr->startAngleChanged();
+                }
+            }
+            void QPieSlicePrivate::setAngleSpan(qreal span)
+            {
+                if (!qFuzzyIsNull(m_data.m_angleSpan - span)) {
+                    m_data.m_angleSpan = span;
+                    emit q_ptr->angleSpanChanged();
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             #include "moc_qpieslice.cpp"
+            #include "moc_qpieslice_p.cpp"

src/piechart/qpieslice.h +32 -19

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QPIESLICE_H
             #define QPIESLICE_H
             #include <qchartglobal.h>
             #include <QObject>
             #include <QPen>
             #include <QBrush>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class PieSliceData;
+            class QPieSlicePrivate;
             class QTCOMMERCIALCHART_EXPORT QPieSlice : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QString label READ label WRITE setLabel NOTIFY labelChanged)
                 Q_PROPERTY(qreal value READ value WRITE setValue NOTIFY valueChanged)
-                Q_PROPERTY(bool labelVisible READ isLabelVisible WRITE setLabelVisible)
+                Q_PROPERTY(bool labelVisible READ isLabelVisible WRITE setLabelVisible NOTIFY labelVisibleChanged)
-                Q_PROPERTY(bool exploded READ isExploded WRITE setExploded)
+                Q_PROPERTY(bool exploded READ isExploded WRITE setExploded NOTIFY explodedChanged)
+                Q_PROPERTY(QPen pen READ pen WRITE setPen NOTIFY penChanged)
+                Q_PROPERTY(QBrush brush READ brush WRITE setBrush NOTIFY brushChanged)
+                Q_PROPERTY(QPen labelPen READ labelPen WRITE setLabelPen NOTIFY labelPenChanged)
+                Q_PROPERTY(QFont labelFont READ labelFont WRITE setLabelFont NOTIFY labelFontChanged)
                 Q_PROPERTY(qreal LabelArmLengthFactor READ labelArmLengthFactor WRITE setLabelArmLengthFactor)
                 Q_PROPERTY(qreal explodeDistanceFactor READ explodeDistanceFactor WRITE setExplodeDistanceFactor)
-                Q_PROPERTY(qreal percentage READ percentage NOTIFY calculatedDataChanged)
+                Q_PROPERTY(qreal percentage READ percentage NOTIFY percentageChanged)
-                Q_PROPERTY(qreal startAngle READ startAngle NOTIFY calculatedDataChanged)
+                Q_PROPERTY(qreal startAngle READ startAngle NOTIFY startAngleChanged)
-                Q_PROPERTY(qreal endAngle READ endAngle NOTIFY calculatedDataChanged)
+                Q_PROPERTY(qreal angleSpan READ angleSpan NOTIFY angleSpanChanged)
             public:
                 explicit QPieSlice(QObject *parent = 0);
                 QPieSlice(QString label, qreal value, QObject *parent = 0);
                 virtual ~QPieSlice();
                 void setLabel(QString label);
                 QString label() const;
                 void setValue(qreal value);
                 qreal value() const;
+                void setLabelVisible(bool visible = true);
+                bool isLabelVisible() const;
+                void setExploded(bool exploded = true);
+                bool isExploded() const;
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
-                void setLabelVisible(bool visible = true);
-                bool isLabelVisible() const;
-                void setLabelArmLengthFactor(qreal factor);
-                qreal labelArmLengthFactor() const;
                 void setLabelPen(const QPen &pen);
                 QPen labelPen() const;
                 void setLabelFont(const QFont &font);
                 QFont labelFont() const;
-                void setExploded(bool exploded = true);
+                void setLabelArmLengthFactor(qreal factor);
-                bool isExploded() const;
+                qreal labelArmLengthFactor() const;
                 void setExplodeDistanceFactor(qreal factor);
                 qreal explodeDistanceFactor() const;
                 qreal percentage() const;
                 qreal startAngle() const;
-                qreal endAngle() const;
+                qreal angleSpan() const;
             Q_SIGNALS:
                 void labelChanged();
                 void valueChanged();
-                void appearanceChanged();
+                void labelVisibleChanged();
-                void calculatedDataChanged();
+                void explodedChanged();
+                void penChanged();
+                void brushChanged();
+                void labelPenChanged();
+                void labelFontChanged();
+                void labelArmLengthFactorChanged();
+                void explodeDistanceFactorChanged();
+                void percentageChanged();
+                void startAngleChanged();
+                void angleSpanChanged();
                 void clicked();
                 void hovered(bool state);
             private:
-                friend class PieSliceData;
+                QPieSlicePrivate * const d_ptr;
-                PieSliceData * const d;
+                Q_DECLARE_PRIVATE(QPieSlice)
                 Q_DISABLE_COPY(QPieSlice)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIESLICE_H

tests/auto/qpieseries/tst_qpieseries.cpp +23 -8

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <qchartview.h>
             #include <qchart.h>
             #include <qpieseries.h>
             #include <qpieslice.h>
             #include <qpiemodelmapper.h>
             #include <QStandardItemModel>
             #include <tst_definitions.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QPieSlice*)
             class tst_qpieseries : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void properties();
                 void append();
                 void insert();
                 void remove();
                 void calculatedValues();
                 void clickedSignal();
                 void hoverSignal();
             private:
                 void verifyCalculatedData(const QPieSeries &series, bool *ok);
             private:
             };
             void tst_qpieseries::initTestCase()
             {
                 qRegisterMetaType<QPieSlice*>("QPieSlice*");
             }
             void tst_qpieseries::cleanupTestCase()
             {
             }
             void tst_qpieseries::init()
             {
             }
             void tst_qpieseries::cleanup()
             {
             }
             void tst_qpieseries::properties()
             {
                 QPieSeries s;
                 QSignalSpy countSpy(&s, SIGNAL(countChanged()));
                 QSignalSpy sumSpy(&s, SIGNAL(sumChanged()));
                 QSignalSpy sizeSpy(&s, SIGNAL(pieSizeChanged()));
                 QSignalSpy startAngleSpy(&s, SIGNAL(pieStartAngleChanged()));
                 QSignalSpy endAngleSpy(&s, SIGNAL(pieEndAngleChanged()));
                 QSignalSpy horPosSpy(&s, SIGNAL(horizontalPositionChanged()));
                 QSignalSpy verPosSpy(&s, SIGNAL(verticalPositionChanged()));
                 QVERIFY(s.type() == QAbstractSeries::SeriesTypePie);
                 QVERIFY(s.count() == 0);
                 QVERIFY(s.isEmpty());
                 QCOMPARE(s.sum(), 0.0);
                 QCOMPARE(s.horizontalPosition(), 0.5);
                 QCOMPARE(s.verticalPosition(), 0.5);
                 QCOMPARE(s.pieSize(), 0.7);
                 QCOMPARE(s.pieStartAngle(), 0.0);
                 QCOMPARE(s.pieEndAngle(), 360.0);
                 s.append("s1", 1);
                 s.append("s2", 1);
                 s.append("s3", 1);
                 s.insert(1, new QPieSlice("s4", 1));
                 s.remove(s.slices().first());
                 QCOMPARE(s.count(), 3);
                 QCOMPARE(s.sum(), 3.0);
                 s.clear();
                 QCOMPARE(s.count(), 0);
                 QCOMPARE(s.sum(), 0.0);
                 QCOMPARE(countSpy.count(), 6);
                 QCOMPARE(sumSpy.count(), 6);
                 s.setPieSize(-1.0);
                 QCOMPARE(s.pieSize(), 0.0);
                 s.setPieSize(0.0);
                 s.setPieSize(0.9);
                 s.setPieSize(2.0);
                 QCOMPARE(s.pieSize(), 1.0);
                 QCOMPARE(sizeSpy.count(), 3);
                 s.setPieStartAngle(0);
                 s.setPieStartAngle(-180);
                 s.setPieStartAngle(180);
                 QCOMPARE(startAngleSpy.count(), 2);
                 s.setPieEndAngle(360);
                 s.setPieEndAngle(-180);
                 s.setPieEndAngle(180);
                 QCOMPARE(endAngleSpy.count(), 2);
                 s.setHorizontalPosition(0.5);
                 s.setHorizontalPosition(-1.0);
                 QCOMPARE(s.horizontalPosition(), 0.0);
                 s.setHorizontalPosition(1.0);
                 s.setHorizontalPosition(2.0);
                 QCOMPARE(s.horizontalPosition(), 1.0);
                 QCOMPARE(horPosSpy.count(), 2);
                 s.setVerticalPosition(0.5);
                 s.setVerticalPosition(-1.0);
                 QCOMPARE(s.verticalPosition(), 0.0);
                 s.setVerticalPosition(1.0);
                 s.setVerticalPosition(2.0);
                 QCOMPARE(s.verticalPosition(), 1.0);
                 QCOMPARE(verPosSpy.count(), 2);
             }
             void tst_qpieseries::append()
             {
                 QPieSeries s;
                 // append pointer
                 QPieSlice *slice1 = 0;
                 QVERIFY(!s.append(slice1));
                 slice1 = new QPieSlice("slice 1", 1);
                 QVERIFY(s.append(slice1));
                 QVERIFY(!s.append(slice1));
                 QCOMPARE(s.count(), 1);
                 // append pointer list
                 QList<QPieSlice *> list;
                 QVERIFY(!s.append(list));
                 list << (QPieSlice *) 0;
                 QVERIFY(!s.append(list));
                 list.clear();
                 list << new QPieSlice("slice 2", 2);
                 list << new QPieSlice("slice 3", 3);
                 QVERIFY(s.append(list));
                 QVERIFY(!s.append(list));
                 QCOMPARE(s.count(), 3);
                 // append operator
                 s << new QPieSlice("slice 4", 4);
                 s << slice1; // fails because already added
                 QCOMPARE(s.count(), 4);
                 // append with params
                 QPieSlice *slice5 = s.append("slice 5", 5);
                 QVERIFY(slice5 != 0);
                 QCOMPARE(slice5->value(), 5.0);
                 QCOMPARE(slice5->label(), QString("slice 5"));
                 QCOMPARE(s.count(), 5);
                 // check slices
                 QVERIFY(!s.isEmpty());
                 for (int i=0; i<s.count(); i++) {
                     QCOMPARE(s.slices().at(i)->value(), (qreal) i+1);
                     QCOMPARE(s.slices().at(i)->label(), QString("slice ") + QString::number(i+1));
                 }
             }
             void tst_qpieseries::insert()
             {
                 QPieSeries s;
                 // insert one slice
                 QPieSlice *slice1 = 0;
                 QVERIFY(!s.insert(0, slice1));
                 slice1 = new QPieSlice("slice 1", 1);
                 QVERIFY(!s.insert(-1, slice1));
                 QVERIFY(!s.insert(5, slice1));
                 QVERIFY(s.insert(0, slice1));
                 QVERIFY(!s.insert(0, slice1));
                 QCOMPARE(s.count(), 1);
                 // add some more slices
                 s.append("slice 2", 2);
                 s.append("slice 4", 4);
                 QCOMPARE(s.count(), 3);
                 // insert between slices
                 s.insert(2, new QPieSlice("slice 3", 3));
                 QCOMPARE(s.count(), 4);
                 // check slices
                 for (int i=0; i<s.count(); i++) {
                     QCOMPARE(s.slices().at(i)->value(), (qreal) i+1);
                     QCOMPARE(s.slices().at(i)->label(), QString("slice ") + QString::number(i+1));
                 }
             }
             void tst_qpieseries::remove()
             {
                 QPieSeries s;
                 // add some slices
                 QPieSlice *slice1 = s.append("slice 1", 1);
                 QPieSlice *slice2 = s.append("slice 2", 2);
                 QPieSlice *slice3 = s.append("slice 3", 3);
                 QSignalSpy spy1(slice1, SIGNAL(destroyed()));
                 QSignalSpy spy2(slice2, SIGNAL(destroyed()));
                 QSignalSpy spy3(slice3, SIGNAL(destroyed()));
                 QCOMPARE(s.count(), 3);
                 // null pointer remove
                 QVERIFY(!s.remove(0));
                 // remove first
                 QVERIFY(s.remove(slice1));
                 QVERIFY(!s.remove(slice1));
                 QCOMPARE(s.count(), 2);
                 QCOMPARE(s.slices().at(0)->label(), slice2->label());
                 // remove all
                 s.clear();
                 QVERIFY(s.isEmpty());
                 QVERIFY(s.slices().isEmpty());
                 QCOMPARE(s.count(), 0);
                 // check that slices were actually destroyed
                 TRY_COMPARE(spy1.count(), 1);
                 TRY_COMPARE(spy2.count(), 1);
                 TRY_COMPARE(spy3.count(), 1);
             }
             void tst_qpieseries::calculatedValues()
             {
                 bool ok;
                 QPieSeries s;
                 QPieSlice *slice1 = new QPieSlice("slice 1", 1);
-                QSignalSpy calculatedDataSpy(slice1, SIGNAL(calculatedDataChanged()));
+                QSignalSpy percentageSpy(slice1, SIGNAL(percentageChanged()));
+                QSignalSpy startAngleSpy(slice1, SIGNAL(startAngleChanged()));
+                QSignalSpy angleSpanSpy(slice1, SIGNAL(angleSpanChanged()));
                 // add a slice
                 s.append(slice1);
                 verifyCalculatedData(s, &ok);
                 if (!ok)
                     return;
-                QCOMPARE(calculatedDataSpy.count(), 1);
+                QCOMPARE(percentageSpy.count(), 1);
+                QCOMPARE(startAngleSpy.count(), 0);
+                QCOMPARE(angleSpanSpy.count(), 1);
                 // add some more slices
                 QList<QPieSlice *> list;
                 list << new QPieSlice("slice 2", 2);
                 list << new QPieSlice("slice 3", 3);
                 s.append(list);
                 verifyCalculatedData(s, &ok);
                 if (!ok)
                     return;
-                QCOMPARE(calculatedDataSpy.count(), 2);
+                QCOMPARE(percentageSpy.count(), 2);
+                QCOMPARE(startAngleSpy.count(), 0);
+                QCOMPARE(angleSpanSpy.count(), 2);
                 // remove a slice
                 s.remove(list.first()); // remove slice 2
                 verifyCalculatedData(s, &ok);
                 if (!ok)
                     return;
-                QCOMPARE(calculatedDataSpy.count(), 3);
+                QCOMPARE(percentageSpy.count(), 3);
+                QCOMPARE(startAngleSpy.count(), 0);
+                QCOMPARE(angleSpanSpy.count(), 3);
                 // insert a slice
                 s.insert(0, new QPieSlice("Slice 4", 4));
                 verifyCalculatedData(s, &ok);
                 if (!ok)
                     return;
-                QCOMPARE(calculatedDataSpy.count(), 4);
+                QCOMPARE(percentageSpy.count(), 4);
+                QCOMPARE(startAngleSpy.count(), 1);
+                QCOMPARE(angleSpanSpy.count(), 4);
                 // modify pie angles
                 s.setPieStartAngle(-90);
                 s.setPieEndAngle(90);
                 verifyCalculatedData(s, &ok);
                 if (!ok)
                     return;
-                QCOMPARE(calculatedDataSpy.count(), 6);
+                QCOMPARE(percentageSpy.count(), 4);
+                QCOMPARE(startAngleSpy.count(), 3);
+                QCOMPARE(angleSpanSpy.count(), 6);
                 // clear all
                 s.clear();
                 verifyCalculatedData(s, &ok);
+                QCOMPARE(percentageSpy.count(), 4);
+                QCOMPARE(startAngleSpy.count(), 3);
+                QCOMPARE(angleSpanSpy.count(), 6);
             }
             void tst_qpieseries::verifyCalculatedData(const QPieSeries &series, bool *ok)
             {
                 *ok = false;
                 qreal sum = 0;
                 foreach (const QPieSlice *slice, series.slices())
                     sum += slice->value();
                 QCOMPARE(series.sum(), sum);
                 qreal startAngle = series.pieStartAngle();
                 qreal pieAngleSpan = series.pieEndAngle() - series.pieStartAngle();
                 foreach (const QPieSlice *slice, series.slices()) {
                     qreal ratio = slice->value() / sum;
                     qreal sliceSpan = pieAngleSpan * ratio;
                     QCOMPARE(slice->startAngle(), startAngle);
-                    QCOMPARE(slice->endAngle(), startAngle + sliceSpan);
+                    QCOMPARE(slice->angleSpan(), sliceSpan);
                     QCOMPARE(slice->percentage(), ratio);
                     startAngle += sliceSpan;
                 }
                 if (!series.isEmpty())
-                    QCOMPARE(series.slices().last()->endAngle(), series.pieEndAngle());
+                    QCOMPARE(series.slices().last()->startAngle() + series.slices().last()->angleSpan(), series.pieEndAngle());
                 *ok = true;
             }
             void tst_qpieseries::clickedSignal()
             {
                 // create a pie series
                 QPieSeries *series = new QPieSeries();
                 QPieSlice *s1 = series->append("slice 1", 1);
                 QPieSlice *s2 = series->append("slice 2", 1);
                 QPieSlice *s3 = series->append("slice 3", 1);
                 QPieSlice *s4 = series->append("slice 4", 1);
                 QSignalSpy clickSpy(series, SIGNAL(clicked(QPieSlice*)));
                 // add series to the chart
                 QChartView view(new QChart());
                 view.chart()->legend()->setVisible(false);
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // if you devide the chart in four equal tiles these
                 // are the center points of those tiles
                 QPoint p1(90.25, 90);
                 QPoint p2(150, 90);
                 QPoint p3(90, 150);
                 QPoint p4(150, 150);
                 QPoint center(120, 120);
                 series->setPieSize(1.0);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p1);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p2);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p3);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p4);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, center);
                 TRY_COMPARE(clickSpy.count(), 5); // all hit
                 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(0).at(0)), s4);
                 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(1).at(0)), s1);
                 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(2).at(0)), s3);
                 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(3).at(0)), s2);
                 clickSpy.clear();
                 series->setPieSize(0.5);
                 series->setVerticalPosition(0.25);
                 series->setHorizontalPosition(0.25);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p1); // hits
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p2);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p3);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p4);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, center);
                 TRY_COMPARE(clickSpy.count(), 1);
                 clickSpy.clear();
                 series->setVerticalPosition(0.25);
                 series->setHorizontalPosition(0.75);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p1);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p2); // hits
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p3);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p4);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, center);
                 TRY_COMPARE(clickSpy.count(), 1);
                 clickSpy.clear();
                 series->setVerticalPosition(0.75);
                 series->setHorizontalPosition(0.25);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p1);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p2);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p3); // hits
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p4);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, center);
                 TRY_COMPARE(clickSpy.count(), 1);
                 clickSpy.clear();
                 series->setVerticalPosition(0.75);
                 series->setHorizontalPosition(0.75);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p1);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p2);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p3);
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p4); // hits
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, center);
                 TRY_COMPARE(clickSpy.count(), 1);
                 clickSpy.clear();
             }
             void tst_qpieseries::hoverSignal()
             {
                 // create a pie series
                 QPieSeries *series = new QPieSeries();
                 series->setPieSize(1.0);
                 QPieSlice *s1 = series->append("slice 1", 1);
                 series->append("slice 2", 2);
                 series->append("slice 3", 3);
                 // add series to the chart
                 QChartView view(new QChart());
                 view.chart()->legend()->setVisible(false);
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // first move to right top corner
                 QTest::mouseMove(view.viewport(), QPoint(200, 0));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 // move inside the slice
                 // pie rectangle: QRectF(60,60 121x121)
                 QSignalSpy hoverSpy(series, SIGNAL(hovered(QPieSlice*,bool)));
                 QTest::mouseMove(view.viewport(), QPoint(139, 85));
                 TRY_COMPARE(hoverSpy.count(), 1);
                 QCOMPARE(qvariant_cast<QPieSlice*>(hoverSpy.at(0).at(0)), s1);
                 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(0).at(1)), true);
                 // move outside the slice
                 QTest::mouseMove(view.viewport(), QPoint(200, 0));
                 TRY_COMPARE(hoverSpy.count(), 2);
                 QCOMPARE(qvariant_cast<QPieSlice*>(hoverSpy.at(1).at(0)), s1);
                 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(1).at(1)), false);
             }
             QTEST_MAIN(tst_qpieseries)
             #include "tst_qpieseries.moc"

tests/auto/qpieslice/tst_qpieslice.cpp +18 -5

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <tst_definitions.h>
             #include <qchartview.h>
             #include <qchart.h>
             #include <qpieslice.h>
             #include <qpieseries.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class tst_qpieslice : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void construction();
                 void changedSignals();
                 void customize();
                 void mouseClick();
                 void mouseHover();
             private:
             private:
             };
             void tst_qpieslice::initTestCase()
             {
             }
             void tst_qpieslice::cleanupTestCase()
             {
             }
             void tst_qpieslice::init()
             {
             }
             void tst_qpieslice::cleanup()
             {
             }
             void tst_qpieslice::construction()
             {
                 // no params
                 QPieSlice slice1;
                 QCOMPARE(slice1.value(), 0.0);
                 QVERIFY(slice1.label().isEmpty());
                 QVERIFY(!slice1.isLabelVisible());
                 QVERIFY(!slice1.isExploded());
                 QCOMPARE(slice1.pen(), QPen());
                 QCOMPARE(slice1.brush(), QBrush());
                 QCOMPARE(slice1.labelPen(), QPen());
                 QCOMPARE(slice1.labelFont(), QFont());
                 QCOMPARE(slice1.labelArmLengthFactor(), 0.15); // default value
                 QCOMPARE(slice1.explodeDistanceFactor(), 0.15); // default value
                 QCOMPARE(slice1.percentage(), 0.0);
                 QCOMPARE(slice1.startAngle(), 0.0);
-                QCOMPARE(slice1.endAngle(), 0.0);
+                QCOMPARE(slice1.angleSpan(), 0.0);
                 // value and label params
                 QPieSlice slice2("foobar", 1.0);
                 QCOMPARE(slice2.value(), 1.0);
                 QCOMPARE(slice2.label(), QString("foobar"));
                 QVERIFY(!slice2.isLabelVisible());
                 QVERIFY(!slice2.isExploded());
                 QCOMPARE(slice2.pen(), QPen());
                 QCOMPARE(slice2.brush(), QBrush());
                 QCOMPARE(slice2.labelPen(), QPen());
                 QCOMPARE(slice2.labelFont(), QFont());
                 QCOMPARE(slice2.labelArmLengthFactor(), 0.15); // default value
                 QCOMPARE(slice2.explodeDistanceFactor(), 0.15); // default value
                 QCOMPARE(slice2.percentage(), 0.0);
                 QCOMPARE(slice2.startAngle(), 0.0);
-                QCOMPARE(slice2.endAngle(), 0.0);
+                QCOMPARE(slice2.angleSpan(), 0.0);
             }
             void tst_qpieslice::changedSignals()
             {
                 QPieSlice slice;
                 QSignalSpy valueSpy(&slice, SIGNAL(valueChanged()));
                 QSignalSpy labelSpy(&slice, SIGNAL(labelChanged()));
-                QSignalSpy appearanceSpy(&slice, SIGNAL(appearanceChanged()));
+                QSignalSpy explodedSpy(&slice, SIGNAL(explodedChanged()));
-                // calculatedDataChanged signal is tested at tst_qpieseries::calculatedValues()
+                QSignalSpy penSpy(&slice, SIGNAL(penChanged()));
+                QSignalSpy brushSpy(&slice, SIGNAL(brushChanged()));
+                QSignalSpy labelPenSpy(&slice, SIGNAL(labelPenChanged()));
+                QSignalSpy labelFontSpy(&slice, SIGNAL(labelFontChanged()));
+                QSignalSpy labelArmLengthFactorSpy(&slice, SIGNAL(labelArmLengthFactorChanged()));
+                QSignalSpy explodeDistanceFactorSpy(&slice, SIGNAL(explodeDistanceFactorChanged()));
+                // percentageChanged(), startAngleChanged() and angleSpanChanged() signals tested at tst_qpieseries::calculatedValues()
                 // set everything twice to see we do not get unnecessary signals
                 slice.setValue(1);
                 slice.setValue(1);
                 slice.setLabel("foobar");
                 slice.setLabel("foobar");
                 slice.setLabelVisible();
                 slice.setLabelVisible();
                 slice.setExploded();
                 slice.setExploded();
                 slice.setPen(QPen(Qt::red));
                 slice.setPen(QPen(Qt::red));
                 slice.setBrush(QBrush(Qt::red));
                 slice.setBrush(QBrush(Qt::red));
                 slice.setLabelPen(QPen(Qt::green));
                 slice.setLabelPen(QPen(Qt::green));
                 slice.setLabelFont(QFont("Tahoma"));
                 slice.setLabelFont(QFont("Tahoma"));
                 slice.setLabelArmLengthFactor(0.1);
                 slice.setLabelArmLengthFactor(0.1);
                 slice.setExplodeDistanceFactor(0.1);
                 slice.setExplodeDistanceFactor(0.1);
                 TRY_COMPARE(valueSpy.count(), 1);
                 TRY_COMPARE(labelSpy.count(), 1);
-                TRY_COMPARE(appearanceSpy.count(), 8);
+                TRY_COMPARE(explodedSpy.count(), 1);
+                TRY_COMPARE(penSpy.count(), 1);
+                TRY_COMPARE(brushSpy.count(), 1);
+                TRY_COMPARE(labelPenSpy.count(), 1);
+                TRY_COMPARE(labelFontSpy.count(), 1);
+                TRY_COMPARE(labelArmLengthFactorSpy.count(), 1);
+                TRY_COMPARE(explodeDistanceFactorSpy.count(), 1);
             }
             void tst_qpieslice::customize()
             {
                 // create a pie series
                 QPieSeries *series = new QPieSeries();
                 QPieSlice *s1 = series->append("slice 1", 1);
                 QPieSlice *s2 = series->append("slice 2", 2);
                 series->append("slice 3", 3);
                 // customize a slice
                 QPen p1(Qt::red);
                 s1->setPen(p1);
                 QBrush b1(Qt::red);
                 s1->setBrush(b1);
                 s1->setLabelPen(p1);
                 QFont f1("Consolas");
                 s1->setLabelFont(f1);
                 // add series to the chart
                 QChartView view(new QChart());
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 //QTest::qWait(1000);
                 // check that customizations persist
                 QCOMPARE(s1->pen(), p1);
                 QCOMPARE(s1->brush(), b1);
                 QCOMPARE(s1->labelPen(), p1);
                 QCOMPARE(s1->labelFont(), f1);
                 // remove a slice
                 series->remove(s2);
                 QCOMPARE(s1->pen(), p1);
                 QCOMPARE(s1->brush(), b1);
                 QCOMPARE(s1->labelPen(), p1);
                 QCOMPARE(s1->labelFont(), f1);
                 // add a slice
                 series->append("slice 4", 4);
                 QCOMPARE(s1->pen(), p1);
                 QCOMPARE(s1->brush(), b1);
                 QCOMPARE(s1->labelPen(), p1);
                 QCOMPARE(s1->labelFont(), f1);
                 // insert a slice
                 series->insert(0, new QPieSlice("slice 5", 5));
                 QCOMPARE(s1->pen(), p1);
                 QCOMPARE(s1->brush(), b1);
                 QCOMPARE(s1->labelPen(), p1);
                 QCOMPARE(s1->labelFont(), f1);
                 // change theme
                 // theme will overwrite customizations
                 view.chart()->setTheme(QChart::ChartThemeHighContrast);
                 QVERIFY(s1->pen() != p1);
                 QVERIFY(s1->brush() != b1);
                 QVERIFY(s1->labelPen() != p1);
                 QVERIFY(s1->labelFont() != f1);
             }
             void tst_qpieslice::mouseClick()
             {
                 // create a pie series
                 QPieSeries *series = new QPieSeries();
                 series->setPieSize(1.0);
                 QPieSlice *s1 = series->append("slice 1", 1);
                 QPieSlice *s2 = series->append("slice 2", 2);
                 QPieSlice *s3 = series->append("slice 3", 3);
                 QSignalSpy clickSpy1(s1, SIGNAL(clicked()));
                 QSignalSpy clickSpy2(s2, SIGNAL(clicked()));
                 QSignalSpy clickSpy3(s3, SIGNAL(clicked()));
                 // add series to the chart
                 QChartView view(new QChart());
                 view.chart()->legend()->setVisible(false);
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // simulate clicks
                 // pie rectangle: QRectF(60,60 121x121)
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(139, 85)); // inside slice 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(146, 136)); // inside slice 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(91, 119)); // inside slice 3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(70, 70)); // inside pie rectangle but not inside a slice
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(170, 170)); // inside pie rectangle but not inside a slice
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(clickSpy1.count(), 1);
                 QCOMPARE(clickSpy2.count(), 1);
                 QCOMPARE(clickSpy3.count(), 1);
             }
             void tst_qpieslice::mouseHover()
             {
                 // create a pie series
                 QPieSeries *series = new QPieSeries();
                 series->setPieSize(1.0);
                 QPieSlice *s1 = series->append("slice 1", 1);
                 series->append("slice 2", 2);
                 series->append("slice 3", 3);
                 // add series to the chart
                 QChartView view(new QChart());
                 view.chart()->legend()->setVisible(false);
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // first move to right top corner
                 QTest::mouseMove(view.viewport(), QPoint(200, 0));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 // move inside slice rectangle but NOT the actual slice
                 // pie rectangle: QRectF(60,60 121x121)
                 QSignalSpy hoverSpy(s1, SIGNAL(hovered(bool)));
                 QTest::mouseMove(view.viewport(), QPoint(170, 70));
                 TRY_COMPARE(hoverSpy.count(), 0);
                 // move inside the slice
                 QTest::mouseMove(view.viewport(), QPoint(139, 85));
                 TRY_COMPARE(hoverSpy.count(), 1);
                 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(0).at(0)), true);
                 // move outside the slice
                 QTest::mouseMove(view.viewport(), QPoint(200, 0));
                 TRY_COMPARE(hoverSpy.count(), 2);
                 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(1).at(0)), false);
             }
             QTEST_MAIN(tst_qpieslice)
             #include "tst_qpieslice.moc"

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