HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r822:924499b21823

Polish QPieSlice API by removing the DataPtr stuff

Jani Honkonen -

r822:924499b21823

parent child

Context file:

r822:924499b21823

Collapse all files

src/charttheme.cpp +4 -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$
             **
             ****************************************************************************/
             #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)->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() || 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 *s = series->slices().at(i);
-                    PieSliceData data = *s->data_ptr();
+                    PieSliceData data = PieSliceData::data(s);
                     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->data_ptr() != data) {
+                    if (PieSliceData::data(s) != data) {
-                        *s->data_ptr() = data;
+                        PieSliceData::data(s) = data;
-                        emit s->data_ptr()->emitChangedSignal(s);
+                        emit PieSliceData::data(s).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/piechartitem.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 "piechartitem_p.h"
             #include "piesliceitem_p.h"
             #include "qpieslice.h"
             #include "qpieseries.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "chartanimator_p.h"
             #include <QDebug>
             #include <QPainter>
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter* presenter)
                 :ChartItem(presenter),
                 m_series(series)
             {
                 Q_ASSERT(series);
                 connect(series, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleSlicesAdded(QList<QPieSlice*>)));
                 connect(series, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleSlicesRemoved(QList<QPieSlice*>)));
                 connect(series, SIGNAL(piePositionChanged()), this, SLOT(handlePieLayoutChanged()));
                 connect(series, SIGNAL(pieSizeChanged()), this, SLOT(handlePieLayoutChanged()));
                 QTimer::singleShot(0, this, SLOT(initialize()));
                 // Note: the following does not affect as long as the item does not have anything to paint
                 setZValue(ChartPresenter::PieSeriesZValue);
             }
             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)
             {
             	// TODO: This function is kid of useless now. Refactor.
-                PieSliceData sliceData = *slice->data_ptr();
+                PieSliceData sliceData = PieSliceData::data(slice);
                 sliceData.m_center = PieSliceItem::sliceCenter(m_pieCenter, m_pieRadius, slice);
                 sliceData.m_radius = m_pieRadius;
                 return sliceData;
             }
             PieLayout PieChartItem::calculateLayout()
             {
                 calculatePieLayout();
                 PieLayout layout;
                 foreach (QPieSlice* s, m_series->slices()) {
                     if (m_slices.contains(s)) // calculate layout only for those slices that are already visible
                         layout.insert(s, sliceData(s));
                 }
                 return layout;
             }
             void PieChartItem::applyLayout(const PieLayout &layout)
             {
                 if (animator())
                     animator()->updateLayout(this, layout);
                 else
                     setLayout(layout);
             }
             void PieChartItem::updateLayout(QPieSlice *slice, const PieSliceData &sliceData)
             {
                 if (animator())
                     animator()->updateLayout(this, slice, sliceData);
                 else
                     setLayout(slice, sliceData);
             }
             void PieChartItem::setLayout(const PieLayout &layout)
             {
                 foreach (QPieSlice *slice, layout.keys()) {
                     PieSliceItem *item = m_slices.value(slice);
                     Q_ASSERT(item);
                     item->setSliceData(layout.value(slice));
                     item->updateGeometry();
                     item->update();
                 }
             }
             void PieChartItem::setLayout(QPieSlice *slice, const PieSliceData &sliceData)
             {
                 // find slice
                 PieSliceItem *item = m_slices.value(slice);
                 Q_ASSERT(item);
                 item->setSliceData(sliceData);
                 item->updateGeometry();
                 item->update();
             }
             void PieChartItem::destroySlice(QPieSlice *slice)
             {
                 delete m_slices.take(slice);
             }
             #include "moc_piechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslicedata_p.h +6 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef PIESLICEDATA_P_H
             #define PIESLICEDATA_P_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();
                 }
+                static PieSliceData &data(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/qpieseries.cpp +4 -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$
             **
             ****************************************************************************/
             #include "qpieseries.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();
+                    PieSliceData data = PieSliceData::data(s);
                     data.m_percentage = s->value() / m_total;
                     data.m_angleSpan = pieSpan * data.m_percentage;
                     data.m_startAngle = sliceAngle;
                     sliceAngle += data.m_angleSpan;
-                    if (*s->data_ptr() != data) {
+                    if (PieSliceData::data(s) != data) {
-                        *s->data_ptr() = data;
+                        PieSliceData::data(s) = data;
                         changed << s;
                     }
                 }
                 // emit signals
                 foreach (QPieSlice* s, changed)
-                    s->data_ptr()->emitChangedSignal(s);
+                    PieSliceData::data(s).emitChangedSignal(s);
             }
             void QPieSeriesPrivate::sliceChanged()
             {
                 Q_ASSERT(m_slices.contains(qobject_cast<QPieSlice *>(sender())));
                 updateDerivativeData();
             }
             void QPieSeriesPrivate::sliceClicked(Qt::MouseButtons buttons)
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->clicked(slice, buttons);
             }
             void QPieSeriesPrivate::sliceHoverEnter()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->hoverEnter(slice);
             }
             void QPieSeriesPrivate::sliceHoverLeave()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->hoverLeave(slice);
             }
             void QPieSeriesPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(bottomRight)
                 Q_Q(QPieSeries);
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     //        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(Qt::MouseButtons)), d, SLOT(sliceClicked(Qt::MouseButtons)));
                 connect(slice, SIGNAL(hoverEnter()), d, SLOT(sliceHoverEnter()));
                 connect(slice, SIGNAL(hoverLeave()), d, SLOT(sliceHoverLeave()));
                 emit added(QList<QPieSlice*>() << slice);
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference this pointer after this call.
             */
             void QPieSeries::remove(QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 if (!d->m_slices.removeOne(slice)) {
                     Q_ASSERT(0); // TODO: how should this be reported?
                     return;
                 }
                 d->updateDerivativeData();
                 emit removed(QList<QPieSlice*>() << slice);
                 delete slice;
                 slice = 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/qpieslice.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 QPIESLICE_H
             #define QPIESLICE_H
             #include <qchartglobal.h>
             #include <QObject>
             #include <QPen>
             #include <QBrush>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             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:
                 friend class PieSliceData;
                 PieSliceData * const d;
                 Q_DISABLE_COPY(QPieSlice)
-            public:
-                typedef PieSliceData * const DataPtr;
-                inline DataPtr &data_ptr() { return d; }
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIESLICE_H

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages