HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r659:7d415c8db783

Fix add/remove animation for pie and apply colors from theme when adding/removing

Jani Honkonen -

r659:7d415c8db783

parent child

Context file:

r659:7d415c8db783

Collapse all files

src/animations/piesliceanimation.cpp +35 -5

             #include "piesliceanimation_p.h"
             #include "piechartitem_p.h"
             #include "qpieslice.h"
             Q_DECLARE_METATYPE(QtCommercialChart::PieSliceLayout)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             qreal linearPos(qreal start, qreal end, qreal pos)
             {
                 return start + ((end - start) * pos);
             }
             QPointF linearPos(QPointF start, QPointF end, qreal pos)
             {
                 qreal x = linearPos(start.x(), end.x(), pos);
                 qreal y = linearPos(start.y(), end.y(), pos);
                 return QPointF(x, y);
             }
+            QPen linearPos(QPen start, QPen end, qreal pos)
+            {
+                QColor c;
+                c.setRedF(linearPos(start.color().redF(), end.color().redF(), pos));
+                c.setGreenF(linearPos(start.color().greenF(), end.color().greenF(), pos));
+                c.setBlueF(linearPos(start.color().blueF(), end.color().blueF(), pos));
+                end.setColor(c);
+                return end;
+            }
+            QBrush linearPos(QBrush start, QBrush end, qreal pos)
+            {
+                QColor c;
+                c.setRedF(linearPos(start.color().redF(), end.color().redF(), pos));
+                c.setGreenF(linearPos(start.color().greenF(), end.color().greenF(), pos));
+                c.setBlueF(linearPos(start.color().blueF(), end.color().blueF(), pos));
+                end.setColor(c);
+                return end;
+            }
             PieSliceAnimation::PieSliceAnimation(PieChartItem *item, QPieSlice *slice)
                 :QVariantAnimation(item),
                 m_item(item),
                 m_slice(slice)
             {
             }
             PieSliceAnimation::~PieSliceAnimation()
             {
             }
             void PieSliceAnimation::setValue(const PieSliceLayout &startValue, const PieSliceLayout &endValue)
             {
                 if (state() != QAbstractAnimation::Stopped)
                     stop();
+                m_currentValue = startValue;
                 setKeyValueAt(0.0, qVariantFromValue(startValue));
                 setKeyValueAt(1.0, qVariantFromValue(endValue));
             }
             void PieSliceAnimation::updateValue(const PieSliceLayout &endValue)
             {
                 if (state() != QAbstractAnimation::Stopped)
                     stop();
-                setKeyValueAt(0.0, qVariantFromValue(currentSliceValue()));
+                setKeyValueAt(0.0, qVariantFromValue(m_currentValue));
                 setKeyValueAt(1.0, qVariantFromValue(endValue));
             }
             PieSliceLayout PieSliceAnimation::currentSliceValue()
             {
-                return qVariantValue<PieSliceLayout>(currentValue());
+                // NOTE:
+                // We must use an internal current value because QVariantAnimation::currentValue() is updated
+                // before the animation is actually started. So if we get 2 updateValue() calls in a row the currentValue()
+                // will have the end value set from the first call and the second call will interpolate that instead of
+                // the original current value as it was before the first call.
+                return m_currentValue;
             }
             QVariant PieSliceAnimation::interpolated(const QVariant &start, const QVariant &end, qreal progress) const
             {
                 PieSliceLayout startValue = qVariantValue<PieSliceLayout>(start);
                 PieSliceLayout endValue = qVariantValue<PieSliceLayout>(end);
                 PieSliceLayout result;
                 result = endValue;
                 result.m_center = linearPos(startValue.m_center, endValue.m_center, progress);
                 result.m_radius = linearPos(startValue.m_radius, endValue.m_radius, progress);
                 result.m_startAngle = linearPos(startValue.m_startAngle, endValue.m_startAngle, progress);
                 result.m_angleSpan = linearPos(startValue.m_angleSpan, endValue.m_angleSpan, progress);
+                result.m_pen = linearPos(startValue.m_pen, endValue.m_pen, progress);
+                result.m_brush = linearPos(startValue.m_brush, endValue.m_brush, progress);
                 return qVariantFromValue(result);
             }
             void PieSliceAnimation::updateCurrentValue(const QVariant &value)
             {
-                PieSliceLayout layout = qVariantValue<PieSliceLayout>(value);
+                if (state() != QAbstractAnimation::Stopped) { //workaround
-                if (state() != QAbstractAnimation::Stopped) //workaround
+                    m_currentValue = qVariantValue<PieSliceLayout>(value);
-                    m_item->setLayout(m_slice, layout);
+                    m_item->setLayout(m_slice, m_currentValue);
+                }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/piesliceanimation_p.h +1 0

             #ifndef PIESLICEANIMATION_P_H_
             #define PIESLICEANIMATION_P_H_
             #include "piechartitem_p.h"
             #include <QVariantAnimation>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieChartItem;
             class QPieSlice;
             class PieSliceAnimation : public QVariantAnimation
             {
             public:
                 PieSliceAnimation(PieChartItem *item, QPieSlice *slice);
                 ~PieSliceAnimation();
                 void setValue(const PieSliceLayout &startValue, const PieSliceLayout &endValue);
                 void updateValue(const PieSliceLayout &endValue);
                 PieSliceLayout currentSliceValue();
             protected:
                 QVariant interpolated(const QVariant &start, const QVariant &end, qreal progress) const;
                 void updateCurrentValue(const QVariant &value);
             private:
                 PieChartItem *m_item;
                 QPieSlice *m_slice;
+                PieSliceLayout m_currentValue;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/chartpresenter.cpp +1 -1

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             //series
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "areachartitem_p.h"
             #include "barpresenter_p.h"
             #include "stackedbarpresenter_p.h"
             #include "percentbarpresenter_p.h"
             #include "linechartitem_p.h"
             #include "piechartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "splinechartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
                 m_chart(chart),
                 m_animator(0),
                 m_dataset(dataset),
                 m_chartTheme(0),
                 m_zoomIndex(0),
                 m_rect(QRectF(QPoint(0,0),m_chart->size())),
                 m_options(QChart::NoAnimation),
                 m_themeForce(false)
             {
                 createConnections();
                 setChartTheme(QChart::ChartThemeDefault,false);
             }
             ChartPresenter::~ChartPresenter()
             {
             	delete m_chartTheme;
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),this,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),this,SLOT(handleSeriesRemoved(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*,Domain*)),this,SLOT(handleAxisAdded(QChartAxis*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 QRectF rect(QPoint(0,0),m_chart->size());
                 rect.adjust(m_chart->padding(),m_chart->padding(), -m_chart->padding(), -m_chart->padding());
                 //rewrite zoom stack
                 for(int i=0;i<m_zoomStack.count();i++){
                     QRectF r = m_zoomStack[i];
                     qreal w = rect.width()/m_rect.width();
                     qreal h = rect.height()/m_rect.height();
                     QPointF tl = r.topLeft();
                     tl.setX(tl.x()*w);
                     tl.setY(tl.y()*h);
                     QPointF br = r.bottomRight();
                     br.setX(br.x()*w);
                     br.setY(br.y()*h);
                     r.setTopLeft(tl);
                     r.setBottomRight(br);
                     m_zoomStack[i]=r;
                 }
                 m_rect = rect;
                 Q_ASSERT(m_rect.isValid());
                 emit geometryChanged(m_rect);
             }
             void ChartPresenter::handleAxisAdded(QChartAxis* axis,Domain* domain)
             {
                 AxisItem* item = new AxisItem(axis,this,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
                     m_animator->addAnimation(item);
                 }
                 if(axis==m_dataset->axisX()){
                     m_chartTheme->decorate(axis,true,m_themeForce);
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minX(),domain->maxX(),domain->tickXCount());
                 }
                 else{
                     m_chartTheme->decorate(axis,false,m_themeForce);
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY(),domain->tickYCount());
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                 //initialize
                 item->handleGeometryChanged(m_rect);
                 m_axisItems.insert(axis, item);
             }
             void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
             {
                 AxisItem* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 if(m_animator) m_animator->removeAnimation(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain)
             {
             	ChartItem *item = 0 ;
                 switch(series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                     LineChartItem* line = new LineChartItem(lineSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                     	m_animator->addAnimation(line);
                     }
                     m_chartTheme->decorate(lineSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),line,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),line,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item = line;
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
                     QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                     AreaChartItem* area = new AreaChartItem(areaSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(area->upperLineItem());
                         if(areaSeries->lowerSeries())  m_animator->addAnimation(area->lowerLineItem());
                     }
                     m_chartTheme->decorate(areaSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),area,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),area,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=area;
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     BarPresenter* bar = new BarPresenter(barSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                      //  m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(barSeries, m_dataset->seriesIndex(barSeries),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
                     QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                     StackedBarPresenter* bar = new StackedBarPresenter(stackedBarSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                      //  m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(stackedBarSeries, m_dataset->seriesIndex(stackedBarSeries),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
                     QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                     PercentBarPresenter* bar = new PercentBarPresenter(percentBarSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                      //  m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(percentBarSeries, m_dataset->seriesIndex(percentBarSeries),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
                 	QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
                         ScatterChartItem *scatter = new ScatterChartItem(scatterSeries, m_chart);
                         if(m_options.testFlag(QChart::SeriesAnimations)) {
                             m_animator->addAnimation(scatter);
                         }
                         m_chartTheme->decorate(scatterSeries, m_dataset->seriesIndex(series),m_themeForce);
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),scatter,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),scatter,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                         item = scatter;
                         break;
             	}
                 case QSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
-                    PieChartItem* pie = new PieChartItem(m_chart, pieSeries);
+                    PieChartItem* pie = new PieChartItem(pieSeries, this, m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(pie);
                     }
                     m_chartTheme->decorate(pieSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),pie,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),pie,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     // 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()->hide();
                         m_chart->axisY()->hide();
                     }
                     item=pie;
                     break;
                 }
                 case QSeries::SeriesTypeSpline: {
                     QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
                     SplineChartItem* spline  = new SplineChartItem(splineSeries, m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(spline);
                     }
                     m_chartTheme->decorate(splineSeries, m_dataset->seriesIndex(series),m_themeForce);
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),spline,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),spline,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=spline;
                     break;
                 }
                 default: {
                     qDebug()<< "Series type" << series->type() << "not implemented.";
                     break;
                 }
                 }
                 //initialize
                 item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                 m_chartItems.insert(series,item);
                 zoomReset();
             }
             void ChartPresenter::handleSeriesRemoved(QSeries* series)
             {
                 ChartItem* item = m_chartItems.take(series);
                 Q_ASSERT(item);
                 if(m_animator) {
                     //small hack to handle area animations
                     if(series->type()==QSeries::SeriesTypeArea){
                          QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                          AreaChartItem* area = static_cast<AreaChartItem*>(item);
                          m_animator->removeAnimation(area->upperLineItem());
                          if(areaSeries->lowerSeries())  m_animator->removeAnimation(area->lowerLineItem());
                     }else
                     m_animator->removeAnimation(item);
                 }
                 delete item;
             }
             void ChartPresenter::setChartTheme(QChart::ChartTheme theme,bool force)
             {
             	if(m_chartTheme && m_chartTheme->id() == theme) return;
                 delete m_chartTheme;
                 m_themeForce = force;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart,m_themeForce);
                 m_chartTheme->decorate(m_chart->legend(),m_themeForce);
                 resetAllElements();
             }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     if(m_options!=QChart::NoAnimation && !m_animator) {
                         m_animator= new ChartAnimator(this);
                     }
                     resetAllElements();
                 }
             }
             void ChartPresenter::resetAllElements()
             {
                  QList<QChartAxis*> axisList = m_axisItems.uniqueKeys();
                  QList<QSeries*> seriesList = m_chartItems.uniqueKeys();
                  foreach(QChartAxis* axis, axisList) {
                      handleAxisRemoved(axis);
                      handleAxisAdded(axis,m_dataset->domain(axis));
                  }
                  foreach(QSeries* series, seriesList) {
                      handleSeriesRemoved(series);
                      handleSeriesAdded(series,m_dataset->domain(series));
                  }
             }
             void ChartPresenter::zoomIn()
             {
             	QRectF rect = geometry();
             	rect.setWidth(rect.width()/2);
             	rect.setHeight(rect.height()/2);
             	rect.moveCenter(geometry().center());
             	zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
             	QRectF r = rect.normalized();
             	r.translate(-m_chart->padding(), -m_chart->padding());
             	if(m_animator) {
             		QPointF point(r.center().x()/geometry().width(),r.center().y()/geometry().height());
             		m_animator->setState(ChartAnimator::ZoomInState,point);
             	}
             	m_dataset->zoomInDomain(r,geometry().size());
             	m_zoomStack<<r;
             	m_zoomIndex++;
             	if(m_animator) {
             		m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             void ChartPresenter::zoomOut()
             {
             	if(m_zoomIndex==0) return;
             	if(m_animator)
             	{
             		m_animator->setState(ChartAnimator::ZoomOutState);
             	}
             	m_dataset->zoomOutDomain(m_zoomStack[m_zoomIndex-1],geometry().size());
             	m_zoomIndex--;
             	m_zoomStack.resize(m_zoomIndex);
             	if(m_animator){
             			m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             void ChartPresenter::zoomReset()
             {
                 m_zoomIndex=0;
                 m_zoomStack.resize(m_zoomIndex);
             }
             void ChartPresenter::scroll(int dx,int dy)
             {
             	if(m_animator){
             		if(dx<0) m_animator->setState(ChartAnimator::ScrollLeftState,QPointF());
             		if(dx>0) m_animator->setState(ChartAnimator::ScrollRightState,QPointF());
             		if(dy<0) m_animator->setState(ChartAnimator::ScrollUpState,QPointF());
             		if(dy>0) m_animator->setState(ChartAnimator::ScrollDownState,QPointF());
             	}
             	m_dataset->scrollDomain(dx,dy,geometry().size());
                 if(m_animator){
             		m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +5 -1

             #ifndef CHARTPRESENTER_H_
             #define CHARTPRESENTER_H_
             #include "qchartglobal.h"
             #include "qchart.h" //becouse of QChart::ChartThemeId //TODO
             #include "qchartaxis.h"
             #include <QRectF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class QSeries;
             class ChartDataSet;
             class Domain;
             class AxisItem;
             class ChartTheme;
             class ChartAnimator;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
                     ShadesZValue,
                     GridZValue,
                     AxisZValue,
                     LineChartZValue,
                     BarSeriesZValue,
                     ScatterSeriesZValue,
                     PieSeriesZValue,
                     LegendZValue
                 };
                 ChartPresenter(QChart* chart,ChartDataSet *dataset);
                 virtual ~ChartPresenter();
                 void setMargin(int margin);
                 int margin() const;
                 QRectF geometry() const;
-                ChartAnimator* animator() const {return m_animator;};
+                ChartAnimator* animator() const {return m_animator;}
+                ChartTheme *theme() { return m_chartTheme; }
+                ChartDataSet *dataSet() { return m_dataset; }
                 void setChartTheme(QChart::ChartTheme theme,bool force = true);
                 QChart::ChartTheme chartTheme();
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 void zoomIn();
                 void zoomIn(const QRectF& rect);
                 void zoomOut();
                 void zoomReset();
                 void scroll(int dx,int dy);
             private:
                 void createConnections();
                 void resetAllElements();
             public slots:
                 void handleSeriesAdded(QSeries* series,Domain* domain);
                 void handleSeriesRemoved(QSeries* series);
                 void handleAxisAdded(QChartAxis* axis,Domain* domain);
                 void handleAxisRemoved(QChartAxis* axis);
                 void handleGeometryChanged();
             signals:
                 void geometryChanged(const QRectF& rect);
             private:
                 QChart* m_chart;
                 ChartAnimator* m_animator;
                 ChartDataSet* m_dataset;
                 ChartTheme *m_chartTheme;
                 int m_zoomIndex;
                 QMap<QSeries*,ChartItem*> m_chartItems;
                 QMap<QChartAxis*,AxisItem*> m_axisItems;
                 QVector<QRectF> m_zoomStack;
                 QRectF m_rect;
                 QChart::AnimationOptions m_options;
                 bool m_themeForce;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H_ */

src/piechart/piechartitem.cpp +10 -2

             #include "piechartitem_p.h"
             #include "pieslice_p.h"
             #include "qpieslice.h"
             #include "qpieseries.h"
             #include "chartpresenter_p.h"
+            #include "chartdataset_p.h"
             #include "chartanimator_p.h"
             #include <QDebug>
             #include <QPainter>
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            PieChartItem::PieChartItem(QGraphicsItem *parent, QPieSeries *series)
+            PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter *presenter, QGraphicsItem *parent)
                 :ChartItem(parent),
-                m_series(series)
+                m_series(series),
+                m_presenter(presenter)
             {
                 Q_ASSERT(series);
                 connect(series, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleSlicesAdded(QList<QPieSlice*>)));
                 connect(series, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleSlicesRemoved(QList<QPieSlice*>)));
                 connect(series, SIGNAL(piePositionChanged()), this, SLOT(handlePieLayoutChanged()));
                 connect(series, SIGNAL(pieSizeChanged()), this, SLOT(handlePieLayoutChanged()));
                 QTimer::singleShot(0, this, SLOT(initialize()));
                 // Note: the following does not affect as long as the item does not have anything to paint
                 setZValue(ChartPresenter::PieSeriesZValue);
             }
             PieChartItem::~PieChartItem()
             {
                 // slices deleted automatically through QGraphicsItem
             }
             void PieChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
             {
                 Q_UNUSED(painter)
                 // TODO: paint shadows for all components
                 // - get paths from items & merge & offset and draw with shadow color?
                 //painter->setBrush(QBrush(Qt::red));
                 //painter->drawRect(m_debugRect);
             }
             void PieChartItem::initialize()
             {
                 handleSlicesAdded(m_series->m_slices);
             }
             void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices)
             {
                 bool isEmpty = m_slices.isEmpty();
+                m_presenter->theme()->decorate(m_series, m_presenter->dataSet()->seriesIndex(m_series));
                 foreach (QPieSlice *s, slices) {
                     PieSlice* slice = new PieSlice(this);
                     m_slices.insert(s, slice);
                     connect(s, SIGNAL(changed()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(clicked()), s, SIGNAL(clicked()));
                     connect(slice, SIGNAL(hoverEnter()), s, SIGNAL(hoverEnter()));
                     connect(slice, SIGNAL(hoverLeave()), s, SIGNAL(hoverLeave()));
                     PieSliceLayout layout = calculateSliceLayout(s);
                     if (m_animator)
                         m_animator->addAnimation(this, s, layout, isEmpty);
                     else
                         setLayout(s, layout);
                 }
             }
             void PieChartItem::handleSlicesRemoved(QList<QPieSlice*> slices)
             {
+                m_presenter->theme()->decorate(m_series, m_presenter->dataSet()->seriesIndex(m_series));
                 foreach (QPieSlice *s, slices) {
                     if (m_animator)
                         m_animator->removeAnimation(this, s);
                     else
                         destroySlice(s);
                 }
             }
             void PieChartItem::handlePieLayoutChanged()
             {
                 PieLayout layout = calculateLayout();
                 applyLayout(layout);
                 update();
             }
             void PieChartItem::handleSliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 PieSliceLayout layout = calculateSliceLayout(slice);
                 updateLayout(slice, layout);
                 update();
             }
             void PieChartItem::handleDomainChanged(qreal, qreal, qreal, qreal)
             {
                 // TODO
             }
             void PieChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 handlePieLayoutChanged();
             }
             void PieChartItem::calculatePieLayout()
             {
                 // find pie center coordinates
                 m_pieCenter.setX(m_rect.left() + (m_rect.width() * m_series->pieHorizontalPosition()));
                 m_pieCenter.setY(m_rect.top() + (m_rect.height() * m_series->pieVerticalPosition()));
                 // find maximum radius for pie
                 m_pieRadius = m_rect.height() / 2;
                 if (m_rect.width() < m_rect.height())
                     m_pieRadius = m_rect.width() / 2;
                 // apply size factor
                 m_pieRadius *= m_series->pieSize();
             }
             PieSliceLayout PieChartItem::calculateSliceLayout(QPieSlice *slice)
             {
                 PieSliceLayout sliceLayout;
                 sliceLayout.m_center = PieSlice::sliceCenter(m_pieCenter, m_pieRadius, slice);
                 sliceLayout.m_radius = m_pieRadius;
                 sliceLayout.m_startAngle = slice->startAngle();
                 sliceLayout.m_angleSpan = slice->m_angleSpan;
+                sliceLayout.m_pen = slice->m_slicePen;
+                sliceLayout.m_brush = slice->m_sliceBrush;
                 return sliceLayout;
             }
             PieLayout PieChartItem::calculateLayout()
             {
                 calculatePieLayout();
                 PieLayout  layout;
                 foreach (QPieSlice* s, m_series->slices()) {
                     if (m_slices.contains(s)) // calculate layout only for those slices that are already visible
                         layout.insert(s, calculateSliceLayout(s));
                 }
                 return layout;
             }
             void PieChartItem::applyLayout(const PieLayout &layout)
             {
                 if (m_animator)
                     m_animator->updateLayout(this, layout);
                 else
                     setLayout(layout);
             }
             void PieChartItem::updateLayout(QPieSlice *slice, const PieSliceLayout &layout)
             {
                 if (m_animator)
                     m_animator->updateLayout(this, slice, layout);
                 else
                     setLayout(slice, layout);
             }
             void PieChartItem::setLayout(const PieLayout &layout)
             {
                 foreach (QPieSlice *slice, layout.keys()) {
                     PieSlice *s = m_slices.value(slice);
                     Q_ASSERT(s);
                     s->setLayout(layout.value(slice));
                     s->updateData(slice);
                     s->updateGeometry();
                     s->update();
                 }
             }
             void PieChartItem::setLayout(QPieSlice *slice, const PieSliceLayout &layout)
             {
                 // find slice
                 PieSlice *s = m_slices.value(slice);
                 Q_ASSERT(s);
                 s->setLayout(layout);
                 if (m_series->m_slices.contains(slice)) // Slice has been deleted if not found. Animations ongoing...
                     s->updateData(slice);
                 s->updateGeometry();
                 s->update();
             }
             void PieChartItem::destroySlice(QPieSlice *slice)
             {
                 delete m_slices.take(slice);
             }
             #include "moc_piechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piechartitem_p.h +3 -2

             #ifndef PIECHARTITEM_H
             #define PIECHARTITEM_H
             #include "qpieseries.h"
             #include "chartitem_p.h"
             #include "pieslice_p.h"
             class QGraphicsItem;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSlice;
