HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r163:daab1c215b03

Make pie work better with chartwidgettest

Jani Honkonen -

r163:daab1c215b03

parent child

Context file:

r163:daab1c215b03

Collapse all files

src/chartpresenter.cpp +2 -3

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             //series
             #include "barchartseries.h"
             #include "stackedbarchartseries.h"
             #include "percentbarchartseries.h"
             #include "qlinechartseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             //items
             #include "axisitem_p.h"
             #include "bargroup.h"
             #include "stackedbargroup.h"
             #include "linechartitem_p.h"
             #include "percentbargroup.h"
             #include "linechartanimationitem_p.h"
             #include "piepresenter.h"
             #include "scatterpresenter.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_dataset(dataset),
             m_chartTheme(0),
             m_domainIndex(0),
             m_marginSize(0),
             m_axisX(new QChartAxis(this)),
             m_axisY(new QChartAxis(this)),
             m_rect(QRectF(QPoint(0,0),m_chart->size()))
             {
                 setChartTheme(QChart::ChartThemeDefault);
                 m_axisItems[m_axisX] = new AxisItem(m_axisX,AxisItem::X_AXIS,m_chart);
                 m_axisItems[m_axisY] = new AxisItem(m_axisY,AxisItem::Y_AXIS,m_chart);
                 createConnections();
             }
             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*)));
                 QMapIterator<QChartAxis*,AxisItem*> i(m_axisItems);
                 while (i.hasNext()) {
                     i.next();
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),i.value(),SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),i.value(),SLOT(handleDomainChanged(const Domain&)));
                 }
             }
             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::handleSeriesAdded(QChartSeries* series)
             {
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QLineChartSeries* lineSeries = static_cast<QLineChartSeries*>(series);
                         LineChartItem* item = new LineChartAnimationItem(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(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(lineSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         BarChartSeries* barSeries = static_cast<BarChartSeries*>(series);
                         BarGroup* item = new BarGroup(*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(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(barSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         // m_axisXItem->setVisible(false);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         StackedBarChartSeries* stackedBarSeries = static_cast<StackedBarChartSeries*>(series);
                         StackedBarGroup* item = new StackedBarGroup(*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(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(stackedBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         PercentBarChartSeries* percentBarSeries = static_cast<PercentBarChartSeries*>(series);
                         PercentBarGroup* item = new PercentBarGroup(*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(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         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(this, SIGNAL(geometryChanged(const QRectF&)),
                                          scatterPresenter, SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset, SIGNAL(domainChanged(const Domain&)),
                                          scatterPresenter, SLOT(handleDomainChanged(const Domain&)));
             //            scatterSeries->d->m_theme = m_chartTheme->themeForSeries();
             //            scatterSeries->d->setParentItem(this);
             //            scatterSeries->d->m_boundingRect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                         m_chartItems.insert(scatterSeries, scatterPresenter);
                         break;
                     }
                     case QChartSeries::SeriesTypePie: {
-                        QPieSeries *pieSeries = qobject_cast<QPieSeries *>(series);
+                        QPieSeries *s = qobject_cast<QPieSeries *>(series);
-                        PiePresenter* pie = new PiePresenter(m_chart, pieSeries);
+                        PiePresenter* pie = new PiePresenter(m_chart, s);
-                        QObject::connect(pieSeries, SIGNAL(changed(const PieChangeSet&)), pie, SLOT(handleSeriesChanged(const PieChangeSet&)));
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pie, SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset, SIGNAL(domainChanged(const Domain&)), pie, SLOT(handleDomainChanged(const Domain&)));
                         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::handleSeriesChanged(QChartSeries* series)
             {
                 //TODO:
             }
             void ChartPresenter::zoomInToRect(const QRectF& rect)
             {
                 if(!rect.isValid()) return;
                 QRectF r = rect.normalized();
                 r.translate(-m_marginSize, -m_marginSize);
                 Domain domain (m_dataset->domain().subDomain(r,m_rect.width(),m_rect.height()));
                 m_dataset->addDomain(domain);
             }
             void ChartPresenter::zoomIn()
             {
                 if (!m_dataset->nextDomain()) {
                     QRectF rect = m_rect;
                     rect.setWidth(rect.width()/2);
                     rect.setHeight(rect.height()/2);
                     rect.moveCenter(m_rect.center());
                     Domain domain (m_dataset->domain().subDomain(rect,m_rect.width(),m_rect.height()));
                     m_dataset->addDomain(domain);
                 }
             }
             void ChartPresenter::zoomOut()
             {
                 m_dataset->previousDomain();
             }
             void ChartPresenter::zoomReset()
             {
                 m_dataset->clearDomains();
             }
             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();
                     index++;
                     m_chartTheme->decorate(i.value(),i.key(),index);
                   }
                 }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             QChartAxis* ChartPresenter::axisX()
             {
                return m_axisX;
             }
             QChartAxis* ChartPresenter::axisY()
             {
                return m_axisY;
             }
             QChartAxis* ChartPresenter::addAxisX()
             {
               //only one axis
               if(m_axisX==0){
                   m_axisX = new QChartAxis(this);
                   m_axisItems[m_axisX] = new AxisItem(m_axisX,AxisItem::X_AXIS,m_chart);
               }
               return m_axisX;
             }
             QChartAxis* ChartPresenter::addAxisY()
             {
                 if(m_axisY==0){
                     m_axisY = new QChartAxis(this);
                     m_axisItems[m_axisY] = new AxisItem(m_axisY,AxisItem::Y_AXIS,m_chart);
                     return m_axisY;
                 }
                 QChartAxis* axis = new QChartAxis(this);
                 m_axisItems[axis] = new AxisItem(axis,AxisItem::Y_AXIS,m_chart);
                 return axis;
             }
             void ChartPresenter::removeAxis(QChartAxis* axis)
             {
                 AxisItem* item = m_axisItems.take(axis);
                 if(item){
                     delete item;
                     delete axis;
                 }
                 //reset pointers to default ones
                 if(axis == m_axisX) m_axisX=0;
                 else if(axis == m_axisY) m_axisY=0;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme.cpp +20 0

             #include "charttheme_p.h"
             #include "qchart.h"
             //series
             #include "barchartseries.h"
             #include "stackedbarchartseries.h"
             #include "percentbarchartseries.h"
             #include "qlinechartseries.h"
+            #include "qpieseries.h"
             //items
             #include "axisitem_p.h"
             #include "bargroup.h"
             #include "stackedbargroup.h"
             #include "linechartitem_p.h"
             #include "percentbargroup.h"
+            #include "piepresenter.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));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeDefault:
                         return new ChartTheme();
                     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: {
                         QLineChartSeries* s = static_cast<QLineChartSeries*>(series);
                         LineChartItem* i = static_cast<LineChartItem*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         BarChartSeries* b = static_cast<BarChartSeries*>(series);
                         BarGroup* i = static_cast<BarGroup*>(item);
                         decorate(i,b,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         StackedBarChartSeries* s = static_cast<StackedBarChartSeries*>(series);
                         StackedBarGroup* i = static_cast<StackedBarGroup*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         PercentBarChartSeries* s = static_cast<PercentBarChartSeries*>(series);
                         PercentBarGroup* i = static_cast<PercentBarGroup*>(item);
                         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, QLineChartSeries* 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(BarGroup* item, BarChartSeries* series,int count)
             {
                 item->addColor(QColor(255,0,0,128));
                 item->addColor(QColor(255,255,0,128));
                 item->addColor(QColor(0,255,0,128));
                 item->addColor(QColor(0,0,255,128));
                 item->addColor(QColor(255,128,0,128));
             }
             void ChartTheme::decorate(StackedBarGroup* item, StackedBarChartSeries* series,int count)
             {
                 // Add some fugly colors for 5 fist series...
                 item->addColor(QColor(255,0,0,128));
                 item->addColor(QColor(255,255,0,128));
                 item->addColor(QColor(0,255,0,128));
                 item->addColor(QColor(0,0,255,128));
                 item->addColor(QColor(255,128,0,128));
             }
             void ChartTheme::decorate(PercentBarGroup* item, PercentBarChartSeries* series,int count)
             {
             // Add some fugly colors for 5 fist series...
                 item->addColor(QColor(255,0,0,128));
                 item->addColor(QColor(255,255,0,128));
                 item->addColor(QColor(0,255,0,128));
                 item->addColor(QColor(0,0,255,128));
                 item->addColor(QColor(255,128,0,128));
             }
+            void ChartTheme::decorate(PiePresenter* item, QPieSeries* series, int /*count*/)
+            {
+                // TODO: Does not work well. We need to generate enough different colors
+                // based on available theme and not use the same color twice.
+                for (int i=0; i<series->count(); i++) {
+                    QPieSlice slice = series->slice(i);
+                    slice.m_color = m_seriesColor.at(i % m_seriesColor.count());
+                    series->update(i, slice);
+                }
+            }
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme_p.h +3 0

             #ifndef CHARTTHEME_H
             #define CHARTTHEME_H
             #include "qchartglobal.h"
             #include "qchart.h"
             #include <QColor>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class QChartSeries;
             class LineChartItem;
             class QLineChartSeries;
             class BarGroup;
             class BarChartSeries;
             class StackedBarGroup;
             class StackedBarChartSeries;
             class PercentBarChartSeries;
             class PercentBarGroup;
+            class PiePresenter;
+            class QPieSeries;
             class ChartTheme
             {
             protected:
                 explicit ChartTheme(QChart::ChartTheme id =  QChart::ChartThemeDefault);
             public:
                 static ChartTheme* createTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme id() const {return m_id;}
                 void decorate(QChart* chart);
                 void decorate(ChartItem* item, QChartSeries* series,int count);
                 void decorate(LineChartItem* item, QLineChartSeries*, int count);
                 void decorate(BarGroup* item, BarChartSeries* series,int count);
                 void decorate(StackedBarGroup* item, StackedBarChartSeries* series,int count);
                 void decorate(PercentBarGroup* item, PercentBarChartSeries* series,int count);
+                void decorate(PiePresenter* item, QPieSeries* series, int count);
             protected:
                 QChart::ChartTheme m_id;
                 QColor m_gradientStartColor;
                 QColor m_gradientEndColor;
                 QList<QColor> m_seriesColor;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // CHARTTHEME_H

src/piechart/piepresenter.cpp +18 -4

             #include "piepresenter.h"
             #include "pieslice.h"
             #include <QDebug>
+            #include <QTime>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PiePresenter::PiePresenter(QGraphicsItem *parent, QPieSeries *series) :
                 ChartItem(parent),
                 m_pieSeries(series)
             {
                 Q_ASSERT(parent);
                 Q_ASSERT(series);
                 m_rect = parentItem()->boundingRect();
                 setAcceptHoverEvents(true);
+                qsrand(QTime::currentTime().msec()); // for random color generation
+                connect(series, SIGNAL(changed(const PieChangeSet&)), this, SLOT(handleSeriesChanged(const PieChangeSet&)));
+                connect(series, SIGNAL(sizeFactorChanged()), this, SLOT(updateGeometry()));
+                connect(series, SIGNAL(positionChanged()), this, SLOT(updateGeometry()));
             }
             PiePresenter::~PiePresenter()
             {
                 while (m_slices.count())
                     delete m_slices.takeLast();
             }
-            void PiePresenter::handleSeriesChanged(const PieChangeSet& changeSet)
+            void PiePresenter::handleSeriesChanged(const PieChangeSet& /*changeSet*/)
             {
                 const qreal fullPie = 360;
                 qreal total = 0;
-                // calculate total
+                // calculate total and set random color if there is no color
-                foreach (QPieSlice sliceData, m_pieSeries->slices())
+                for (int i=0; i<m_pieSeries->count(); i++) {
-                    total += sliceData.m_value;
+                    QPieSlice& slice = m_pieSeries->m_slices[i];
+                    total += slice.m_value;
+                    if  (slice.m_color == QColor::Invalid) {
+                        slice.m_color.setRed(qrand() % 255);
+                        slice.m_color.setGreen(qrand() % 255);
+                        slice.m_color.setBlue(qrand() % 255);
+                    }
+                }
                 // TODO: no need to create new slices in case size changed; we should re-use the existing ones
                 while (m_slices.count())
                     delete m_slices.takeLast();
                 // create slices
                 qreal angle = 0;
                 for (int i=0; i<m_pieSeries->count(); i++) {
                     QPieSlice sliceData = m_pieSeries->slice(i);
                     qreal span = sliceData.m_value / total * fullPie;
                     PieSlice *slice = new PieSlice(this, i, angle, span);
                     m_slices.append(slice);
                     angle += span;
                 }
             }
             void PiePresenter::updateGeometry()
             {
                 prepareGeometryChange();
                 m_pieRect = m_rect;
                 if (m_pieRect.width() < m_pieRect.height()) {
                     m_pieRect.setWidth(m_pieRect.width() * m_pieSeries->sizeFactor());
                     m_pieRect.setHeight(m_pieRect.width());
                     m_pieRect.moveCenter(m_rect.center());
                 } else {
                     m_pieRect.setHeight(m_pieRect.height() * m_pieSeries->sizeFactor());
                     m_pieRect.setWidth(m_pieRect.height());
                     m_pieRect.moveCenter(m_rect.center());
                 }
                 switch (m_pieSeries->position()) {
                     case QPieSeries::PiePositionTopLeft: {
                         m_pieRect.setHeight(m_pieRect.height() / 2);
                         m_pieRect.setWidth(m_pieRect.height());
                         m_pieRect.moveCenter(QPointF(m_rect.center().x() / 2, m_rect.center().y() / 2));
                         break;
                     }
                     case QPieSeries::PiePositionTopRight: {
                         m_pieRect.setHeight(m_pieRect.height() / 2);
                         m_pieRect.setWidth(m_pieRect.height());
                         m_pieRect.moveCenter(QPointF((m_rect.center().x() / 2) * 3, m_rect.center().y() / 2));
                         break;
                     }
                     case QPieSeries::PiePositionBottomLeft: {
                         m_pieRect.setHeight(m_pieRect.height() / 2);
                         m_pieRect.setWidth(m_pieRect.height());
                         m_pieRect.moveCenter(QPointF(m_rect.center().x() / 2, (m_rect.center().y() / 2) * 3));
                         break;
                     }
                     case QPieSeries::PiePositionBottomRight: {
                         m_pieRect.setHeight(m_pieRect.height() / 2);
                         m_pieRect.setWidth(m_pieRect.height());
                         m_pieRect.moveCenter(QPointF((m_rect.center().x() / 2) * 3, (m_rect.center().y() / 2) * 3));
                         break;
                     }
                     default:
                         break;
                 }
                 qDebug() << "presentation rect:" << m_rect;
                 qDebug() << "pie rect:" << m_pieRect;
                 foreach (PieSlice *slice, m_slices)
                     slice->updateGeometry();
             }
             void PiePresenter::handleDomainChanged(const Domain& domain)
             {
                 // TODO
             }
             void PiePresenter::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect = rect;
                 updateGeometry();
             }
             #include "moc_piepresenter.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piepresenter.h +1 -1

             #ifndef PIEPRESENTER_H
             #define PIEPRESENTER_H
             #include "chartitem_p.h"
             #include "qpieseries.h"
             class QGraphicsItem;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieSlice;
             class PiePresenter : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
                 // TODO: use a generic data class instead of x and y
                 PiePresenter(QGraphicsItem *parent, QPieSeries *series);
                 ~PiePresenter();
             public: // from QGraphicsItem
                 QRectF boundingRect() const { return m_rect; }
                 void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *) {}
             public:
-                void updateGeometry();
                 QRectF pieRect() const { return m_pieRect; }
             public Q_SLOTS:
                 void handleSeriesChanged(const PieChangeSet& changeSet);
                 void handleDomainChanged(const Domain& domain);
                 void handleGeometryChanged(const QRectF& rect);
+                void updateGeometry();
             private:
                 friend class PieSlice;
                 QList<PieSlice*> m_slices;
                 QPieSeries *m_pieSeries;
                 QRectF m_rect;
                 QRectF m_pieRect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIEPRESENTER_H

src/piechart/pieslice.cpp +4 -6

             #include "pieslice.h"
             #include "piepresenter.h"
             #include "qpieseries.h"
             #include <QPainter>
             #include <QDebug>
             #include <qmath.h>
+            #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             #define PI 3.14159265
             #define EXPLODE_OFFSET 20
             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(PiePresenter *presenter, int seriesIndex, qreal startAngle, qreal span)
                 :QGraphicsItem(presenter),
                 m_label(new QGraphicsTextItem(this)),
                 m_seriesIndex(seriesIndex),
                 m_startAngle(startAngle),
                 m_span(span)
             {
                 Q_ASSERT(presenter);
                 setAcceptHoverEvents(true);
                 setAcceptedMouseButtons(Qt::LeftButton);
                 updateGeometry();
                 // TODO: use themes
                 m_pen = QPen(Qt::black);
                 m_brush = QBrush(sliceData().m_color);
             }
             PieSlice::~PieSlice()
             {
             }
             QRectF PieSlice::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath PieSlice::shape() const
             {
                 return m_path;
             }
             void PieSlice::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
             {
                 painter->setRenderHint(QPainter::Antialiasing);
                 // TODO: themes
                 painter->setPen(m_pen);
                 painter->setBrush(m_brush);
                 painter->drawPath(m_path);
                 // Draw the label
                 // TODO: do this better
                 //QTextItem text;
                 painter->drawText(m_center, sliceData().m_label);
             }
-            void PieSlice::hoverEnterEvent(QGraphicsSceneHoverEvent * event)
+            void PieSlice::hoverEnterEvent(QGraphicsSceneHoverEvent* event)
             {
-                QGraphicsItem::hoverEnterEvent(event);
                 m_brush = QBrush(sliceData().m_color.lighter());
                 update();
             }
-            void PieSlice::hoverLeaveEvent(QGraphicsSceneHoverEvent * event)
+            void PieSlice::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
-                QGraphicsItem::hoverLeaveEvent(event);
                 m_brush = QBrush(sliceData().m_color);
                 update();
             }
-            void PieSlice::mousePressEvent(QGraphicsSceneMouseEvent *event)
+            void PieSlice::mousePressEvent(QGraphicsSceneMouseEvent* /*event*/)
             {
-                QGraphicsItem::mousePressEvent(event);
                 QPieSlice data = sliceData();
                 data.m_isExploded = !data.m_isExploded;
                 (static_cast<PiePresenter*>(parentItem()))->m_pieSeries->update(m_seriesIndex, data);
             }
             void PieSlice::updateGeometry()
             {
                 prepareGeometryChange();
                 PiePresenter *presenter = static_cast<PiePresenter*>(parentItem());
                 QRectF rect = presenter->pieRect();
                 rect.adjust(EXPLODE_OFFSET, EXPLODE_OFFSET, -EXPLODE_OFFSET ,-EXPLODE_OFFSET);
                 qreal centerAngle = m_startAngle + (m_span/2);
                 if (presenter->m_pieSeries->slice(m_seriesIndex).m_isExploded) {
                     QPointF d = offset((centerAngle), EXPLODE_OFFSET);
                     rect.translate(d.x(), d.y());
                 }
                 qreal angle = (-m_startAngle) + (90);
                 qreal span = -m_span;
                 QPainterPath path;
                 path.moveTo(rect.center());
                 path.arcTo(rect, angle, span);
                 // TODO: draw the shape so that it might have a hole in the center
                 m_path = path;
                 m_rect = path.boundingRect();
                 qreal radius = rect.height() / 2;
                 m_center = rect.center() + offset(centerAngle, radius / 2);
             }
             QPieSlice PieSlice::sliceData()
             {
                 return (static_cast<PiePresenter*>(parentItem()))->m_pieSeries->slice(m_seriesIndex);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.cpp +30 -8

             #include "qpieseries.h"
             #include "piepresenter.h"
             #include "pieslice.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QPieSeries::QPieSeries(QObject *parent) :
                 QChartSeries(parent),
                 m_sizeFactor(1.0),
                 m_position(PiePositionMaximized)
             {
             }
             QPieSeries::~QPieSeries()
             {
             }
-            void QPieSeries::set(QList<QPieSlice> slices)
+            bool QPieSeries::setData(QList<qreal> data)
             {
+                QList<QPieSlice> slices;
+                foreach (int value, data)
+                    slices << QPieSlice(value, QString::number(value));
+                return set(slices);
+            }
+            bool QPieSeries::set(QList<QPieSlice> slices)
+            {
+                if (!slices.count())
+                    return false;
                 PieChangeSet changeSet;
                 for (int i=slices.count(); i<m_slices.count(); i++)
                     changeSet.m_removed << i;
                 for (int i=0; i<slices.count(); i++) {
                     if (i < m_slices.count())
                         changeSet.m_changed << i;
                     else
                         changeSet.m_added << i;
                 }
                 m_slices = slices;
                 emit changed(changeSet);
+                return true;
             }
-            void QPieSeries::add(QList<QPieSlice> slices)
+            bool QPieSeries::add(QList<QPieSlice> slices)
             {
+                if (!slices.count())
+                    return false;
                 PieChangeSet changeSet;
                 for (int i=0; i<slices.count(); i++)
                     changeSet.m_added << m_slices.count() + i;
                 m_slices += slices;
                 emit changed(changeSet);
+                return true;
             }
-            void QPieSeries::add(QPieSlice slice)
+            bool QPieSeries::add(QPieSlice slice)
             {
-                add(QList<QPieSlice>() << slice);
+                return add(QList<QPieSlice>() << slice);
             }
             QPieSlice QPieSeries::slice(int index) const
             {
                 if ((index >= 0) && (index < m_slices.count()))
                     return m_slices.at(index);
                 return QPieSlice();
             }
             bool QPieSeries::update(int index, QPieSlice slice)
             {
                 if ((index >= 0) && (index < m_slices.count())) {
                     m_slices[index] = slice;
                     PieChangeSet changeSet;
                     changeSet.m_changed << index;
                     emit changed(changeSet);
                     return true;
                 }
                 return false;
             }
             void QPieSeries::setSizeFactor(qreal factor)
             {
-                if (factor > 0.0)
+                if (factor < 0.0)
+                    return;
+                if (m_sizeFactor != factor) {
                     m_sizeFactor = factor;
-                emit sizeFactorChanged();
+                    emit sizeFactorChanged();
+                }
             }
             void QPieSeries::setPosition(PiePosition position)
             {
-                m_position = position;
+                if (m_position != position) {
-                emit positionChanged();
+                    m_position = position;
+                    emit positionChanged();
+                }
             }
             #include "moc_qpieseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.h +8 -6

             #ifndef PIESERIES_H
             #define PIESERIES_H
             #include "qchartseries.h"
             #include <QObject>
             #include <QRectF>
             #include <QColor>
             class QGraphicsObject;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PiePresenter;
             class PieSlice;
             class QPieSlice
             {
             public:
                 QPieSlice()
-                    :m_value(0), m_label("<empty>"), m_color(Qt::white), m_isExploded(false) {}
+                    :m_value(0), m_label("<empty>"), m_color(QColor::Invalid), m_isExploded(false) {}
-                QPieSlice(qreal value, QString label, QColor color, bool exploded = false)
+                QPieSlice(qreal value, QString label = "<empty>", QColor color = QColor::Invalid, bool exploded = false)
                     :m_value(value), m_label(label), m_color(color), m_isExploded(exploded) {}
             public:
                 qreal m_value;
                 QString m_label;
-                QColor m_color;
+                QColor m_color; // TODO: should we even define color here?
                 bool m_isExploded;
             };
             class PieChangeSet
             {
             public:
                 QList<int> m_added;
                 QList<int> m_removed;
                 QList<int> m_changed;
             };
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
                 enum PiePosition {
                     PiePositionMaximized = 0,
                     PiePositionTopLeft,
                     PiePositionTopRight,
                     PiePositionBottomLeft,
                     PiePositionBottomRight
                 };
             public:
                 QPieSeries(QObject *parent = 0);
                 ~QPieSeries();
             public: // from QChartSeries
                 QChartSeriesType type() const { return QChartSeries::SeriesTypePie; }
+                virtual bool setData(QList<qreal> data);
             public:
-                void set(QList<QPieSlice> slices);
+                bool set(QList<QPieSlice> slices);
-                void add(QList<QPieSlice> slices);
+                bool add(QList<QPieSlice> slices);
-                void add(QPieSlice slice);
+                bool add(QPieSlice slice);
                 int count() const { return m_slices.count(); }
                 QList<QPieSlice> slices() const { return m_slices; }
                 QPieSlice slice(int index) const;
                 bool update(int index, QPieSlice slice);
                 // TODO: convenience functions
                 //void updateValue(int sliceIndex, qreal value);
                 //void updateLabel(int sliceIndex, QString label);
                 //void updateColor(int sliceIndex, QColor color);
                 //void updateExploded(int slizeIndex, bool exploded);
                 void setSizeFactor(qreal sizeFactor);
                 qreal sizeFactor() const { return m_sizeFactor; }
                 void setPosition(PiePosition position);
                 PiePosition position() const { return m_position; }
             Q_SIGNALS:
                 void changed(const PieChangeSet& changeSet);
                 void sizeFactorChanged();
                 void positionChanged();
             private:
                 Q_DISABLE_COPY(QPieSeries)
+                friend class PiePresenter;
                 // TODO: use PIML
                 QList<QPieSlice> m_slices;
                 qreal m_sizeFactor;
                 PiePosition m_position;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_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