HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r353:e5ed5bdfafc1

Add _p to pie internal headers

Jani Honkonen -

r353:e5ed5bdfafc1

parent child

Context file:

r353:e5ed5bdfafc1

Collapse all files

src/chartpresenter.cpp +1 -1

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             //series
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             //items
             #include "axisitem_p.h"
             #include "axisanimationitem_p.h"
             #include "barpresenter.h"
             #include "stackedbarpresenter.h"
             #include "linechartitem_p.h"
             #include "percentbarpresenter.h"
             #include "linechartanimationitem_p.h"
-            #include "piepresenter.h"
+            #include "piepresenter_p.h"
             #include "scatterpresenter_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_dataset(dataset),
             m_chartTheme(0),
             m_marginSize(0),
             m_rect(QRectF(QPoint(0,0),m_chart->size())),
             m_options(0)
             {
             	createConnections();
                 setChartTheme(QChart::ChartThemeDefault);
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QChartSeries*)),this,SLOT(handleSeriesAdded(QChartSeries*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QChartSeries*)),this,SLOT(handleSeriesRemoved(QChartSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*)),this,SLOT(handleAxisAdded(QChartAxis*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
                 QObject::connect(m_dataset,SIGNAL(seriesDomainChanged(QChartSeries*,const Domain&)),this,SLOT(handleSeriesDomainChanged(QChartSeries*,const Domain&)));
                 QObject::connect(m_dataset,SIGNAL(axisLabelsChanged(QChartAxis*,const QStringList&)),this,SLOT(handleAxisLabelsChanged(QChartAxis*,const QStringList&)));
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 m_rect = QRectF(QPoint(0,0),m_chart->size());
                 m_rect.adjust(m_marginSize,m_marginSize, -m_marginSize, -m_marginSize);
                 Q_ASSERT(m_rect.isValid());
                 emit geometryChanged(m_rect);
             }
             int ChartPresenter::margin() const
             {
                 return m_marginSize;
             }
             void ChartPresenter::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
             void ChartPresenter::handleAxisAdded(QChartAxis* axis)
             {
                 AxisItem* item ;
                 if(!m_options.testFlag(QChart::GridAxisAnimations))
                 {
                     item = new AxisItem(axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 }else{
                     item = new AxisAnimationItem(axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                 QObject::connect(axis,SIGNAL(update(QChartAxis*)),item,SLOT(handleAxisUpdate(QChartAxis*)));
                 item->handleAxisUpdate(axis);
                 item->handleGeometryChanged(m_rect);
                 m_chartTheme->decorate(axis,item);
                 m_axisItems.insert(axis,item);
             }
             void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
             {
                 AxisItem* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QChartSeries* series)
             {
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                         LineChartItem* item;
                         if(m_options.testFlag(QChart::SeriesAnimations)){
                             item = new LineChartAnimationItem(this,lineSeries,m_chart);
                         }else{
                             item = new LineChartItem(this,lineSeries,m_chart);
                         }
                         m_chartTheme->decorate(item,lineSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(lineSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                         BarPresenter* item = new BarPresenter(barSeries,m_chart);
                         m_chartTheme->decorate(item,barSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(barSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         // m_axisXItem->setVisible(false);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                         StackedBarPresenter* item = new StackedBarPresenter(stackedBarSeries,m_chart);
                         m_chartTheme->decorate(item,stackedBarSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(stackedBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                         PercentBarPresenter* item = new PercentBarPresenter(percentBarSeries,m_chart);
                         m_chartTheme->decorate(item,percentBarSeries ,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(percentBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     case QChartSeries::SeriesTypeScatter: {
                         QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                         ScatterPresenter *scatterPresenter = new ScatterPresenter(scatterSeries, m_chart);
                         QObject::connect(scatterPresenter, SIGNAL(clicked()), scatterSeries, SIGNAL(clicked()));
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)),
                                          scatterPresenter, SLOT(handleGeometryChanged(const QRectF&)));
                         m_chartTheme->decorate(scatterPresenter, scatterSeries, m_chartItems.count());
                         m_chartItems.insert(scatterSeries, scatterPresenter);
                         break;
                     }
                     case QChartSeries::SeriesTypePie: {
                         QPieSeries *s = qobject_cast<QPieSeries *>(series);
                         PiePresenter* pie = new PiePresenter(m_chart, s);
                         m_chartTheme->decorate(pie, s, m_chartItems.count());
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pie, SLOT(handleGeometryChanged(const QRectF&)));
                         // Hide all from background when there is only piechart
                         // TODO: refactor this ugly code... should be one setting for this
                         if (m_chartItems.count() == 0) {
                             m_chart->axisX()->setAxisVisible(false);
                             m_chart->axisY()->setAxisVisible(false);
                             m_chart->axisX()->setGridVisible(false);
                             m_chart->axisY()->setGridVisible(false);
                             m_chart->axisX()->setLabelsVisible(false);
                             m_chart->axisY()->setLabelsVisible(false);
                             m_chart->axisX()->setShadesVisible(false);
                             m_chart->axisY()->setShadesVisible(false);
                             m_chart->setChartBackgroundBrush(Qt::transparent);
                         }
                         m_chartItems.insert(series, pie);
                         break;
                     }
                     default: {
                         qDebug()<< "Series type" << series->type() << "not implemented.";
                         break;
                     }
                 }
                 if(m_rect.isValid()) emit geometryChanged(m_rect);
             }
             void ChartPresenter::handleSeriesRemoved(QChartSeries* series)
             {
             	ChartItem* item = m_chartItems.take(series);
             	delete item;
             }
             void ChartPresenter::handleSeriesChanged(QChartSeries* series)
             {
                 //TODO:
             }
             void ChartPresenter::handleSeriesDomainChanged(QChartSeries* series, const Domain& domain)
             {
                 m_chartItems.value(series)->handleDomainChanged(domain);
             }
             void ChartPresenter::handleAxisLabelsChanged(QChartAxis* axis,const QStringList& labels)
             {
                 m_axisItems.value(axis)->handleLabelsChanged(axis,labels);
             }
             void ChartPresenter::setChartTheme(QChart::ChartTheme theme)
             {
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart);
                 QMapIterator<QChartSeries*,ChartItem*> i(m_chartItems);
                 int index=0;
                 while (i.hasNext()) {
                     i.next();
                     m_chartTheme->decorate(i.value(),i.key(),index);
                     index++;
                 }
                 QMapIterator<QChartAxis*,AxisItem*> j(m_axisItems);
                 while (j.hasNext()) {
                         j.next();
                         m_chartTheme->decorate(j.key(),j.value());
                 }
             }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     //recreate elements
                     QList<QChartAxis*> axisList = m_axisItems.uniqueKeys();
                     QList<QChartSeries*> seriesList = m_chartItems.uniqueKeys();
                     foreach(QChartAxis* axis, axisList) {
                         handleAxisRemoved(axis);
                         handleAxisAdded(axis);
                     }
                     foreach(QChartSeries* series, seriesList) {
                         handleSeriesRemoved(series);
                         handleSeriesAdded(series);
                     }
                     //now reintialize view data
                     //TODO: make it more nice
                     m_dataset->setDomain(m_dataset->domainIndex());
                 }
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme.cpp +1 -1

             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             #include <QTime>
             //series
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             //items
             #include "axisitem_p.h"
             #include "barpresenter.h"
             #include "stackedbarpresenter.h"
             #include "linechartitem_p.h"
             #include "percentbarpresenter.h"
             #include "scatterpresenter_p.h"
-            #include "piepresenter.h"
+            #include "piepresenter_p.h"
             //themes
             #include "chartthemevanilla_p.h"
             #include "chartthemeicy_p.h"
             #include "chartthemegrayscale_p.h"
             #include "chartthemescientific_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /* TODO
                 case QChart::ChartThemeUnnamed1:
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff3fa9f5)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff7AC943)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF931E)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF1D25)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF7BAC)), 2));
                     m_gradientStartColor = QColor(QRgb(0xfff3dc9e));
                     m_gradientEndColor = QColor(QRgb(0xffafafaf));
             */
             ChartTheme::ChartTheme(QChart::ChartTheme id)
             {
                 m_id = id;
                 m_seriesColor.append(QRgb(0xff000000));
                 m_seriesColor.append(QRgb(0xff707070));
                 m_gradientStartColor = QColor(QRgb(0xffffffff));
                 m_gradientEndColor = QColor(QRgb(0xffafafaf));
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeDefault:
                         return new ChartThemeIcy();
                     case QChart::ChartThemeVanilla:
                         return new ChartThemeVanilla();
                     case QChart::ChartThemeIcy:
                         return new ChartThemeIcy();
                     case QChart::ChartThemeGrayscale:
                         return new ChartThemeGrayscale();
                     case QChart::ChartThemeScientific:
                         return new ChartThemeScientific();
                 }
             }
             void ChartTheme::decorate(QChart* chart)
             {
                 QLinearGradient backgroundGradient;
                 backgroundGradient.setColorAt(0.0, m_gradientStartColor);
                 backgroundGradient.setColorAt(1.0, m_gradientEndColor);
                 backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                 chart->setChartBackgroundBrush(backgroundGradient);
             }
             //TODO helper to by removed later
             void ChartTheme::decorate(ChartItem* item, QChartSeries* series,int count)
             {
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QLineSeries* s = static_cast<QLineSeries*>(series);
                         LineChartItem* i = static_cast<LineChartItem*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         QBarSeries* b = static_cast<QBarSeries*>(series);
                         BarPresenter* i = static_cast<BarPresenter*>(item);
                         decorate(i,b,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         QStackedBarSeries* s = static_cast<QStackedBarSeries*>(series);
                         StackedBarPresenter* i = static_cast<StackedBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         QPercentBarSeries* s = static_cast<QPercentBarSeries*>(series);
                         PercentBarPresenter* i = static_cast<PercentBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeScatter: {
                         QScatterSeries* s = qobject_cast<QScatterSeries*>(series);
                         Q_ASSERT(s);
                         ScatterPresenter* i = static_cast<ScatterPresenter*>(item);
                         Q_ASSERT(i);
                         decorate(i, s, count);
                         break;
                     }
                     case QChartSeries::SeriesTypePie: {
                         QPieSeries* s = static_cast<QPieSeries*>(series);
                         PiePresenter* i = static_cast<PiePresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     default:
                     qDebug()<<"Wrong item to be decorated by theme";
                     break;
                 }
             }
             void ChartTheme::decorate(LineChartItem* item, QLineSeries* series,int count)
             {
                 QPen pen;
                 if(pen != series->pen()){
                     item->setPen(series->pen());
                     return;
                 }
                 pen.setColor(m_seriesColor.at(count%m_seriesColor.size()));
                 pen.setWidthF(2);
                 item->setPen(pen);
             }
             void ChartTheme::decorate(BarPresenter* item, QBarSeries* series,int count)
             {
                 for (int i=0; i<series->countSets(); i++) {
                     series->nextSet(0==i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(StackedBarPresenter* item, QStackedBarSeries* series,int count)
             {
                 for (int i=0; i<series->countSets(); i++) {
                     series->nextSet(0==i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(PercentBarPresenter* item, QPercentBarSeries* series,int count)
             {
                 for (int i=0; i<series->countSets(); i++) {
                     series->nextSet(0==i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(ScatterPresenter* presenter, QScatterSeries* series, int count)
             {
                 Q_ASSERT(presenter);
                 Q_ASSERT(series);
                 QColor color = m_seriesColor.at(count % m_seriesColor.size());
                 // TODO: define alpha in the theme? or in the series?
                 //color.setAlpha(120);
                 QBrush brush(color, Qt::SolidPattern);
                 presenter->m_markerBrush = brush;
                 QPen pen(brush, 3);
                 pen.setColor(color);
                 presenter->m_markerPen = pen;
             }
             void ChartTheme::decorate(PiePresenter* item, QPieSeries* series, int /*count*/)
             {
                 // create a list of slice colors based on current theme
                 int i = 0;
                 QList<QColor> colors;
                 while (colors.count() < series->count()) {
                     // get base color
                     QColor c = m_seriesColor[i++];
                     i = i % m_seriesColor.count();
                     // dont use black colors... looks bad
                     if (c == Qt::black)
                         continue;
                     // by default use the "raw" theme color
                     if (!colors.contains(c)) {
                         colors << c;
                         continue;
                     }
                     // ...ok we need to generate something that looks like the same color
                     // but different lightness
                     int tryCount = 0;
                     while (tryCount++ < 100) {
                         // find maximum value we can raise the lightness
                         int lMax = 255;
                         if (lMax > 255 - c.red())
                             lMax = 255 - c.red();
                         if (lMax > 255 - c.green())
                             lMax = 255 - c.green();
                         if (lMax > 255 - c.blue())
                             lMax = 255 - c.blue();
                         // find maximum value we can make it darker
                         int dMax = 255;
                         if (dMax > c.red())
                             dMax = c.red();
                         if (dMax > c.green())
                             dMax = c.green();
                         if (dMax > c.blue())
                             dMax = c.blue();
                         int max = dMax + lMax;
                         if (max == 0) {
                             // no room to make color lighter or darker...
                             qDebug() << "cannot generate a color for pie!";
                             break;
                         }
                         // generate random color
                         int r = c.red() - dMax;
                         int g = c.green() - dMax;
                         int b = c.blue() - dMax;
                         int d = qrand() % max;
                         c.setRgb(r+d, g+d, b+d);
                         // found a unique color?
                         if (!colors.contains(c))
                             break;
                     }
                     qDebug() << "generated a color for pie" << c;
                     colors << c;
                 }
                 // finally update colors
                 foreach (QPieSlice* s, series->slices()) {
                     QColor c = colors.takeFirst();
                     s->setPen(c);
                     s->setBrush(c);
                 }
             }
             void ChartTheme::decorate(QChartAxis* axis,AxisItem* item)
             {
                 //TODO: dummy defults for now
                 axis->setLabelsBrush(Qt::black);
                 axis->setLabelsPen(Qt::NoPen);
                 axis->setShadesPen(Qt::NoPen);
                 axis->setShadesOpacity(0.5);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piechart.pri +3 -3

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/qpieseries.cpp \
                 $$PWD/pieslice.cpp \
                 $$PWD/piepresenter.cpp \
                 $$PWD/pieslicelabel.cpp \
                 $$PWD/qpieslice.cpp
             PRIVATE_HEADERS += \
-                $$PWD/piepresenter.h \
+                $$PWD/piepresenter_p.h \
-                $$PWD/pieslice.h \
+                $$PWD/pieslice_p.h \
-                $$PWD/pieslicelabel.h
+                $$PWD/pieslicelabel_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qpieseries.h \
                 $$PWD/qpieslice.h

src/piechart/piepresenter.cpp +4 -4

-            #include "piepresenter.h"
+            #include "piepresenter_p.h"
-            #include "pieslice.h"
+            #include "pieslice_p.h"
             #include "qpieslice.h"
-            #include "pieslicelabel.h"
+            #include "pieslicelabel_p.h"
             #include "qpieseries.h"
             #include <qmath.h>
             #include <QDebug>
             #include <QFontMetrics>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PiePresenter::PiePresenter(QGraphicsItem *parent, QPieSeries *series)
                 :ChartItem(parent),
                 m_series(series)
             {
                 Q_ASSERT(series);
                 connect(series, SIGNAL(changed(const QPieSeries::ChangeSet&)), this, SLOT(handleSeriesChanged(const QPieSeries::ChangeSet&)));
                 connect(series, SIGNAL(sizeFactorChanged()), this, SLOT(updateGeometry()));
                 connect(series, SIGNAL(positionChanged()), this, SLOT(updateGeometry()));
                 if (m_series->count()) {
                     QPieSeries::ChangeSet changeSet;
                     changeSet.appendAdded(m_series->m_slices);
                     handleSeriesChanged(changeSet);
                 }
             }
             PiePresenter::~PiePresenter()
             {
                 // slices deleted automatically through QGraphicsItem
             }
             void PiePresenter::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
             {
                 // TODO: paint shadows for all components
                 // - get paths from items & merge & offset and draw with shadow color?
             }
             void PiePresenter::handleSeriesChanged(const QPieSeries::ChangeSet& changeSet)
             {
                 //qDebug() << "PiePresenter::handleSeriesChanged()";
                 //qDebug() << "  added  : " << changeSet.added();
                 //qDebug() << "  changed: " << changeSet.changed();
                 //qDebug() << "  removed: " << changeSet.removed();
                 foreach (QPieSlice* s, changeSet.added())
                     addSlice(s);
                 foreach (QPieSlice* s, changeSet.changed())
                     updateSlice(s);
                 foreach (QPieSlice* s, changeSet.removed())
                     deleteSlice(s);
                 // every change possibly changes the actual pie size
                 updateGeometry();
             }
             void PiePresenter::handleDomainChanged(const Domain& domain)
             {
                 // TODO
             }
             void PiePresenter::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect = rect;
                 prepareGeometryChange();
                 updateGeometry();
             }
             void PiePresenter::updateGeometry()
             {
                 if (!m_rect.isValid() || m_rect.isEmpty())
                     return;
                 // calculate maximum rectangle for pie
                 QRectF pieRect = m_rect;
                 if (pieRect.width() < pieRect.height()) {
                     pieRect.setWidth(pieRect.width() * m_series->sizeFactor());
                     pieRect.setHeight(pieRect.width());
                     pieRect.moveCenter(m_rect.center());
                 } else {
                     pieRect.setHeight(pieRect.height() * m_series->sizeFactor());
                     pieRect.setWidth(pieRect.height());
                     pieRect.moveCenter(m_rect.center());
                 }
                 // position the pie rectangle
                 switch (m_series->position()) {
                     case QPieSeries::PiePositionTopLeft: {
                         pieRect.setHeight(pieRect.height() / 2);
                         pieRect.setWidth(pieRect.height());
                         pieRect.moveCenter(QPointF(m_rect.center().x() / 2, m_rect.center().y() / 2));
                         break;
                     }
                     case QPieSeries::PiePositionTopRight: {
                         pieRect.setHeight(pieRect.height() / 2);
                         pieRect.setWidth(pieRect.height());
                         pieRect.moveCenter(QPointF((m_rect.center().x() / 2) * 3, m_rect.center().y() / 2));
                         break;
                     }
                     case QPieSeries::PiePositionBottomLeft: {
                         pieRect.setHeight(pieRect.height() / 2);
                         pieRect.setWidth(pieRect.height());
                         pieRect.moveCenter(QPointF(m_rect.center().x() / 2, (m_rect.center().y() / 2) * 3));
                         break;
                     }
                     case QPieSeries::PiePositionBottomRight: {
                         pieRect.setHeight(pieRect.height() / 2);
                         pieRect.setWidth(pieRect.height());
                         pieRect.moveCenter(QPointF((m_rect.center().x() / 2) * 3, (m_rect.center().y() / 2) * 3));
                         break;
                     }
                     default:
                         break;
                 }
                 // calculate how much space we need around the pie rectangle (labels & exploding)
                 qreal delta = 0;
                 qreal pieRadius = pieRect.height() / 2;
                 foreach (QPieSlice* s, m_series->m_slices) {
                     // calculate the farthest point in the slice from the pie center
                     qreal centerAngle = s->angle() + (s->angleSpan() / 2);
                     qreal len = pieRadius + s->labelArmLength() + s->explodeDistance();
                     QPointF dp(qSin(centerAngle*(PI/180)) * len, -qCos(centerAngle*(PI/180)) * len);
                     QPointF p = pieRect.center() + dp;
                     // TODO: consider the label text
                     // calculate how much the radius must get smaller to fit that point in the base rectangle
                     qreal dt = m_rect.top() - p.y();
                     if (dt > delta) delta = dt;
                     qreal dl = m_rect.left() - p.x();
                     if (dl > delta) delta = dl;
                     qreal dr = p.x() - m_rect.right();
                     if (dr > delta) delta = dr;
                     qreal db = p.y() - m_rect.bottom();
                     if (db > delta) delta = db;
                     //if (!m_rect.contains(p)) qDebug() << s->label() << dt << dl << dr << db << "delta" << delta;
                 }
                 // shrink the pie rectangle so that everything outside it fits the base rectangle
                 pieRect.adjust(delta, delta, -delta, -delta);
                 // update slices
                 if (m_pieRect != pieRect) {
                     m_pieRect = pieRect;
                     //qDebug() << "PiePresenter::updateGeometry()" << m_rect << m_pieRect;
                     foreach (PieSlice* s, m_slices.values()) {
                         s->setPieRect(m_pieRect);
                         s->updateGeometry();
                         s->update();
                     }
                 }
             }
             void PiePresenter::addSlice(QPieSlice* sliceData)
             {
                 //qDebug() << "PiePresenter::addSlice()" << sliceData;
                 if (m_slices.keys().contains(sliceData)) {
                     Q_ASSERT(0); // TODO: how to handle this nicely?
                     return;
                 }
                 // create slice
                 PieSlice *slice = new PieSlice(this);
                 slice->setPieRect(m_pieRect);
                 slice->updateData(sliceData);
                 slice->updateGeometry();
                 slice->update();
                 m_slices.insert(sliceData, slice);
                 // connect signals
                 connect(slice, SIGNAL(clicked()), sliceData, SIGNAL(clicked()));
                 connect(slice, SIGNAL(hoverEnter()), sliceData, SIGNAL(hoverEnter()));
                 connect(slice, SIGNAL(hoverLeave()), sliceData, SIGNAL(hoverLeave()));
             }
             void PiePresenter::updateSlice(QPieSlice* sliceData)
             {
                 //qDebug() << "PiePresenter::updateSlice()" << sliceData;
                 if (!m_slices.contains(sliceData)) {
                     Q_ASSERT(0); // TODO: how to handle this nicely?
                     return;
                 }
                 m_slices[sliceData]->updateData(sliceData);
             }
             void PiePresenter::deleteSlice(QPieSlice* sliceData)
             {
                 //qDebug() << "PiePresenter::deleteSlice()" << sliceData;
                 if (!m_slices.contains(sliceData)) {
                     Q_ASSERT(0); // TODO: how to handle this nicely?
                     return;
                 }
                 delete m_slices.take(sliceData);
             }
-            #include "moc_piepresenter.cpp"
+            #include "moc_piepresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piepresenter_p.h ~~src/piechart/piepresenter.h~~ renamed 0 0

NO CONTENT: file renamed from src/piechart/piepresenter.h to src/piechart/piepresenter_p.h

src/piechart/pieslice.cpp +4 -4

-            #include "pieslice.h"
+            #include "pieslice_p.h"
-            #include "pieslicelabel.h"
+            #include "pieslicelabel_p.h"
-            #include "piepresenter.h"
+            #include "piepresenter_p.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include <QPainter>
             #include <QDebug>
             #include <qmath.h>
             #include <QGraphicsSceneEvent>
             #include <QTime>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QPointF offset(qreal angle, qreal length)
             {
                 qreal dx = qSin(angle*(PI/180)) * length;
                 qreal dy = qCos(angle*(PI/180)) * length;
                 return QPointF(dx, -dy);
             }
             PieSlice::PieSlice(QGraphicsItem* parent)
                 :QGraphicsObject(parent),
                 m_slicelabel(new PieSliceLabel(this)),
                 m_angle(0),
                 m_angleSpan(0),
                 m_isExploded(false),
                 m_explodeDistance(0)
             {
                 setAcceptHoverEvents(true);
                 setAcceptedMouseButtons(Qt::LeftButton);
             }
             PieSlice::~PieSlice()
             {
             }
             QRectF PieSlice::boundingRect() const
             {
                 return m_path.boundingRect();
             }
             QPainterPath PieSlice::shape() const
             {
                 return m_path;
             }
             void PieSlice::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
             {
                 painter->setPen(m_pen);
                 painter->setBrush(m_brush);
                 painter->drawPath(m_path);
             }
             void PieSlice::hoverEnterEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverEnter();
             }
             void PieSlice::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverLeave();
             }
             void PieSlice::mousePressEvent(QGraphicsSceneMouseEvent* /*event*/)
             {
                 emit clicked();
             }
             void PieSlice::setPieRect(QRectF rect)
             {
                 m_pieRect = rect;
             }
             void PieSlice::updateGeometry()
             {
                 if (!m_pieRect.isValid() || m_pieRect.isEmpty())
                     return;
                 prepareGeometryChange();
                 // calculate center angle
                 qreal centerAngle = m_angle + (m_angleSpan/2);
                 // adjust rect for exploding
                 QRectF rect = m_pieRect;
                 if (m_isExploded) {
                     qreal dx = qSin(centerAngle*(PI/180)) * m_explodeDistance;
                     qreal dy = -qCos(centerAngle*(PI/180)) * m_explodeDistance;
                     rect.translate(dx, dy);
                 }
                 // update slice path
                 // TODO: draw the shape so that it might have a hole in the center
                 QPainterPath path;
                 path.moveTo(rect.center());
                 path.arcTo(rect, -m_angle + 90, -m_angleSpan);
                 path.closeSubpath();
                 m_path = path;
                 // update label position
                 qreal radius = rect.height() / 2;
                 QPointF edgeCenter = rect.center() + offset(centerAngle, radius + 5);
                 m_slicelabel->setArmStartPoint(edgeCenter);
                 m_slicelabel->setArmAngle(centerAngle);
                 m_slicelabel->updateGeometry();
                 m_slicelabel->update();
                 //qDebug() << "PieSlice::updateGeometry" << m_slicelabel->text() << boundingRect() << m_angle << m_span;
             }
             void PieSlice::updateData(const QPieSlice* sliceData)
             {
                 // TODO: compare what has changes to avoid unneccesary geometry updates
                 m_angle = sliceData->angle();
                 m_angleSpan = sliceData->angleSpan();
                 m_isExploded = sliceData->isExploded();
                 m_explodeDistance = sliceData->explodeDistance(); // TODO: expose to public API
                 m_pen = sliceData->pen();
                 m_brush = sliceData->brush();
                 m_slicelabel->setVisible(sliceData->isLabelVisible());
                 m_slicelabel->setText(sliceData->label());
                 m_slicelabel->setPen(sliceData->labelPen());
                 m_slicelabel->setFont(sliceData->labelFont());
                 m_slicelabel->setArmLength(sliceData->labelArmLength());
                 updateGeometry();
                 update();
             }
-            #include "moc_pieslice.cpp"
+            #include "moc_pieslice_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslice_p.h ~~src/piechart/pieslice.h~~ renamed 0 0

NO CONTENT: file renamed from src/piechart/pieslice.h to src/piechart/pieslice_p.h

src/piechart/pieslicelabel.cpp +1 -1

-            #include "pieslicelabel.h"
+            #include "pieslicelabel_p.h"
             #include <QPainter>
             #include <qmath.h>
             #include <QGraphicsTextItem>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             #define PI 3.14159265
             PieSliceLabel::PieSliceLabel(QGraphicsItem* parent)
                 :QGraphicsItem(parent),
                 m_armAngle(0),
                 m_armLength(0)
             {
             }
             void PieSliceLabel::paint(QPainter *painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
             {
                 painter->setPen(m_pen);
                 painter->drawPath(m_armPath);
                 // TODO: do we need a pen for text?
                 painter->setFont(m_font);
                 painter->drawText(m_textRect.bottomLeft(), m_text);
                 //qDebug() << "PieSliceLabel::paint" << m_text << m_textRect;
             }
             void PieSliceLabel::updateGeometry()
             {
                 prepareGeometryChange();
                 // calculate text size
                 QFontMetricsF fm(m_font);
                 QRectF textRect = fm.boundingRect(m_text);
                 // calculate path for arm and text start point
                 qreal dx = qSin(m_armAngle*(PI/180)) * m_armLength;
                 qreal dy = -qCos(m_armAngle*(PI/180)) * m_armLength;
                 QPointF parm1 = m_armStartPoint + QPointF(dx, dy);
                 // calculate horizontal arm and text position
                 QPointF parm2 = parm1;
                 textRect.moveBottomLeft(parm1);
                 if (m_armAngle < 180) { // arm swings the other way on the left side
                      parm2 += QPointF(m_textRect.width(), 0);
                 } else {
                      parm2 += QPointF(-m_textRect.width(),0);
                      textRect.moveBottomLeft(parm2);
                 }
                 // add a little offset to text so that it does not touch the arm
                 qreal yOffset = m_pen.widthF() ? m_pen.widthF() : 2;
                 textRect.translate(0, -yOffset);
                 // update arm path
                 QPainterPath path;
                 path.moveTo(m_armStartPoint);
                 path.lineTo(parm1);
                 path.lineTo(parm2);
                 // update paths & rects
                 m_armPath = path;
                 m_textRect = textRect;
                 m_rect = path.boundingRect().united(m_textRect);
                 //qDebug() << "PieSliceLabel::updateGeometry" << m_text << m_armStartPoint << m_armLength << m_armAngle << m_textRect;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslicelabel_p.h ~~src/piechart/pieslicelabel.h~~ renamed 0 0

NO CONTENT: file renamed from src/piechart/pieslicelabel.h to src/piechart/pieslicelabel_p.h

src/piechart/qpieseries.cpp 0 -3

             #include "qpieseries.h"
             #include "qpieslice.h"
-            #include "piepresenter.h"
-            #include "pieslice.h"
-            #include <QFontMetrics>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries::ChangeSet
                 \brief Defines the changes in the series.
                 Contains the changes that have occurred in the series. Lists of added, changed and removed slices.
                 \sa QPieSeries::changed()
             */
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendAdded(QPieSlice* slice)
             {
                 if (!m_added.contains(slice))
                     m_added << slice;
             }
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendAdded(QList<QPieSlice*> slices)
             {
                 foreach (QPieSlice* s, slices)
                     appendAdded(s);
             }
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendChanged(QPieSlice* slice)
             {
                 if (!m_changed.contains(slice))
                     m_changed << slice;
             }
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendRemoved(QPieSlice* slice)
             {
                 if (!m_removed.contains(slice))
                     m_removed << slice;
             }
             /*!
                 Returns a list of slices that have been added to the series.
                 \sa QPieSeries::changed()
             */
             QList<QPieSlice*> QPieSeries::ChangeSet::added() const
             {
                 return m_added;
             }
             /*!
                 Returns a list of slices that have been changed in the series.
                 \sa QPieSeries::changed()
             */
             QList<QPieSlice*> QPieSeries::ChangeSet::changed() const
             {
                 return m_changed;
             }
             /*!
                 Returns a list of slices that have been removed from the series.
                 \sa QPieSeries::changed()
             */
             QList<QPieSlice*> QPieSeries::ChangeSet::removed() const
             {
                 return m_removed;
             }
             /*!
                 Returns true if there are no added/changed or removed slices in the change set.
             */
             bool QPieSeries::ChangeSet::isEmpty() const
             {
                 if (m_added.count() || m_changed.count() || m_removed.count())
                     return false;
                 return true;
             }
             /*!
                 \enum QPieSeries::PiePosition
                 This enum describes pie position within its bounding rectangle
                 \value PiePositionMaximized
                 \value PiePositionTopLeft
                 \value PiePositionTopRight
                 \value PiePositionBottomLeft
                 \value PiePositionBottomRight
             */
             /*!
                 \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 (span) is determined by that relative value.
                 By default the pie is defined as full but it can be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
                 Example on how to create a chart with pie series:
                 \snippet ../example/piechart/main.cpp 1
                 To help with the most common user intercation scenarions there some convenience functions. Specifically
                 exploding and higlighting:
                 \snippet ../example/piechart/main.cpp 2
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent) :
                 QChartSeries(parent),
                 m_sizeFactor(1.0),
                 m_position(PiePositionMaximized),
                 m_pieStartAngle(0),
                 m_pieAngleSpan(360)
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QPieSeries::~QPieSeries()
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
             QChartSeries::QChartSeriesType QPieSeries::type() const
             {
                 return QChartSeries::SeriesTypePie;
             }
             /*!
                 \internal \a data
             */
             bool QPieSeries::setData(QList<qreal> data)
             {
                 // TODO: remove this function
                 QList<QPieSlice*> slices;
                 foreach (qreal value, data)
                     slices << new QPieSlice(value, QString::number(value));
                 set(slices);
                 return true;
             }
             /*!
                 Sets an array of \a slices to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::set(QList<QPieSlice*> slices)
             {
                 clear();
                 add(slices);
             }
             /*!
                 Adds an array of \a slices to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::add(QList<QPieSlice*> slices)
             {
                 ChangeSet changeSet;
                 foreach (QPieSlice* s, slices) {
                     s->setParent(this);
                     m_slices << s;
                     changeSet.appendAdded(s);
                 }
                 updateDerivativeData();
                 foreach (QPieSlice* s, slices) {
                     connect(s, SIGNAL(changed()), this, SLOT(sliceChanged()));
                     connect(s, SIGNAL(clicked()), this, SLOT(sliceClicked()));
                     connect(s, SIGNAL(hoverEnter()), this, SLOT(sliceHoverEnter()));
                     connect(s, SIGNAL(hoverLeave()), this, SLOT(sliceHoverLeave()));
                 }
                 emit changed(changeSet);
             }
             /*!
                 Adds a single \a slice to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::add(QPieSlice* slice)
             {
                 add(QList<QPieSlice*>() << slice);
             }
             /*!
                 Adds a single slice to the series with give \a value and \a name.
                 Slice ownership is passed to the series.
             */
             QPieSlice* QPieSeries::add(qreal value, QString name)
             {
                 QPieSlice* slice = new QPieSlice(value, name);
                 add(slice);
                 return slice;
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference this pointer after this call.
             */
             void QPieSeries::remove(QPieSlice* slice)
             {
                 if (!m_slices.removeOne(slice)) {
                     Q_ASSERT(0); // TODO: how should this be reported?
                     return;
                 }
                 ChangeSet changeSet;
                 changeSet.appendRemoved(slice);
                 emit changed(changeSet);
                 delete slice;
                 slice = NULL;
                 updateDerivativeData();
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 if (m_slices.count() == 0)
                     return;
                 ChangeSet changeSet;
                 foreach (QPieSlice* s, m_slices) {
                     changeSet.appendRemoved(s);
                     m_slices.removeOne(s);
                     delete s;
                 }
                 emit changed(changeSet);
                 updateDerivativeData();
             }
             /*!
                 Counts the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 return m_slices.count();
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice*> QPieSeries::slices() const
             {
                 return m_slices;
             }
             /*!
                 Sets the size \a factor of the pie. 1.0 is the default value.
                 Note that the pie will not grow beyond its absolute maximum size.
                 In practice its use is to make the pie appear smaller.
                 \sa sizeFactor()
             */
             void QPieSeries::setSizeFactor(qreal factor)
             {
                 if (factor < 0.0)
                     return;
                 if (m_sizeFactor != factor) {
                     m_sizeFactor = factor;
                     emit sizeFactorChanged();
                 }
             }
             /*!
                 Gets the size factor of the pie.
                 \sa setSizeFactor()
             */
             qreal QPieSeries::sizeFactor() const
             {
                 return m_sizeFactor;
             }
             /*!
                 Sets the \a position of the pie within its bounding rectangle.
                 \sa PiePosition, position()
             */
             void QPieSeries::setPosition(PiePosition position)
             {
                 if (m_position != position) {
                     m_position = position;
                     emit positionChanged();
                 }
             }
             /*!
                 Gets the position of the pie within its bounding rectangle.
                 \sa PiePosition, setPosition()
             */
             QPieSeries::PiePosition QPieSeries::position() const
             {
                 return m_position;
             }
             /*!
                 Sets the \a startAngle and \a angleSpan of this series.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
             */
             void QPieSeries::setSpan(qreal startAngle, qreal angleSpan)
             {
                 if (startAngle >= 0 && startAngle < 360 &&
                     angleSpan > 0 && angleSpan <= 360) {
                     m_pieStartAngle = startAngle;
                     m_pieAngleSpan = angleSpan;
                     updateDerivativeData();
                 }
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 foreach (QPieSlice* s, m_slices)
                     s->setLabelVisible(visible);
             }
             /*!
                 Convenience method for exploding a slice when user clicks the pie. Set \a enable to true to
                 explode slices by clicking.
                 \sa QPieSlice::isExploded(), QPieSlice::setExploded(), QPieSlice::setExplodeDistance()
             */
             void QPieSeries::enableClickExplodes(bool enable)
             {
                 if (enable)
                     connect(this, SIGNAL(clicked(QPieSlice*)), this, SLOT(toggleExploded(QPieSlice*)));
                 else
                     disconnect(this, SLOT(toggleExploded(QPieSlice*)));
             }
             /*!
                 Convenience method for highlighting a slice when user hovers over the slice.
                 It changes the slice color to be lighter and shows the label of the slice.
                 Set \a enable to true to highlight a slice when user hovers on top of it.
                 \sa QPieSlice::isExploded(), QPieSlice::setExploded()
             */
             void QPieSeries::enableHoverHighlight(bool enable)
             {
                 if (enable) {
                     connect(this, SIGNAL(hoverEnter(QPieSlice*)), this, SLOT(highlightOn(QPieSlice*)));
                     connect(this, SIGNAL(hoverLeave(QPieSlice*)), this, SLOT(highlightOff(QPieSlice*)));
                 } else {
                     disconnect(this, SLOT(hoverEnter(QPieSlice*)));
                     disconnect(this, SLOT(hoverLeave(QPieSlice*)));
                 }
             }
             /*!
                 \fn void QPieSeries::changed(const QPieSeries::ChangeSet& changeSet)
                 This signal emitted when something has changed in the series.
                 The \a changeSet contains the details of which slices have been added, changed or removed.
                 \sa QPieSeries::ChangeSet, QPieSlice::changed()
             */
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice)
                 This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
             /*!
                 \fn void QPieSeries::hoverEnter(QPieSlice* slice)
                 This signal is emitted when user has hovered over a \a slice.
                 \sa QPieSlice::hoverEnter()
             */
             /*!
                 \fn void QPieSeries::hoverLeave(QPieSlice* slice)
                 This signal is emitted when user has hovered away from a \a slice.
                 \sa QPieSlice::hoverLeave()
             */
             /*!
                 \fn void QPieSeries::sizeFactorChanged()
                 This signal is emitted when size factor has been changed.
                 \sa sizeFactor(), setSizeFactor()
             */
             /*!
                 \fn void QPieSeries::positionChanged()
                 This signal is emitted when position of the pie has been changed.
                 \sa position(), setPosition()
             */
             void QPieSeries::sliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 ChangeSet changeSet;
                 changeSet.appendChanged(slice);
                 emit changed(changeSet);
                 updateDerivativeData();
             }
             void QPieSeries::sliceClicked()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit clicked(slice);
             }
             void QPieSeries::sliceHoverEnter()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit hoverEnter(slice);
             }
             void QPieSeries::sliceHoverLeave()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit hoverLeave(slice);
             }
             void QPieSeries::toggleExploded(QPieSlice* slice)
             {
                 Q_ASSERT(slice);
                 slice->setExploded(!slice->isExploded());
             }
             void QPieSeries::highlightOn(QPieSlice* slice)
             {
                 Q_ASSERT(slice);
                 QColor c = slice->brush().color().lighter();
                 slice->setBrush(c);
                 slice->setLabelVisible(true);
             }
             void QPieSeries::highlightOff(QPieSlice* slice)
             {
                 Q_ASSERT(slice);
                 QColor c = slice->brush().color().darker(150);
                 slice->setBrush(c);
                 slice->setLabelVisible(false);
             }
             void QPieSeries::updateDerivativeData()
             {
                 m_total = 0;
                 // nothing to do?
                 if (m_slices.count() == 0)
                     return;
                 // calculate total
                 foreach (QPieSlice* s, m_slices)
                     m_total += s->value();
                 // we must have some values
                 Q_ASSERT(m_total > 0); // TODO: is this the correct way to handle this?
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 foreach (QPieSlice* s, m_slices) {
                     bool changed = false;
                     qreal percentage = s->value() / m_total;
                     if (s->m_percentage != percentage) {
                         s->m_percentage = percentage;
                         changed = true;
                     }
                     qreal sliceSpan = m_pieAngleSpan * percentage;
                     if (s->m_angleSpan != sliceSpan) {
                         s->m_angleSpan = sliceSpan;
                         changed = true;
                     }
                     if (s->m_angle != sliceAngle) {
                         s->m_angle = sliceAngle;
                         changed = true;
                     }
                     sliceAngle += sliceSpan;
                     if (changed)
                         emit s->changed();
                 }
             }
             #include "moc_qpieseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

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