+            class ChartPresenter;
             typedef QHash<QPieSlice*, PieSliceLayout> PieLayout;
             class PieChartItem : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
                 // TODO: use a generic data class instead of x and y
-                PieChartItem(QGraphicsItem *parent, QPieSeries *series);
+                PieChartItem(QPieSeries *series, ChartPresenter *presenter, QGraphicsItem *parent);
                 ~PieChartItem();
             public: // from QGraphicsItem
                 QRectF boundingRect() const { return m_rect; }
                 void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *);
             public Q_SLOTS:
                 void initialize();
                 void handleSlicesAdded(QList<QPieSlice*> slices);
                 void handleSlicesRemoved(QList<QPieSlice*> slices);
                 void handlePieLayoutChanged();
                 void handleSliceChanged();
                 void handleDomainChanged(qreal, qreal, qreal, qreal);
                 void handleGeometryChanged(const QRectF& rect);
             public:
                 void calculatePieLayout();
                 PieSliceLayout calculateSliceLayout(QPieSlice *slice);
                 PieLayout calculateLayout();
                 void applyLayout(const PieLayout &layout);
                 void updateLayout(QPieSlice *slice, const PieSliceLayout &layout);
                 void setLayout(const PieLayout &layout);
                 void setLayout(QPieSlice *slice, const PieSliceLayout &layout);
                 void destroySlice(QPieSlice *slice);
             private:
                 friend class PieSlice;
                 QHash<QPieSlice*, PieSlice*> m_slices;
                 QPieSeries *m_series;
                 QRectF m_rect;
                 QPointF m_pieCenter;
                 qreal m_pieRadius;
