HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r818:5bf1dbd3a89a

Refactoring QPieSlice private implementation. Removes the useless QPieSlicePrivate layer and uses PieSliceData directly.

Jani Honkonen -

r818:5bf1dbd3a89a

parent child

Context file:

r818:5bf1dbd3a89a

Collapse all files

src/charttheme.cpp +6 -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 "charttheme_p.h"
             #include "qchart.h"
             #include "qchartview.h"
             #include "qlegend.h"
             #include "qchartaxis.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 "qsplineseries.h"
             //items
             #include "axisitem_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 "chartthemedefault_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", 12)),
                 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_gridLinePen(QPen(QRgb(0x000000)))
             {
                 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 ChartThemeDefault();
                 }
             }
             void ChartTheme::decorate(QChart* chart,bool force)
             {
                 QBrush brush;
                 if(brush == chart->backgroundBrush() || force)
                     chart->setBackgroundBrush(m_chartBackgroundGradient);
                 chart->setTitleFont(m_masterFont);
                 chart->setTitleBrush(m_titleBrush);
             }
             void ChartTheme::decorate(QLegend* legend,bool force)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == legend->pen() || force){
                     legend->setPen(Qt::NoPen);
                 }
                 if (brush == legend->brush() || force) {
                     legend->setBrush(m_chartBackgroundGradient);
                 }
             }
             void ChartTheme::decorate(QAreaSeries* series, int index,bool force)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() || force){
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() || force) {
                    QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                    series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QLineSeries* series,int index,bool force)
             {
                 QPen pen;
                 if(pen == series->pen() || force ){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(QBarSeries* series, int index, bool force)
             {
                 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;
                     }
                     qDebug() << "pos:" << takeAtPos;
                     if (brush == sets.at(i)->brush() || 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)->setValuePen(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1));
                     else
                         sets.at(i)->setValuePen(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0));
                     if (pen == sets.at(i)->pen() || 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,bool force)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() || force) {
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() || force) {
                     QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                     series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QPieSeries* series, int index, bool force)
             {
                 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::DataPtr s = series->slices().at(i)->data_ptr();
+                    QPieSlice *s = series->slices().at(i);
-                    PieSliceData data = s->m_data;
+                    PieSliceData data = *s->data_ptr();
                     if (data.m_slicePen.isThemed() || force) {
                         data.m_slicePen = penColor;
                         data.m_slicePen.setThemed(true);
                     }
                     if (data.m_sliceBrush.isThemed() || force) {
                         data.m_sliceBrush = brushColor;
                         data.m_sliceBrush.setThemed(true);
                     }
                     if (data.m_labelPen.isThemed() || force) {
                         data.m_labelPen = QPen(m_titleBrush.color());
                         data.m_labelPen.setThemed(true);
                     }
                     if (data.m_labelFont.isThemed() || force) {
                         data.m_labelFont = m_labelFont;
                         data.m_labelFont.setThemed(true);
                     }
-                    if (s->m_data != data) {
+                    if (*s->data_ptr() != data) {
-                        s->m_data = data;
+                        *s->data_ptr() = data;
-                        emit s->changed();
+                        emit s->data_ptr()->emitChangedSignal(s);
                     }
                 }
             }
             void ChartTheme::decorate(QSplineSeries* series, int index, bool force)
             {
                 QPen pen;
                 if(pen == series->pen() || force){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(QChartAxis* axis,bool axisX, bool force)
             {
                 QPen pen;
                 QBrush brush;
                 QFont font;
                 if (axis->isAxisVisible()) {
                     if(brush == axis->labelsBrush() || force){
                         axis->setLabelsBrush(m_axisLabelBrush);
                     }
                     if(pen == axis->labelsPen() || force){
                         axis->setLabelsPen(Qt::NoPen); // NoPen for performance reasons
                     }
                    if (axis->shadesVisible() || force) {
                      if(brush == axis->shadesBrush() || force){
                          axis->setShadesBrush(m_backgroundShadesBrush);
                      }
                      if(pen == axis->shadesPen() || force){
                          axis->setShadesPen(m_backgroundShadesPen);
                      }
                      if(force && (m_backgroundShades == BackgroundShadesBoth
                                      || (m_backgroundShades == BackgroundShadesVertical && axisX)
                                      || (m_backgroundShades == BackgroundShadesHorizontal && !axisX))){
                          axis->setShadesVisible(true);
                      }
                    }
                     if(pen == axis->axisPen() || force){
                         axis->setAxisPen(m_axisLinePen);
                     }
                     if(pen == axis->gridLinePen() || force){
                         axis->setGridLinePen(m_gridLinePen);
                     }
                     if(font == axis->labelsFont() || force){
                         axis->setLabelsFont(m_labelFont);
                     }
                 }
             }
             void ChartTheme::generateSeriesGradients()
             {
                 // Generate gradients in HSV color space
                 foreach (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);
                 // another possibility:
                 // http://stackoverflow.com/questions/3306786/get-intermediate-color-from-a-gradient
                 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);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piechart.pri 0 -1

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/qpieseries.cpp \
                 $$PWD/piesliceitem.cpp \
                 $$PWD/piechartitem.cpp \
                 $$PWD/qpieslice.cpp
             PRIVATE_HEADERS += \
                 $$PWD/pieslicedata_p.h \
                 $$PWD/piechartitem_p.h \
                 $$PWD/piesliceitem_p.h \
-                $$PWD/qpiesliceprivate_p.h \
                 $$PWD/qpieseriesprivate_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qpieseries.h \
                 $$PWD/qpieslice.h

src/piechart/piechartitem.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "piechartitem_p.h"
             #include "piesliceitem_p.h"
             #include "qpieslice.h"
-            #include "qpiesliceprivate_p.h"
             #include "qpieseries.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "chartanimator_p.h"
             #include <QDebug>
             #include <QPainter>
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter* presenter)
                 :ChartItem(presenter),
                 m_series(series)
             {
                 Q_ASSERT(series);
                 connect(series, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleSlicesAdded(QList<QPieSlice*>)));
                 connect(series, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleSlicesRemoved(QList<QPieSlice*>)));
                 connect(series, SIGNAL(piePositionChanged()), this, SLOT(handlePieLayoutChanged()));
                 connect(series, SIGNAL(pieSizeChanged()), this, SLOT(handlePieLayoutChanged()));
                 QTimer::singleShot(0, this, SLOT(initialize()));
                 // Note: the following does not affect as long as the item does not have anything to paint
                 setZValue(ChartPresenter::PieSeriesZValue);
             }
             PieChartItem::~PieChartItem()
             {
                 // slices deleted automatically through QGraphicsItem
             }
             void PieChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
             {
                 Q_UNUSED(painter)
                 // TODO: paint shadows for all components
                 // - get paths from items & merge & offset and draw with shadow color?
                 //painter->setBrush(QBrush(Qt::red));
                 //painter->drawRect(m_debugRect);
             }
             void PieChartItem::initialize()
             {
                 handleSlicesAdded(m_series->slices());
             }
             void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices)
             {
                 bool isEmpty = m_slices.isEmpty();
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series), false);
                 foreach (QPieSlice *s, slices) {
                     PieSliceItem* item = new PieSliceItem(this);
                     m_slices.insert(s, item);
                     connect(s, SIGNAL(changed()), this, SLOT(handleSliceChanged()));
                     connect(item, SIGNAL(clicked(Qt::MouseButtons)), s, SIGNAL(clicked(Qt::MouseButtons)));
                     connect(item, SIGNAL(hoverEnter()), s, SIGNAL(hoverEnter()));
                     connect(item, SIGNAL(hoverLeave()), s, SIGNAL(hoverLeave()));
                     PieSliceData data = sliceData(s);
                     if (animator())
                         animator()->addAnimation(this, s, data, isEmpty);
                     else
                         setLayout(s, data);
                 }
             }
             void PieChartItem::handleSlicesRemoved(QList<QPieSlice*> slices)
             {
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series), false);
                 foreach (QPieSlice *s, slices) {
                     if (animator())
                         animator()->removeAnimation(this, s);
                     else
                         destroySlice(s);
                 }
             }
             void PieChartItem::handlePieLayoutChanged()
             {
                 PieLayout layout = calculateLayout();
                 applyLayout(layout);
                 update();
             }
             void PieChartItem::handleSliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 PieSliceData data = sliceData(slice);
                 updateLayout(slice, data);
                 update();
             }
             void PieChartItem::handleDomainChanged(qreal, qreal, qreal, qreal)
             {
                 // TODO
             }
             void PieChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 handlePieLayoutChanged();
             }
             void PieChartItem::calculatePieLayout()
             {
                 // find pie center coordinates
                 m_pieCenter.setX(m_rect.left() + (m_rect.width() * m_series->pieHorizontalPosition()));
                 m_pieCenter.setY(m_rect.top() + (m_rect.height() * m_series->pieVerticalPosition()));
                 // find maximum radius for pie
                 m_pieRadius = m_rect.height() / 2;
                 if (m_rect.width() < m_rect.height())
                     m_pieRadius = m_rect.width() / 2;
                 // apply size factor
                 m_pieRadius *= m_series->pieSize();
             }
             PieSliceData PieChartItem::sliceData(QPieSlice *slice)
             {
-                PieSliceData sliceData = slice->data_ptr()->m_data;
+            	// TODO: This function is kid of useless now. Refactor.
+                PieSliceData sliceData = *slice->data_ptr();
                 sliceData.m_center = PieSliceItem::sliceCenter(m_pieCenter, m_pieRadius, slice);
                 sliceData.m_radius = m_pieRadius;
                 return sliceData;
             }
             PieLayout PieChartItem::calculateLayout()
             {
                 calculatePieLayout();
                 PieLayout layout;
                 foreach (QPieSlice* s, m_series->slices()) {
                     if (m_slices.contains(s)) // calculate layout only for those slices that are already visible
                         layout.insert(s, sliceData(s));
                 }
                 return layout;
             }
             void PieChartItem::applyLayout(const PieLayout &layout)
             {
                 if (animator())
                     animator()->updateLayout(this, layout);
                 else
                     setLayout(layout);
             }
             void PieChartItem::updateLayout(QPieSlice *slice, const PieSliceData &sliceData)
             {
                 if (animator())
                     animator()->updateLayout(this, slice, sliceData);
                 else
                     setLayout(slice, sliceData);
             }
             void PieChartItem::setLayout(const PieLayout &layout)
             {
                 foreach (QPieSlice *slice, layout.keys()) {
                     PieSliceItem *item = m_slices.value(slice);
                     Q_ASSERT(item);
                     item->setSliceData(layout.value(slice));
                     item->updateGeometry();
                     item->update();
                 }
             }
             void PieChartItem::setLayout(QPieSlice *slice, const PieSliceData &sliceData)
             {
                 // find slice
                 PieSliceItem *item = m_slices.value(slice);
                 Q_ASSERT(item);
                 item->setSliceData(sliceData);
                 item->updateGeometry();
                 item->update();
             }
             void PieChartItem::destroySlice(QPieSlice *slice)
             {
                 delete m_slices.take(slice);
             }
             #include "moc_piechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslicedata_p.h +7 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef PIESLICEDATA_P_H
             #define PIESLICEDATA_P_H
