HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r629:54034d98d5c4

Getting rid of slice pointer in PieSliceLayout.

Jani Honkonen -

r629:54034d98d5c4

parent child

Context file:

r629:54034d98d5c4

Collapse all files

src/animations/chartanimator.cpp +4 -4

             #include "chartanimator_p.h"
             #include "axisanimation_p.h"
             #include "xyanimation_p.h"
             #include "splineanimation_p.h"
             #include "xychartitem_p.h"
             #include "pieanimation_p.h"
             #include "areachartitem_p.h"
             #include "splinechartitem_p.h"
             #include "scatterchartitem_p.h"
             #include <QTimer>
             Q_DECLARE_METATYPE(QVector<QPointF>)
             Q_DECLARE_METATYPE(QVector<qreal>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             const static int duration = 1000;
             ChartAnimator::ChartAnimator(QObject *parent):QObject(parent)
             {
             }
             ChartAnimator::~ChartAnimator()
             {
             }
             void ChartAnimator::addAnimation(AxisItem* item)
             {
                 ChartAnimation* animation = m_animations.value(item);
                 if(!animation) {
                     animation = new AxisAnimation(item);
                     m_animations.insert(item,animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::addAnimation(SplineChartItem*  item)
             {
                 ChartAnimation* animation = m_animations.value(item);
                 if(!animation) {
                     animation = new SplineAnimation(item);
                     m_animations.insert(item,animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::addAnimation(ScatterChartItem* item)
             {
                 ChartAnimation* animation = m_animations.value(item);
                 if(!animation) {
                     animation = new XYAnimation(item);
                     m_animations.insert(item,animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::addAnimation(LineChartItem*  item)
             {
                 ChartAnimation* animation = m_animations.value(item);
                 if(!animation) {
                     animation = new XYAnimation(item);
                     m_animations.insert(item,animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::addAnimation(PieChartItem* item)
             {
                 ChartAnimation* animation = m_animations.value(item);
                 if(!animation) {
                     animation = new PieAnimation(item);
                     m_animations.insert(item,animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::removeAnimation(ChartItem* item)
             {
                 item->setAnimator(0);
                 m_animations.remove(item);
             }
             void ChartAnimator::applyLayout(AxisItem* item , QVector<qreal>& newLayout)
             {
                 AxisAnimation* animation = static_cast<AxisAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 QVector<qreal> oldLayout = item->layout();
                 if(newLayout.count()==0) return;
                 switch(m_state)
             	{
                 	case ZoomOutState: {
                 			QRectF rect = item->geometry();
                 			oldLayout.resize(newLayout.count());
                 			for(int i=0,j=oldLayout.count()-1;i<(oldLayout.count()+1)/2;i++,j--)
                 			{
                 				oldLayout[i]= item->axisType()==AxisItem::X_AXIS?rect.left():rect.bottom();
                 				oldLayout[j]= item->axisType()==AxisItem::X_AXIS?rect.right():rect.top();
                 			}
                 		}
                 	break;
             		case ZoomInState: {
             			int index = qMin(oldLayout.count()*(item->axisType()==AxisItem::X_AXIS?m_point.x():(1 -m_point.y())),newLayout.count()-1.0);
             			oldLayout.resize(newLayout.count());
             			for(int i=0;i<oldLayout.count();i++)
             			{
             				oldLayout[i]= oldLayout[index];
             			}
             		}
             		break;
             		case ScrollDownState:
             		case ScrollRightState: {
             			oldLayout.resize(newLayout.count());
             			for(int i=0, j=i+1;i<oldLayout.count()-1;i++,j++)
             			{
             				oldLayout[i]= oldLayout[j];
             			}
             		}
             		break;
             		case ScrollUpState:
             		case ScrollLeftState: {
             			oldLayout.resize(newLayout.count());
             			for(int i=oldLayout.count()-1, j=i-1;i>0;i--,j--)
             			{
             				oldLayout[i]= oldLayout[j];
             			}
             		}
             		break;
             		default: {
             			oldLayout.resize(newLayout.count());
             			QRectF rect = item->geometry();
             			for(int i=0, j=oldLayout.count()-1;i<oldLayout.count();i++,j--)
             			{
             				oldLayout[i]= item->axisType()==AxisItem::X_AXIS?rect.left():rect.top();
             			}
             		}
             		break;
             	}
                 if(animation->state()!=QAbstractAnimation::Stopped) {
                     animation->stop();
                 }
                 animation->setDuration(duration);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 QVariantAnimation::KeyValues value;
                 animation->setKeyValues(value); //workaround for wrong interpolation call
                 animation->setKeyValueAt(0.0, qVariantFromValue(oldLayout));
                 animation->setKeyValueAt(1.0, qVariantFromValue(newLayout));
                 QTimer::singleShot(0,animation,SLOT(start()));
             }
             void ChartAnimator::updateLayout(SplineChartItem* item, QVector<QPointF>& oldPoints ,QVector<QPointF>& newPoints, QVector<QPointF>& oldControlPoints, QVector<QPointF>& newControlPoints,int index)
             {
                 SplineAnimation* animation = static_cast<SplineAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 if(newPoints.count()<2 || newControlPoints.count()<2) return;
                 bool empty = oldPoints.count()==0;
                 if(animation->state()!=QAbstractAnimation::Stopped) {
                      animation->stop();
                 }
                 animation->setDuration(duration);
                 if(!empty)
                 animation->setAnimationType(ChartAnimation::MoveDownAnimation);
                 else
                 animation->setAnimationType(ChartAnimation::LineDrawAnimation);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 animation->setValues(oldPoints,newPoints,oldControlPoints,newControlPoints,index);
                 QTimer::singleShot(0,animation,SLOT(start()));
             }
             void ChartAnimator::updateLayout(XYChartItem* item,  QVector<QPointF>& oldPoints , QVector<QPointF>& newPoints, int index)
             {
                 XYAnimation* animation = static_cast<XYAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 if(newPoints.count()==0) return;
                 bool empty = oldPoints.count()==0;
                 if(animation->state()!=QAbstractAnimation::Stopped) {
                     animation->stop();
                 }
                 animation->setDuration(duration);
                 if(!empty)
                 animation->setAnimationType(ChartAnimation::MoveDownAnimation);
                 else
                 animation->setAnimationType(ChartAnimation::LineDrawAnimation);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 animation->setValues(oldPoints,newPoints,index);
                 QTimer::singleShot(0,animation,SLOT(start()));
             }
-            void ChartAnimator::addAnimation(PieChartItem* item, QPieSlice *slice, PieSliceLayout &layout)
+            void ChartAnimator::addAnimation(PieChartItem* item, QPieSlice *slice, const PieSliceLayout &layout)
             {
                 PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->addSlice(slice, layout);
             }
             void ChartAnimator::removeAnimation(PieChartItem* item, QPieSlice *slice)
             {
                 PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->removeSlice(slice);
             }
-            void ChartAnimator::updateLayout(PieChartItem* item, QVector<PieSliceLayout> &layout)
+            void ChartAnimator::updateLayout(PieChartItem* item, const PieLayout &layout)
             {
                 PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->updateValues(layout);
             }
-            void ChartAnimator::updateLayout(PieChartItem* item, PieSliceLayout &layout)
+            void ChartAnimator::updateLayout(PieChartItem* item, QPieSlice *slice, const PieSliceLayout &layout)
             {
                 PieAnimation* animation = static_cast<PieAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
-                animation->updateValue(layout);
+                animation->updateValue(slice, layout);
             }
             void ChartAnimator::setState(State state,const QPointF& point)
             {
             	m_state=state;
             	m_point=point;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/chartanimator_p.h +3 -3

             #ifndef CHARTANIMATOR_P_H_
             #define CHARTANIMATOR_P_H_
             #include "qchartglobal.h"
             #include "chartanimation_p.h"
             #include "piechartitem_p.h"
             #include <QPointF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class AxisItem;
             class AreaChartItem;
             class SplineChartItem;
             class ScatterChartItem;
             class LineChartItem;
             class XYChartItem;
             class ChartAnimator : public QObject {
             public:
             	//TODO: this should be flags in case of two state at the time
             	enum State{ShowState, ScrollUpState, ScrollDownState, ScrollLeftState,ScrollRightState,ZoomInState,ZoomOutState};
                 ChartAnimator(QObject *parent = 0);
                 virtual ~ChartAnimator();
                 void addAnimation(AxisItem* item);
                 void addAnimation(PieChartItem* item);
                 void addAnimation(ScatterChartItem* item);
                 void addAnimation(LineChartItem* item);
                 void addAnimation(SplineChartItem* item);
                 void removeAnimation(ChartItem* item);
                 void animationStarted();
                 void updateLayout(XYChartItem* item, QVector<QPointF>& oldLayout,QVector<QPointF>& newLayout,int index);
                 void updateLayout(SplineChartItem* item,  QVector<QPointF>& oldPoints , QVector<QPointF>& newPoints, QVector<QPointF>& oldControlPoints, QVector<QPointF>& newContorlPoints,int index);
                 void applyLayout(AxisItem* item, QVector<qreal>& layout);
-                void addAnimation(PieChartItem* item, QPieSlice *slice, PieSliceLayout &layout);
+                void addAnimation(PieChartItem* item, QPieSlice *slice, const PieSliceLayout &layout);
                 void removeAnimation(PieChartItem* item, QPieSlice *slice);
-                void updateLayout(PieChartItem* item, QVector<PieSliceLayout> &layout);
+                void updateLayout(PieChartItem* item, const PieLayout &layout);
-                void updateLayout(PieChartItem* item, PieSliceLayout &layout);
+                void updateLayout(PieChartItem* item, QPieSlice *slice, const PieSliceLayout &layout);
                 void setState(State state,const QPointF& point = QPointF());
             private:
                  QMap<ChartItem*,ChartAnimation*> m_animations;
                  State m_state;
                  QPointF m_point;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/animations/pieanimation.cpp +7 -7

             #include "pieanimation_p.h"
             #include "piesliceanimation_p.h"
             #include "piechartitem_p.h"
             #include <QParallelAnimationGroup>
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieAnimation::PieAnimation(PieChartItem *item)
                 :ChartAnimation(item),
                 m_item(item)
             {
             }
             PieAnimation::~PieAnimation()
             {
             }
-            void PieAnimation::updateValues(QVector<PieSliceLayout>& newValues)
+            void PieAnimation::updateValues(const PieLayout &newValues)
             {
-                foreach (PieSliceLayout endLayout, newValues)
+                foreach (QPieSlice* s, newValues.keys())
-                    updateValue(endLayout);
+                    updateValue(s, newValues.value(s));
             }
-            void PieAnimation::updateValue(PieSliceLayout& endLayout)
+            void PieAnimation::updateValue(QPieSlice *slice, const PieSliceLayout &endLayout)
             {
-                PieSliceAnimation *animation = m_animations.value(endLayout.m_data);
+                PieSliceAnimation *animation = m_animations.value(slice);
                 Q_ASSERT(animation);
                 animation->stop();
                 animation->updateValue(endLayout);
                 animation->setDuration(1000);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
-            void PieAnimation::addSlice(QPieSlice *slice, PieSliceLayout endLayout)
+            void PieAnimation::addSlice(QPieSlice *slice, const PieSliceLayout &endLayout)
             {
-                PieSliceAnimation *animation = new PieSliceAnimation(m_item);
+                PieSliceAnimation *animation = new PieSliceAnimation(m_item, slice);
                 m_animations.insert(slice, animation);
                 PieSliceLayout startLayout = endLayout;
                 startLayout.m_radius = 0;
                 startLayout.m_startAngle = endLayout.m_startAngle + (endLayout.m_angleSpan/2);
                 startLayout.m_angleSpan = 0;
                 animation->setValue(startLayout, endLayout);
                 animation->setDuration(1000);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             void PieAnimation::removeSlice(QPieSlice *slice)
             {
                 PieSliceAnimation *animation = m_animations.value(slice);
                 Q_ASSERT(animation);
                 animation->stop();
                 PieSliceLayout endLayout = animation->currentSliceValue();
                 endLayout.m_radius = 0;
                 // TODO: find the actual angle where this slice disappears
                 endLayout.m_startAngle = endLayout.m_startAngle + endLayout.m_angleSpan;
                 endLayout.m_angleSpan = 0;
                 animation->updateValue(endLayout);
                 animation->setDuration(1000);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 connect(animation, SIGNAL(finished()), this, SLOT(destroySliceAnimationComplete()));
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             void PieAnimation::updateCurrentValue(const QVariant &)
             {
                 // nothing to do...
             }
             void PieAnimation::destroySliceAnimationComplete()
             {
                 PieSliceAnimation *animation = static_cast<PieSliceAnimation*>(sender());
                 QPieSlice *slice = m_animations.key(animation);
                 m_item->destroySlice(slice);
                 delete m_animations.take(slice);
             }
             #include "moc_pieanimation_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/pieanimation_p.h +3 -3

             #ifndef PIEANIMATION_P_H_
             #define PIEANIMATION_P_H_
             #include "chartanimation_p.h"
             #include "piechartitem_p.h"
             #include "piesliceanimation_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieChartItem;
             class PieAnimation : public ChartAnimation
             {
                 Q_OBJECT
             public:
                 PieAnimation(PieChartItem *item);
                 ~PieAnimation();
-                void updateValues(QVector<PieSliceLayout>& newValues);
+                void updateValues(const PieLayout &newValues);
-                void updateValue(PieSliceLayout& newValue);
+                void updateValue(QPieSlice *slice, const PieSliceLayout &newValue);
-                void addSlice(QPieSlice *slice, PieSliceLayout endLayout);
+                void addSlice(QPieSlice *slice, const PieSliceLayout &endLayout);
                 void removeSlice(QPieSlice *slice);
             public: // from QVariantAnimation
                 void updateCurrentValue(const QVariant &value);
             public Q_SLOTS:
                 void destroySliceAnimationComplete();
             private:
                 PieChartItem *m_item;
                 QHash<QPieSlice*, PieSliceAnimation*> m_animations;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/animations/piesliceanimation.cpp +6 -7

             #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);
             }
-            PieSliceAnimation::PieSliceAnimation(PieChartItem *item)
+            PieSliceAnimation::PieSliceAnimation(PieChartItem *item, QPieSlice *slice)
                 :QVariantAnimation(item),
-                m_item(item)
+                m_item(item),
+                m_slice(slice)
             {
             }
             PieSliceAnimation::~PieSliceAnimation()
             {
             }
-            void PieSliceAnimation::setValue(PieSliceLayout& startValue, PieSliceLayout& endValue)
+            void PieSliceAnimation::setValue(const PieSliceLayout &startValue, const PieSliceLayout &endValue)
             {
                 if (state() != QAbstractAnimation::Stopped)
                     stop();
                 setKeyValueAt(0.0, qVariantFromValue(startValue));
                 setKeyValueAt(1.0, qVariantFromValue(endValue));
             }
-            void PieSliceAnimation::updateValue(PieSliceLayout& endValue)
+            void PieSliceAnimation::updateValue(const PieSliceLayout &endValue)
             {
                 if (state() != QAbstractAnimation::Stopped)
                     stop();
-                //qDebug() << "PieSliceAnimation::updateValue()" << endValue.m_data->label() << currentSliceValue().m_startAngle << endValue.m_startAngle;
                 setKeyValueAt(0.0, qVariantFromValue(currentSliceValue()));
                 setKeyValueAt(1.0, qVariantFromValue(endValue));
             }
             PieSliceLayout PieSliceAnimation::currentSliceValue()
             {
                 return qVariantValue<PieSliceLayout>(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);
                 return qVariantFromValue(result);
             }
             void PieSliceAnimation::updateCurrentValue(const QVariant &value)
             {
                 PieSliceLayout layout = qVariantValue<PieSliceLayout>(value);
                 if (state() != QAbstractAnimation::Stopped) //workaround
-                    m_item->setLayout(layout);
+                    m_item->setLayout(m_slice, layout);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/piesliceanimation_p.h +5 -3

             #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);
+                PieSliceAnimation(PieChartItem *item, QPieSlice *slice);
                 ~PieSliceAnimation();
-                void setValue(PieSliceLayout& startValue, PieSliceLayout& endValue);
+                void setValue(const PieSliceLayout &startValue, const PieSliceLayout &endValue);
-                void updateValue(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;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/piechart/piechartitem.cpp +26 -27

             #include "piechartitem_p.h"
             #include "pieslice_p.h"
             #include "qpieslice.h"
             #include "qpieseries.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QDebug>
             #include <QPainter>
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieChartItem::PieChartItem(QGraphicsItem *parent, QPieSeries *series)
                 :ChartItem(parent),
                 m_series(series)
             {
                 Q_ASSERT(series);
                 connect(series, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleSlicesAdded(QList<QPieSlice*>)));
                 connect(series, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleSlicesRemoved(QList<QPieSlice*>)));
                 connect(series, SIGNAL(piePositionChanged()), this, SLOT(handlePieLayoutChanged()));
                 connect(series, SIGNAL(pieSizeChanged()), this, SLOT(handlePieLayoutChanged()));
                 QTimer::singleShot(0, this, SLOT(initialize()));
                 // Note: the following does not affect as long as the item does not have anything to paint
                 setZValue(ChartPresenter::PieSeriesZValue);
             }
             PieChartItem::~PieChartItem()
             {
                 // slices deleted automatically through QGraphicsItem
             }
             void PieChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
             {
                 Q_UNUSED(painter)
                 // TODO: paint shadows for all components
                 // - get paths from items & merge & offset and draw with shadow color?
                 //painter->setBrush(QBrush(Qt::red));
                 //painter->drawRect(m_debugRect);
             }
             void PieChartItem::initialize()
             {
                 handleSlicesAdded(m_series->m_slices);
             }
             void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices)
             {
                 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);
                     else
-                        setLayout(layout);
+                        setLayout(s, layout);
                 }
             }
             void PieChartItem::handleSlicesRemoved(QList<QPieSlice*> slices)
             {
                 foreach (QPieSlice *s, slices) {
                     if (m_animator)
                         m_animator->removeAnimation(this, s);
                     else
                         destroySlice(s);
                 }
             }
             void PieChartItem::handlePieLayoutChanged()
             {
-                QVector<PieSliceLayout> layout = calculateLayout();
+                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(layout);
+                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_data = slice;
                 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;
                 return sliceLayout;
             }
-            QVector<PieSliceLayout> PieChartItem::calculateLayout()
+            PieLayout PieChartItem::calculateLayout()
             {
                 calculatePieLayout();
-                QVector<PieSliceLayout> layout;
+                PieLayout  layout;
                 foreach (QPieSlice* s, m_series->slices()) {
                     if (m_slices.contains(s)) // calculate layout only for those slices that are already visible
-                        layout << calculateSliceLayout(s);
+                        layout.insert(s, calculateSliceLayout(s));
                 }
                 return layout;
             }
-            void PieChartItem::applyLayout(QVector<PieSliceLayout> &layout)
+            void PieChartItem::applyLayout(const PieLayout &layout)
             {
                 if (m_animator)
                     m_animator->updateLayout(this, layout);
                 else
                     setLayout(layout);
             }
-            void PieChartItem::updateLayout(PieSliceLayout &layout)
+            void PieChartItem::updateLayout(QPieSlice *slice, const PieSliceLayout &layout)
             {
                 if (m_animator)
-                    m_animator->updateLayout(this, layout);
+                    m_animator->updateLayout(this, slice, layout);
                 else
-                    setLayout(layout);
+                    setLayout(slice, layout);
             }
-            void PieChartItem::setLayout(QVector<PieSliceLayout> &layout)
+            void PieChartItem::setLayout(const PieLayout &layout)
             {
-                foreach (PieSliceLayout l, layout) {
+                foreach (QPieSlice *slice, layout.keys()) {
-                    PieSlice *slice = m_slices.value(l.m_data);
+                    PieSlice *s = m_slices.value(slice);
-                    Q_ASSERT(slice);
+                    Q_ASSERT(s);
-                    slice->setLayout(l);
+                    s->setLayout(layout.value(slice));
-                    slice->updateData(l.m_data);
+                    s->updateData(slice);
-                    slice->updateGeometry();
+                    s->updateGeometry();
-                    slice->update();
+                    s->update();
                 }
             }
-            void PieChartItem::setLayout(PieSliceLayout &layout)
+            void PieChartItem::setLayout(QPieSlice *slice, const PieSliceLayout &layout)
             {
                 // find slice
-                PieSlice *slice = m_slices.value(layout.m_data);
+                PieSlice *s = m_slices.value(slice);
-                Q_ASSERT(slice);
+                Q_ASSERT(s);
-                slice->setLayout(layout);
+                s->setLayout(layout);
-                if (m_series->m_slices.contains(layout.m_data)) // Slice has been deleted if not found. Animations ongoing...
+                if (m_series->m_slices.contains(slice)) // Slice has been deleted if not found. Animations ongoing...
-                    slice->updateData(layout.m_data);
+                    s->updateData(slice);
-                slice->updateGeometry();
+                s->updateGeometry();
-                slice->update();
+                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 +7 -5

             #ifndef PIECHARTITEM_H
             #define PIECHARTITEM_H
             #include "qpieseries.h"
             #include "chartitem_p.h"
             #include "pieslice_p.h"
             class QGraphicsItem;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSlice;
+            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();
             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);
-                QVector<PieSliceLayout> calculateLayout();
+                PieLayout calculateLayout();
-                void applyLayout(QVector<PieSliceLayout> &layout);
+                void applyLayout(const PieLayout &layout);
-                void updateLayout(PieSliceLayout &layout);
+                void updateLayout(QPieSlice *slice, const PieSliceLayout &layout);
-                void setLayout(QVector<PieSliceLayout> &layout);
+                void setLayout(const PieLayout &layout);
-                void setLayout(PieSliceLayout &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;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIECHARTITEM_H

src/piechart/pieslice_p.h 0 -1

             #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:
-                QPieSlice* m_data; // TODO: get rid of this
                 QPointF m_center;
                 qreal m_radius;
                 qreal m_startAngle;
                 qreal m_angleSpan;
             };
             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