-                QRectF m_debugRect;
+                ChartPresenter *m_presenter;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIECHARTITEM_H

src/piechart/pieslice.cpp +2 -4

             #include "pieslice_p.h"
             #include "piechartitem_p.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QDebug>
             #include <qmath.h>
             #include <QGraphicsSceneEvent>
             #include <QTime>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             #define PI 3.14159265 // TODO: is this defined in some header?
             QPointF offset(qreal angle, qreal length)
             {
                 qreal dx = qSin(angle*(PI/180)) * length;
                 qreal dy = qCos(angle*(PI/180)) * length;
                 return QPointF(dx, -dy);
             }
             PieSlice::PieSlice(QGraphicsItem* parent)
                 :QGraphicsObject(parent),
                 m_isExploded(false),
                 m_explodeDistanceFactor(0),
                 m_labelVisible(false),
                 m_labelArmLengthFactor(0)
             {
                 setAcceptHoverEvents(true);
                 setAcceptedMouseButtons(Qt::LeftButton);
                 setZValue(ChartPresenter::PieSeriesZValue);
             }
             PieSlice::~PieSlice()
             {
             }
             QRectF PieSlice::boundingRect() const
             {
                 return m_boundingRect;
             }
             QPainterPath PieSlice::shape() const
             {
                 // Don't include the label and label arm.
                 // This is used to detect a mouse clicks. We do not want clicks from label.
                 return m_slicePath;
             }
             void PieSlice::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
             {
                 painter->setClipRect(parentItem()->boundingRect());
                 painter->save();
-                painter->setPen(m_slicePen);
+                painter->setPen(m_layout.m_pen);
-                painter->setBrush(m_sliceBrush);
+                painter->setBrush(m_layout.m_brush);
                 painter->drawPath(m_slicePath);
                 painter->restore();
                 if (m_labelVisible) {
                     painter->save();
                     painter->setPen(m_labelArmPen);
                     painter->drawPath(m_labelArmPath);
                     painter->restore();
                     painter->setFont(m_labelFont);
                     painter->drawText(m_labelTextRect.bottomLeft(), m_labelText);
                 }
             }
             void PieSlice::hoverEnterEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverEnter();
             }
             void PieSlice::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverLeave();
             }
             void PieSlice::mousePressEvent(QGraphicsSceneMouseEvent* /*event*/)
             {
                 emit clicked();
             }
             void PieSlice::setLayout(PieSliceLayout layout)
             {
                 m_layout = layout;
             }
             void PieSlice::updateGeometry()
             {
                 if (m_layout.m_radius <= 0)
                     return;
                 prepareGeometryChange();
                 // update slice path
                 qreal centerAngle;
                 QPointF armStart;
                 m_slicePath = slicePath(m_layout.m_center, m_layout.m_radius, m_layout.m_startAngle, m_layout.m_angleSpan, &centerAngle, &armStart);
                 // update text rect
                 m_labelTextRect = labelTextRect(m_labelFont, m_labelText);
                 // update label arm path
                 QPointF labelTextStart;
                 m_labelArmPath = labelArmPath(armStart, centerAngle, m_layout.m_radius * m_labelArmLengthFactor, m_labelTextRect.width(), &labelTextStart);
                 // update text position
                 m_labelTextRect.moveBottomLeft(labelTextStart);
                 // update bounding rect
                 m_boundingRect = m_slicePath.boundingRect().united(m_labelArmPath.boundingRect()).united(m_labelTextRect);
             }
             void PieSlice::updateData(const QPieSlice* sliceData)
             {
                 // TODO: compare what has changes to avoid unneccesary geometry updates
                 m_isExploded = sliceData->isExploded();
                 m_explodeDistanceFactor = sliceData->explodeDistanceFactor();
-                m_slicePen = sliceData->slicePen();
-                m_sliceBrush = sliceData->sliceBrush();
                 m_labelVisible = sliceData->isLabelVisible();
                 m_labelText = sliceData->label();
                 m_labelFont = sliceData->labelFont();
                 m_labelArmLengthFactor = sliceData->labelArmLengthFactor();
                 m_labelArmPen = sliceData->labelArmPen();
             }
             QPointF PieSlice::sliceCenter(QPointF point, qreal radius, QPieSlice *slice)
             {
                 if (slice->isExploded()) {
                     qreal centerAngle = slice->startAngle() + (slice->m_angleSpan/2);
                     qreal len = radius * slice->explodeDistanceFactor();
                     qreal dx = qSin(centerAngle*(PI/180)) * len;
                     qreal dy = -qCos(centerAngle*(PI/180)) * len;
                     point += QPointF(dx, dy);
                 }
                 return point;
             }
             QPainterPath PieSlice::slicePath(QPointF center, qreal radius, qreal startAngle, qreal angleSpan, qreal* centerAngle, QPointF* armStart)
             {
                 // calculate center angle
                 *centerAngle = startAngle + (angleSpan/2);
                 // calculate slice rectangle
                 QRectF rect(center.x()-radius, center.y()-radius, radius*2, radius*2);
                 // slice path
                 // TODO: draw the shape so that it might have a hole in the center
                 QPainterPath path;
                 path.moveTo(rect.center());
                 path.arcTo(rect, -startAngle + 90, -angleSpan);
                 path.closeSubpath();
                 // calculate label arm start point
                 *armStart = center;
                 *armStart += offset(*centerAngle, radius + PIESLICE_LABEL_GAP);
                 return path;
             }
             QPainterPath PieSlice::labelArmPath(QPointF start, qreal angle, qreal length, qreal textWidth, QPointF* textStart)
             {
                 qreal dx = qSin(angle*(PI/180)) * length;
                 qreal dy = -qCos(angle*(PI/180)) * length;
                 QPointF parm1 = start + QPointF(dx, dy);
                 QPointF parm2 = parm1;
                 if (angle < 180) { // arm swings the other way on the left side
                      parm2 += QPointF(textWidth, 0);
                      *textStart = parm1;
                 }
                 else {
                      parm2 += QPointF(-textWidth,0);
                      *textStart = parm2;
                 }
                 // elevate the text position a bit so that it does not hit the line
                 *textStart += QPointF(0, -5);
                 QPainterPath path;
                 path.moveTo(start);
                 path.lineTo(parm1);
                 path.lineTo(parm2);
                 return path;
             }
             QRectF PieSlice::labelTextRect(QFont font, QString text)
             {
                 QFontMetricsF fm(font);
                 return fm.boundingRect(text);
             }
             #include "moc_pieslice_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslice_p.h +2 -2

             #ifndef PIESLICE_H
             #define PIESLICE_H
             #include "qchartglobal.h"
             #include "charttheme_p.h"
             #include "qpieseries.h"
             #include <QGraphicsItem>
             #include <QRectF>
             #include <QColor>
             #include <QPen>
             #define PIESLICE_LABEL_GAP 5
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieChartItem;
             class PieSliceLabel;
             class QPieSlice;
             class PieSliceLayout
             {
             public:
                 QPointF m_center;
                 qreal m_radius;
                 qreal m_startAngle;
                 qreal m_angleSpan;
+                QPen m_pen;
+                QBrush m_brush;
             };
             class PieSlice : public QGraphicsObject
             {
                 Q_OBJECT
             public:
                 PieSlice(QGraphicsItem* parent = 0);
                 ~PieSlice();
             public: // from QGraphicsItem
                 QRectF boundingRect() const;
                 QPainterPath shape() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
                 void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
             Q_SIGNALS:
                 void clicked();
                 void hoverEnter();
                 void hoverLeave();
             public:
                 void setLayout(PieSliceLayout layout);
                 void updateGeometry();
                 void updateData(const QPieSlice *sliceData);
                 static QPointF sliceCenter(QPointF point, qreal radius, QPieSlice *slice);
                 static QPainterPath slicePath(QPointF center, qreal radius, qreal startAngle, qreal angleSpan, qreal* centerAngle, QPointF* armStart);
                 static QPainterPath labelArmPath(QPointF start, qreal angle, qreal length, qreal textWidth, QPointF* textStart);
                 static QRectF labelTextRect(QFont font, QString text);
             private:
                 PieSliceLayout m_layout;
                 QRectF m_boundingRect;
                 QPainterPath m_slicePath;
                 bool m_isExploded;
                 qreal m_explodeDistanceFactor;
                 bool m_labelVisible;
-                QPen m_slicePen;
-                QBrush m_sliceBrush;
                 QPainterPath m_labelArmPath;
                 qreal m_labelArmLengthFactor;
                 QPen m_labelArmPen;
                 QRectF m_labelTextRect;
                 QFont m_labelFont;
                 QString m_labelText;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESLICE_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