-            #include <qchartglobal.h>
+            #include "qchartglobal.h"
+            #include "qpieslice.h"
             #include <QPen>
             #include <QBrush>
             #include <QDebug>
             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;
                 }
+                void emitChangedSignal(QPieSlice *s)
+                {
+                    emit s->changed();
+                }
                 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_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef PIESLICEITEM_H
             #define PIESLICEITEM_H
             #include "qchartglobal.h"
             #include "charttheme_p.h"
             #include "qpieseries.h"
-            #include "qpiesliceprivate_p.h"
+            #include "pieslicedata_p.h"
             #include <QGraphicsItem>
             #include <QRectF>
             #include <QColor>
             #include <QPen>
             #define PIESLICE_LABEL_GAP 5
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieChartItem;
             class PieSliceLabel;
             class QPieSlice;
             class PieSliceItem : public QGraphicsObject
             {
                 Q_OBJECT
             public:
                 PieSliceItem(QGraphicsItem* parent = 0);
                 ~PieSliceItem();
             public: // from QGraphicsItem
                 QRectF boundingRect() const;
                 QPainterPath shape() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
                 void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
             Q_SIGNALS:
                 void clicked(Qt::MouseButtons buttons);
                 void hoverEnter();
                 void hoverLeave();
             public:
                 void setSliceData(PieSliceData sliceData);
                 void updateGeometry();
                 static QPointF sliceCenter(QPointF point, qreal radius, QPieSlice *slice);
                 static QPainterPath slicePath(QPointF center, qreal radius, qreal startAngle, qreal angleSpan, qreal* centerAngle, QPointF* armStart);
                 static QPainterPath labelArmPath(QPointF start, qreal angle, qreal length, qreal textWidth, QPointF* textStart);
                 static QRectF labelTextRect(QFont font, QString text);
             private:
                 PieSliceData m_data;
                 QRectF m_boundingRect;
                 QPainterPath m_slicePath;
                 QPainterPath m_labelArmPath;
                 QRectF m_labelTextRect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESLICEITEM_H

src/piechart/qpieseries.cpp +6 -5

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

src/piechart/qpieseries.h 0 -4

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

src/piechart/qpieslice.cpp +43 -75

             /****************************************************************************
             **
             ** 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 "qpiesliceprivate_p.h"
+            #include "pieslicedata_p.h"
-            #include "qpieseries.h"
-            #include "qpieseriesprivate_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSlice
                 \brief Defines a slice in pie series.
                 Holds all the data of a single slice in a QPieSeries and provides the means
                 to modify slice data and customize the visual appearance of the slice.
                 It also provides the means to customize user interaction with the slice by
                 providing signals for clicking and hover events.
             */
             /*!
                 \property QPieSlice::label
                 Label of the slice.
             */
             /*!
                 \property QPieSlice::value
                 Value of the slice.
             */
             /*!
                 Constructs an empty slice with a \a parent.
                 Note that QPieSeries takes ownership of the slice when it is set/added.
                 \sa QPieSeries::replace(), QPieSeries::append()
             */
             QPieSlice::QPieSlice(QObject *parent)
                 :QObject(parent),
-                d_ptr(new QPieSlicePrivate(this))
+                d(new PieSliceData())
             {
             }
             /*!
                 Constructs an empty slice with given \a value, \a label and a \a parent.
                 Note that QPieSeries takes ownership of the slice when it is set/added.
                 \sa QPieSeries::replace(), QPieSeries::append()
             */
             QPieSlice::QPieSlice(qreal value, QString label, QObject *parent)
                 :QObject(parent),
-                d_ptr(new QPieSlicePrivate(this))
+                d(new PieSliceData())
             {
-                Q_D(QPieSlice);
+                d->m_value = value;
-                d->m_data.m_value = value;
+                d->m_labelText = label;
-                d->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_ptr;
+                delete d;
             }
             /*!
                 Gets the value of the slice.
                 Note that all values in the series
                 \sa setValue()
             */
             qreal QPieSlice::value() const
             {
-                Q_D(const QPieSlice);
+                return d->m_value;
-                return d->m_data.m_value;
             }
             /*!
                 Gets the label of the slice.
                 \sa setLabel()
             */
             QString QPieSlice::label() const
             {
-                Q_D(const QPieSlice);
+                return d->m_labelText;
-                return d->m_data.m_labelText;
             }
             /*!
                 Returns true if label is set as visible.
                 \sa setLabelVisible()
             */
             bool QPieSlice::isLabelVisible() const
             {
-                Q_D(const QPieSlice);
+                return d->m_isLabelVisible;
-                return d->m_data.m_isLabelVisible;
             }
             /*!
                 Returns true if slice is exloded from the pie.
                 \sa setExploded(), setExplodeDistanceFactor()
             */
             bool QPieSlice::isExploded() const
             {
-                Q_D(const QPieSlice);
+                return d->m_isExploded;
-                return d->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()
             */
             qreal QPieSlice::explodeDistanceFactor() const
             {
-                Q_D(const QPieSlice);
+                return d->m_explodeDistanceFactor;
-                return d->m_data.m_explodeDistanceFactor;
             }
             /*!
                 Returns the percentage of this slice compared to all slices in the same series.
                 The returned value ranges from 0 to 1.0.
                 Updated internally after the slice is added to the series.
             */
             qreal QPieSlice::percentage() const
             {
-                Q_D(const QPieSlice);
+                return d->m_percentage;
-                return d->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
             {
-                Q_D(const QPieSlice);
+                return d->m_startAngle;
-                return d->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
             {
-                Q_D(const QPieSlice);
+                return d->m_startAngle + d->m_angleSpan;
-                return d->m_data.m_startAngle + d->m_data.m_angleSpan;
             }
             /*!
                 Returns the pen used to draw this slice.
                 \sa setPen()
             */
             QPen QPieSlice::pen() const
             {
-                Q_D(const QPieSlice);
+                return d->m_slicePen;
-                return d->m_data.m_slicePen;
             }
             /*!
                 Returns the brush used to draw this slice.
                 \sa setBrush()
             */
             QBrush QPieSlice::brush() const
             {
-                Q_D(const QPieSlice);
+                return d->m_sliceBrush;
-                return d->m_data.m_sliceBrush;
             }
             /*!
                 Returns the pen used to draw the label in this slice.
                 \sa setLabelPen()
             */
             QPen QPieSlice::labelPen() const
             {
-                Q_D(const QPieSlice);
+                return d->m_labelPen;
-                return d->m_data.m_labelPen;
             }
             /*!
                 Returns the font used to draw label in this slice.
                 \sa setLabelFont()
             */
             QFont QPieSlice::labelFont() const
             {
-                Q_D(const QPieSlice);
+                return d->m_labelFont;
-                return d->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
             {
-                Q_D(const QPieSlice);
+                return d->m_labelArmLengthFactor;
-                return d->m_data.m_labelArmLengthFactor;
             }
             /*!
                 \fn void QPieSlice::clicked(Qt::MouseButtons buttons)
                 This signal is emitted when user has clicked the slice.
                 \sa QPieSeries::clicked()
             */
             /*!
                 \fn void QPieSlice::hoverEnter()
                 This signal is emitted when user has hovered over the slice.
                 \sa QPieSeries::hoverEnter()
             */
             /*!
                 \fn void QPieSlice::hoverLeave()
                 This signal is emitted when user has hovered away from the slice.
                 \sa QPieSeries::hoverLeave()
             */
             /*!
                 \fn void QPieSlice::changed()
                 This signal emitted when something has changed in the slice.
                 \sa QPieSeries::changed()
             */
             /*!
                 Sets the \a value of this slice.
                 \sa value()
             */
             void QPieSlice::setValue(qreal value)
             {
-                Q_D(QPieSlice);
+                if (!qFuzzyIsNull(d->m_value - value)) {
-                if (!qFuzzyIsNull(d->m_data.m_value - value)) {
+                    d->m_value = value;
-                    d->m_data.m_value = value;
-                    QPieSeries *series = qobject_cast<QPieSeries*>(parent());
-                    if (series)
-                        series->data_ptr()->updateDerivativeData(); // will emit changed()
-                    else
                     emit changed();
                 }
             }
             /*!
                 Sets the \a label of the slice.
                 \sa label()
             */
             void QPieSlice::setLabel(QString label)
             {
-                Q_D(QPieSlice);
+                if (d->m_labelText != label) {
-                if (d->m_data.m_labelText != label) {
+                    d->m_labelText = label;
-                    d->m_data.m_labelText = label;
                     emit changed();
                 }
             }
             /*!
                 Sets the label \a visible in this slice.
                 \sa isLabelVisible(), QPieSeries::setLabelsVisible()
             */
             void QPieSlice::setLabelVisible(bool visible)
             {
-                Q_D(QPieSlice);
+                if (d->m_isLabelVisible != visible) {
-                if (d->m_data.m_isLabelVisible != visible) {
+                    d->m_isLabelVisible = visible;
-                    d->m_data.m_isLabelVisible = visible;
                     emit changed();
                 }
             }
             /*!
                 Sets this slice \a exploded.
                 \sa isExploded(), explodeDistanceFactor()
             */
             void QPieSlice::setExploded(bool exploded)
             {
-                Q_D(QPieSlice);
+                if (d->m_isExploded != exploded) {
-                if (d->m_data.m_isExploded != exploded) {
+                    d->m_isExploded = exploded;
-                    d->m_data.m_isExploded = exploded;
                     emit changed();
                 }
             }
             /*!
                 Sets the explode distance \a factor.
                 The factor is relative to pie radius. For example:
 .0 means the distance is the same as the radius.
 .5 means the distance is half of the radius.
                 Default value is 0.15
                 \sa explodeDistanceFactor()
             */
             void QPieSlice::setExplodeDistanceFactor(qreal factor)
             {
-                Q_D(QPieSlice);
+                if (!qFuzzyIsNull(d->m_explodeDistanceFactor - factor)) {
-                if (!qFuzzyIsNull(d->m_data.m_explodeDistanceFactor - factor)) {
+                    d->m_explodeDistanceFactor = factor;
-                    d->m_data.m_explodeDistanceFactor = factor;
                     emit changed();
                 }
             }
             /*!
                 Sets the \a pen used to draw this slice.
                 Note that applying a theme will override this.
                 \sa pen()
             */
             void QPieSlice::setPen(const QPen &pen)
             {
-                Q_D(QPieSlice);
+                if (d->m_slicePen != pen) {
-                if (d->m_data.m_slicePen != pen) {
+                    d->m_slicePen = pen;
-                    d->m_data.m_slicePen = pen;
+                    d->m_slicePen.setThemed(false);
-                    d->m_data.m_slicePen.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the \a brush used to draw this slice.
                 Note that applying a theme will override this.
                 \sa brush()
             */
             void QPieSlice::setBrush(const QBrush &brush)
             {
-                Q_D(QPieSlice);
+                if (d->m_sliceBrush != brush) {
-                if (d->m_data.m_sliceBrush != brush) {
+                    d->m_sliceBrush = brush;
-                    d->m_data.m_sliceBrush = brush;
+                    d->m_sliceBrush.setThemed(false);
-                    d->m_data.m_sliceBrush.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the \a pen used to draw the label in this slice.
                 Note that applying a theme will override this.
                 \sa labelPen()
             */
             void QPieSlice::setLabelPen(const QPen &pen)
             {
-                Q_D(QPieSlice);
+                if (d->m_labelPen != pen) {
-                if (d->m_data.m_labelPen != pen) {
+                    d->m_labelPen = pen;
-                    d->m_data.m_labelPen = pen;
+                    d->m_labelPen.setThemed(false);
-                    d->m_data.m_labelPen.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the \a font used to draw the label in this slice.
                 Note that applying a theme will override this.
                 \sa labelFont()
             */
             void QPieSlice::setLabelFont(const QFont &font)
             {
-                Q_D(QPieSlice);
+                if (d->m_labelFont != font) {
-                if (d->m_data.m_labelFont != font) {
+                    d->m_labelFont = font;
-                    d->m_data.m_labelFont = font;
+                    d->m_labelFont.setThemed(false);
-                    d->m_data.m_labelFont.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the label arm length \a factor.
                 The factor is relative to pie radius. For example:
 .0 means the length is the same as the radius.
 .5 means the length is half of the radius.
                 Default value is 0.15
                 \sa labelArmLengthFactor()
             */
             void QPieSlice::setLabelArmLengthFactor(qreal factor)
             {
-                Q_D(QPieSlice);
+                if (!qFuzzyIsNull(d->m_labelArmLengthFactor - factor)) {
-                if (!qFuzzyIsNull(d->m_data.m_labelArmLengthFactor - factor)) {
+                    d->m_labelArmLengthFactor = factor;
-                    d->m_data.m_labelArmLengthFactor = factor;
                     emit changed();
                 }
             }
             #include "moc_qpieslice.cpp"
-            #include "moc_qpiesliceprivate_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieslice.h +5 -5

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

src/piechart/qpiesliceprivate_p.h removed 0 -56

NO CONTENT: file was removed

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